C++模拟实现string

C++教学总目录

1、成员变量

class string
{
public:

private:
	char* _str;
	size_t _size;
	size_t _capacity;
public:
	const static size_t npos = -1;
};

_str用来存储字符串,_size表示当前有效字符个数(不包括\0),_capacity表示当前空间大小(实际上开空间要多1,因为要存储\0,但是并不计算在_capacity中)。npos这里由于是const static,所以可以给缺省值初始化。


2、构造函数和析构函数

构造函数我们可以实现无参的和带参的,为了方便,我们直接实现带参缺省构造函数,这样子无参可以调,带参也可以调,也有默认构造函数。
由于string类需要动态开辟空间存储字符串,所以析构函数需要实现资源的清理。

string(const char* str = "")
	:_size(strlen(str))
	, _capacity(_size)
{
	_str = new char[_capacity + 1];
	memcpy(_str, str, _size + 1);
}

~string()
{
	delete[] _str;
	_size = _capacity = 0;
}

_str不在初始化列表开辟空间是因为需要调用strlen,而调用strlen时间复杂度是O(N),消耗大。这里使用memcpy,其实也可以使用strcpy,但是使用strcpy遇到\0就会结束,而使用memcpy由于给定了字符个数,所以哪怕遇到\0也不会结束,后面使用memcpy也是一样的,就不再赘述。这里开的空间为_capacity+1是因为还要存储\0,后面一样不再赘述。


3、swap函数

swap函数是用来交换string内的成员变量的,复用std内的swap函数。

void swap(string& s)
{
	std::swap(_str, s._str);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}

4、拷贝构造函数和赋值运算符重载

这两个函数不能使用编译器默认生成的,因为默认生成的是值拷贝——也就是浅拷贝,会有两个问题:1、析构两次,导致程序崩溃。2、修改其中一个的值会影响另一个。所以我们需要自己实现深拷贝,如下图:
在这里插入图片描述

这里有两种写法,分为传统写法和现代写法。另外对于&重载和const &重载用默认生成的就好。

// 传统写法
string(const string& s)
	:_str(new char[s._capacity + 1])
	,_size(s._size)
	,_capacity(s._capacity)
{
	memcpy(_str, s._str, s._size + 1);
}

string& operator=(const string& s)
{
	if (this != &s)
	{
		char* tmp = new char[s._capacity + 1];
		memcpy(tmp, s._str, s._size + 1);
		delete[] _str;
		_str = tmp;
		_size = s._size;
		_capacity = s._capacity;
	}
	return *this;
}
// 现代写法
string(const string& s)
	:_str(nullptr)
	, _size(0)
	, _capacity(0)
{
	string tmp(s._str);
	swap(tmp);
}

string& operator=(string s)
{
	swap(s);
	return *this;
}

现代写法的构造函数首先在初始化列表将_str置空,并且把_size和_capacity置为0,然后用构造函数构造出一个临时对象,然后调用swap交换。这样当出了构造函数,tmp也不会被析构,因为_str指向的是空。实际上就是通过复用默认构造函数来实现的。但是这个写法有个bug,那就是遇到字符串里面带\0就会出问题。
赋值运算符重载函数直接拷贝构造一个对象s,然后交换他们的值,这样当函数调用结束,即完成了赋值操作,也完成了把原来对象销毁的操作,一举两得。


5、size、capacity、c_str、empty、clear函数

注意,只要不修改成员变量,我们统一加上const。

const char* c_str() const { return _str; }
size_t size() const { return _size; }
size_t capacity() const { return _capacity; }
bool empty() const { return _size == 0; }

void clear()
{
	_str[0] = '\0';
	_size = 0;
}

6、重载operator[]函数

需要实现两个,一个是普通对象,另一个是const对象。

char& operator[](size_t pos)
{
	assert(pos < _size);
	return _str[pos];
}

const char& operator[](size_t pos) const
{
	assert(pos < _size);
	return _str[pos];
}

7、reserve和resize函数

我们可以先实现reserve函数,然后在resize函数中复用reserve。

void reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];
		memcpy(tmp, _str, _size + 1);
		delete[] _str;
		_str = tmp;
		_capacity = n;
	}
}

void resize(size_t n, char ch = '\0')
{
	if (n < _size)
	{
		_str[n] = '\0';
		_size = n;
	}
	else
	{
		reserve(n);
		memset(_str + _size, ch, n - _size);
		_size = n;
		_str[_size] = '\0';
	}
}

reserve在扩容前先判断n是否大于当前容量,如果大于就扩容,并且释放掉原来的空间,修改_capacity的值。
resize如果小于_size直接赋值\0,然后修改_size。如果大于_size,直接调用reserve,因为reserve里面会对扩容进行判断,这里可以省去一步判断。然后将赋值的字符通过memset赋值到n,最后要记得结尾加上\0。


8、push_back和append函数

push_back是在尾部插入一个字符,append是在尾部插入字符串。并且要先判断是否需要扩容。

void push_back(char ch)
{
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	_str[_size++] = ch;
	_str[_size] = '\0';
}

void append(const char* str)
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	memcpy(_str + _size, str, len + 1);
	_size += len;
}

9、重载operator+=函数

我们实现两个重载就好,一个是单个字符的,一个是字符串。实际上只要复用上面的两个函数就好了。

string& operator+=(char ch)
{
	push_back(ch);
	return *this;
}

string& operator+=(const char* str)
{
	append(str);
	return *this;
}

10、insert函数

我们实现三个,分别为:在pos位置插入一个字符、在pos位置插入n个字符、在pos位置插入一个字符串。

string& insert(size_t pos, char ch)
{
	assert(pos <= _size);
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	size_t end = _size + 1;
	while (end > pos)
	{
		_str[end] = _str[end - 1];
		--end;
	}
	_str[pos] = ch;
	_size++;
	return *this;
}

string& insert(size_t pos, size_t n, char ch)
{
	assert(pos <= _size);
	if (n + _size > _capacity)
	{
		reserve(n + _size);
	}
	size_t end = _size;
	while (end >= pos && end != npos)
	{
		_str[end + n] = _str[end];
		end--;
	}
	memset(_str + pos, ch, n);
	_size += n;
	return *this;
}

string& insert(size_t pos, const char* str)
{
	assert(pos <= _size);
	size_t len = strlen(str);
	if (len + _size > _capacity)
	{
		reserve(len + _size);
	}
	size_t end = _size;
	while (end >= pos && end != npos)
	{
		_str[end + len] = _str[end];
		--end;
	}
	memcpy(_str + pos, str, len);
	_size += len;
	return *this;
}

这里有个坑,就是while循环条件不能写成end>= pos这样会出问题,如下图:
在这里插入图片描述


11、erase函数

我们就实现一个erase,在pos位置删除len个字符。

string& erase(size_t pos, size_t len = npos)
{
	assert(pos <= _size);
	if (len == npos || pos + len >= _size)
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		size_t end = pos + len;
		while (end <= _size)
		{
			_str[pos++] = _str[end++];
		}
		_size -= len;
	}
	return *this;
}

开始的断言可以=_size,因为如果=_size的时候,会直接进入if语句中,所以并没有影响。官方实现的也是可以删除_size位置的。


12、find函数

实现两个函数:查找单个字符、查找字符串。查找字符串我们可以复用strstr,另外我提供了一种使用kmp查找子串的算法。(有兴趣的可以去了解了解kmp算法)

size_t find(char ch, size_t pos = 0) const
{
	assert(pos < _size);
	for (size_t i = pos; i < _size; i++)
	{
		if (_str[i] == ch) return i;
	}
	return npos;
}

size_t find(const char* str, size_t pos = 0) const
{
	assert(pos < _size);
	const char* ptr = strstr(_str + pos, str);
	if (ptr) return ptr - _str;
	else return npos;
}

 寻找子串——KMP算法
//size_t find(const char* str, size_t pos = 0) const
//{
//	assert(str);
//	assert(pos < _size);
//	size_t len = strlen(str);
//	int* ne = new int[len];
//	ne[0] = -1;
//	for (int i = 0, j = -1; i < len; i++)
//	{
//		while (j != -1 && str[i] != str[j + 1]) j = ne[j];
//		if (str[i] == str[j + 1]) j++;
//		ne[i] = j;
//	}
//	for (int i = 0, j = -1; i < _size; i++)
//	{
//		while (j != -1 && _str[i] != str[j + 1]) j = ne[j];
//		if (_str[i] == str[j + 1]) j++;
//		if (j == len - 1)
//		{
//			return i - len + 1;
//		}
//	}
//	return npos;
//}

13、substr函数

substr函数是用来获取字串的,参数为pos和len,表示从pos位置获取长度为len的字串。

string substr(size_t pos, size_t len = npos) const
{
	assert(pos < _size);
	size_t n = len;
	if (len == npos || pos + len > _size)
	{
		n = _size - pos;
	}
	string sub;
	sub.reserve(n);
	for (size_t i = pos; i <= pos + n; i++)
	{
		sub += _str[i];
	}
	return sub;
}

提前reserve开空间,防止频繁扩容。


14、六个比较函数

同之前日期类,我们只需要实现> ==或者< ==,剩下四个完成复用即可。

bool operator<(const string& s) const
{
	int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
	return ret == 0 ? _size < s._size : ret < 0;
}

bool operator==(const string& s) const
{
	return _size == s._size
		&& memcmp(_str, s._str, _size) == 0;
}

bool operator<=(const string& s) const
{
	return *this < s || *this == s;
}

bool operator>(const string& s) const
{
	return !(*this <= s);
}

bool operator>=(const string& s) const
{
	return !(*this < s);
}

bool operator!=(const string& s) const
{
	return !(*this == s);
}

使用memcmp是为了防止字符串中有\0,通过返回值进行判断。如果ret=0,有可能两个字符串长度相同刚好相等,也有可能前面都相等,但是有一个字符串更长。所以需要判断_size和s._size的大小,直接返回_size < s._size(如果_size确实比s._size小,说明两个字符串前面都相等,但是字符串s更长,所以返回true。否则就是两个字符串相等,返回false)。如果ret不为0,直接返回ret<0(如果ret确实小于0,那就是返回true,如果是>0,就是返回false)。
判断两个字符串是否相等:首先要满足两个字符串的_size都要相等,然后再满足memcmp的返回值为0。

这里使用了memcmp是因为考虑了字符串中间可能出现\0的情况,如果要简单考虑直接使用strcmp即可,但是strcmp遇到\0就会停止。其实这里跟上面的构造函数拷贝构造函数,包括拷贝数据、挪动数据等使用的mem系列函数是一样的,都是为了避免中间出现\0的情况,如果简单考虑直接使用str系列函数即可。


15、重载<<(流插入)和>>(流提取)运算符

这次虽然将<<和>>重载在类外,但实际上并不需要友元函数。因为在operator<<中可以使用范围for或者operator[]来访问元素输出,在operator>>中可以调用+=。

ostream& operator<<(ostream& out, const string& s)
{
	for (const auto& e : s)
	{
		out << e;
	}
	return out;
}

istream& operator>>(istream& in, string& s)
{
	s.clear();
	char ch = in.get();
	while (ch == ' ' || ch == '\n')
	{
		ch = in.get();
	}
	char buff[128];
	int i = 0;
	while (ch != ' ' && ch != '\n')
	{
		buff[i++] = ch;
		if (i == 127)
		{
			buff[i] = '\0';
			s += buff;
			i = 0;
		}
		ch = in.get();
	}
	if (i)
	{
		buff[i] = '\0';
		s += buff;
	}
	return in;
}

重载流提取有几个需要注意的点:
1、首先要clear将s的内容全部清空。
2、由于使用cin读取是不能读取空格和换行的,所以我们调用cin.get函数,它可以读取空格和换行。
3、在读取数据之前,缓冲区中可能有空格或者换行,我们需要先清除,第一个while函数就是用来处理空格和换行的。
4、开始读取数据后,遇到空格和换行就要结束。
5、我们通过调用+=,这样就不需要实现成友元了。但是为了减少string的频繁扩容,我们创建一个128字节的数组来存储读取数据,每次读满了就调用s.operator+=。这样可以减少string的扩容。
6、最后遇到空格或换行出循环,buff中可能还有数据,需要在调用一次operator+=。


16、迭代器

string类的迭代器可以是指针,所以我们直接使用char*指针来实现正向迭代器。
反向迭代器后面会补充,反向迭代器需要创建自定义类型来实现。

typedef char* iterator;
typedef const char* const_iterator;

iterator begin() { return _str; }
iterator end() { return _str + _size; }
const_iterator begin() const { return _str; }
const_iterator end() const { return _str + _size; }

完整代码(包含测试代码)

#pragma once

namespace zzy
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin() { return _str; }
		iterator end() { return _str + _size; }
		const_iterator begin() const { return _str; }
		const_iterator end() const { return _str + _size; }

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			memcpy(_str, str, _size + 1);
		}

		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

		string(const string& s)
			:_str(new char[s._capacity + 1])
			,_size(s._size)
			,_capacity(s._capacity)
		{
			memcpy(_str, s._str, s._size + 1);
		}

		string& operator=(const string& s)
		{
			if (this != &s)
			{
				char* tmp = new char[s._capacity + 1];
				memcpy(tmp, s._str, s._size + 1);
				delete[] _str;
				_str = tmp;
				_size = s._size;
				_capacity = s._capacity;
			}
			return *this;
		}

		//string(const string& s)
		//	:_str(nullptr)
		//	, _size(0)
		//	, _capacity(0)
		//{
		//	string tmp(s._str);
		//	swap(tmp);
		//}

		//string& operator=(string s)
		//{
		//	swap(s);
		//	return *this;
		//}

		~string()
		{
			delete[] _str;
			_size = _capacity = 0;
		}

		const char* c_str() const { return _str; }
		size_t size() const { return _size; }
		size_t capacity() const { return _capacity; }
		bool empty() const { return _size == 0; }

		void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		const char& operator[](size_t pos) const
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				memcpy(tmp, _str, _size + 1);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}

		void resize(size_t n, char ch = '\0')
		{
			if (n < _size)
			{
				_str[n] = '\0';
				_size = n;
			}
			else
			{
				reserve(n);
				memset(_str + _size, ch, n - _size);
				_size = n;
				_str[_size] = '\0';
			}
		}

		void push_back(char ch)
		{
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			_str[_size++] = ch;
			_str[_size] = '\0';
		}

		void append(const char* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			memcpy(_str + _size, str, len + 1);
			_size += len;
		}

		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}

		string& insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			size_t end = _size + 1;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				--end;
			}
			_str[pos] = ch;
			_size++;
			return *this;
		}

		string& insert(size_t pos, size_t n, char ch)
		{
			assert(pos <= _size);
			if (n + _size > _capacity)
			{
				reserve(n + _size);
			}
			size_t end = _size;
			while (end >= pos && end != npos)
			{
				_str[end + n] = _str[end];
				end--;
			}
			memset(_str + pos, ch, n);
			_size += n;
			return *this;
		}

		string& insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (len + _size > _capacity)
			{
				reserve(len + _size);
			}
			size_t end = _size;
			while (end >= pos && end != npos)
			{
				_str[end + len] = _str[end];
				--end;
			}
			memcpy(_str + pos, str, len);
			_size += len;
			return *this;
		}

		string& erase(size_t pos, size_t len = npos)
		{
			assert(pos <= _size);
			if (len == npos || pos + len >= _size)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				size_t end = pos + len;
				while (end <= _size)
				{
					_str[pos++] = _str[end++];
				}
				_size -= len;
			}
			return *this;
		}

		size_t find(char ch, size_t pos = 0) const
		{
			assert(pos < _size);
			for (size_t i = pos; i < _size; i++)
			{
				if (_str[i] == ch) return i;
			}
			return npos;
		}

		size_t find(const char* str, size_t pos = 0) const
		{
			assert(pos < _size);
			const char* ptr = strstr(_str + pos, str);
			if (ptr) return ptr - _str;
			else return npos;
		}

		string substr(size_t pos = 0, size_t len = npos) const
		{
			assert(pos < _size);
			size_t n = len;
			if (len == npos || pos + len > _size)
			{
				n = _size - pos;
			}
			string sub;
			sub.reserve(n);
			for (size_t i = pos; i < pos + n; i++)
			{
				sub += _str[i];
			}
			return sub;
		}

		bool operator<(const string& s) const
		{
			int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
			return ret == 0 ? _size < s._size : ret < 0;
		}

		bool operator==(const string& s) const
		{
			return _size == s._size
				&& memcmp(_str, s._str, _size) == 0;
		}

		bool operator<=(const string& s) const
		{
			return *this < s || *this == s;
		}

		bool operator>(const string& s) const
		{
			return !(*this <= s);
		}

		bool operator>=(const string& s) const
		{
			return !(*this < s);
		}

		bool operator!=(const string& s) const
		{
			return !(*this == s);
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	public:
		const static size_t npos = -1;
	};

	ostream& operator<<(ostream& out, const string& s)
	{
		for (const auto& e : s)
		{
			out << e;
		}
		return out;
	}

	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		char ch = in.get();
		while (ch == ' ' || ch == '\n')
		{
			ch = in.get();
		}
		char buff[128];
		int i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}
			ch = in.get();
		}
		if (i)
		{
			buff[i] = '\0';
			s += buff;
		}
		return in;
	}


	void test_string1()
	{
		zzy::string s1("hello world");
		cout << s1.c_str() << endl;

		zzy::string s2;
		cout << s2.c_str() << endl;

		for (size_t i = 0; i < s1.size(); i++)
		{
			s1[i]++;
		}
		cout << endl;

		for (size_t i = 0; i < s1.size(); i++)
		{
			cout << s1[i] << " ";
		}
		cout << endl;

		const zzy::string s3("hello world");
		s3[0];

		//zzy::string::const_iterator cit = s3.begin();
		auto cit = s3.begin();
		while (cit != s3.end())
		{
			//*cit += 1;

			cout << *cit << " ";
			++cit;
		}
		cout << endl;

		zzy::string::iterator it = s1.begin();
		while (it != s1.end())
		{
			*it += 1;

			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto ch : s1)
		{
			cout << ch << " ";
		}
		cout << endl;
	}

	void test_string2()
	{

		zzy::string s1("hello world");
		cout << s1.c_str() << endl;

		s1.push_back(' ');
		s1.push_back('#');
		s1.append("hello zzy");
		cout << s1.c_str() << endl;

		zzy::string s2("hello world");
		cout << s2.c_str() << endl;

		s2 += ' ';
		s2 += '#';
		s2 += "hello zzy";
		cout << s2.c_str() << endl;
	}

	void test_string3()
	{
		zzy::string s1("helloworld");
		cout << s1.c_str() << endl;

		s1.insert(5, 3, '#');
		cout << s1.c_str() << endl;

		s1.insert(0, 3, '#');
		cout << s1.c_str() << endl;


		zzy::string s2("helloworld");
		s2.insert(5, "%%%%%");
		cout << s2.c_str() << endl;
	}

	void test_string4()
	{
		zzy::string s1("helloworld");
		cout << s1.c_str() << endl;

		s1.erase(5, 3);
		cout << s1.c_str() << endl;

		s1.erase(5, 30);
		cout << s1.c_str() << endl;

		s1.erase(2);
		cout << s1.c_str() << endl;
	}

	void test_string5()
	{
		zzy::string url = "ftp://www.baidu.com/?tn=65081411_1_oem_dg";

		size_t pos1 = url.find("://");
		if (pos1 != zzy::string::npos)
		{
			zzy::string protocol = url.substr(0, pos1);
			cout << protocol.c_str() << endl;
		}

		size_t pos2 = url.find('/', pos1 + 3);
		if (pos2 != zzy::string::npos)
		{
			zzy::string domain = url.substr(pos1 + 3, pos2 - (pos1 + 3));
			zzy::string uri = url.substr(pos2 + 1);

			cout << domain.c_str() << endl;
			cout << uri.c_str() << endl;
		}
	}

	void test_string6()
	{
		zzy::string s("hello world");
		s.resize(8);
		cout << s.c_str() << endl;
		cout << s << endl;

		s.resize(13, 'x');
		cout << s.c_str() << endl;
		cout << s << endl;

		s.resize(20, 'y');
		cout << s.c_str() << endl;
		cout << s << endl;

		// c的字符数组,以\0为终止算长度
		// string不看\0,以size为终止算长度

		zzy::string ss("hello world");
		ss += '\0';
		ss += "!!!!!!!!!!";
		cout << ss.c_str() << endl;
		cout << ss << endl;

		zzy::string copy(ss);
		cout << ss << endl;
		cout << copy << endl;

		ss += "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
		cout << ss << endl;
	}

	void test_string7()
	{
		zzy::string s;
		cin >> s;
		cout << s << endl;

		cin >> s;
		cout << s << endl;

		//char buff[128];
		//for (size_t i = 0; i < 5; i++)
		//{
		//	cin >> buff[i];
		//}

		//for (size_t i = 0; i < 5; i++)
		//{
		//	cout << buff[i] << endl;
		//}
	}

	void test_string8()
	{
		//string s1("bb");
		//string s2("aaa");
		//cout << (s1 < s2) << endl;

		zzy::string s1("hello");
		zzy::string s2("hello");
		cout << (s1 < s2) << endl;
		cout << (s1 > s2) << endl;
		cout << (s1 == s2) << endl << endl;


		zzy::string s3("hello");
		zzy::string s4("helloxxx");
		cout << (s3 < s4) << endl;
		cout << (s3 > s4) << endl;
		cout << (s3 == s4) << endl << endl;


		zzy::string s5("helloxxx");
		zzy::string s6("hello");
		cout << (s5 < s6) << endl;
		cout << (s5 > s6) << endl;
		cout << (s5 == s6) << endl << endl;

		zzy::string s7("hello");
		s7 += '\0';
		s7 += 'a';
		zzy::string s8("hello");
		s8 += '\0';
		s8 += 'b';
		cout << (s7 < s8) << endl;
		cout << (s7 > s8) << endl;
		cout << (s7 == s8) << endl;
	}

	void test_string9()
	{
		zzy::string s1("hello");
		zzy::string s2(s1);

		cout << s1 << endl;
		cout << s2 << endl;

		zzy::string s3("xxxxxxxxxxxxx");
		s1 = s3;

		cout << s1 << endl;
		cout << s3 << endl;
	}

	void test_string10()
	{
		zzy::string s = "hello world";
		for (auto e : s) cout << e;
		cout << endl;

		zzy::string::iterator it1 = s.begin();
		while (it1 != s.end())
		{
			cout << *it1;
			++it1;
		}
		cout << endl;

		zzy::string::const_iterator it2 = s.begin();
		while (it2 != s.end())
		{
			cout << *it2;
			it2++;
		}
		cout << endl;
	}
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值