• ＜C++＞ 模拟实现string

    目录

    前言

    一、模拟实现string

    1. 成员变量

    2. 构造函数

    2.1 构造函数

    2.2 重载默认构造 

    2.3 合并

    3. 析构函数 

    4. 拷贝构造函数 

    5. c_str

    6. size

    7. operator[ ] 

    7.1 普通版

    7.2 const版本 

    8. 迭代器—iterator 

    8.1 普通版iterator

    8.2 const版本iterator

    9. 尾插

    10. operator+=

    11. insert

    11.1 插入n个字符 

    11.2 插入字符串 

    12. erase 

    12.1 从pos位置开始删除

    13. find

    13.1 查找字符

    13.2 查找字符串

    14. substr 

    15. reseve && resize

    16. operator<< 流插入

    17. operator>> 流提取

    18. string比较

    19. operator= 赋值运算符重载

     二、整体代码

    总结

    ​

    前言

            学习了string的用法，为了提升自身能力，我们来模拟实现string的部分功能

    一、模拟实现string

    初始化列表初始化顺序是声明顺序！

    我们将自己实现的string放在自己的命名空间内，防止与std中的string冲突

    1. namespace my_string
    2. {
    3. 	class string
    4. 	{
    5.  
    6. 	};
    7. };

    1. 成员变量

    1. private:
    2. 		char* _str;
    3. 		size_t _size;
    4. 		size_t _capacity;

    2. 构造函数

     2.1 构造函数

    构造函数功能：为字符串开空间，并根据传入的参数进行初始化操作。

            此处会出现一些问题，当我们使用初始化列表时，每个人的初始化顺序可能不同，并且成员变量的声明顺序也可能不同，编写完代码后，发现出错，代码不能跑，这就是初始化列表的知识点——初始化列表的初始化顺序由成员变量的声明顺序决定。

            并且为了少次使用strlen这一O(N)级函数，我们可以只将一个变量在初始化列表初始化，其他成员在函数内赋值（以达到少次使用strlen函数），这是因为这些成员变量是内置类型（内置类型在列表或构造函数体内初始化区别不大），如果是自定义类型则不能在内部赋值，因为即使不写，它们仍然会被自动调用各自的构造函数。

            这里我们将全部的成员变量都放在函数体内赋值，以便代码清晰。

    1. namespace my_string
    2. {
    3. 	class string
    4. 	{
    5. 	public:
    6. 		string(const char* str)
    7. 		{
    8.             _size = strlen(str);
    9. 			_capacity = _size;
    10.             //加1，存放\0
    11. 			_str = new char[_capacity + 1];
    12. 			strcpy(_str, str);
    13. 		}
    14.  
    15. 	private:
    16. 		size_t _size;
    17. 		size_t _capacity;
    18. 		char* _str;
    19. 	};
    20. };

    2.2 重载默认构造 

            那么，当我们不传参构造，只实例化时，编译器找不到默认构造函数，所以我们要重载一个默认构造函数。

            根据监视，可以看到C++的string在无参构造时，它是有一个‘\0'的，所以我们在初始化_str时不能置空，要至少开一个空间，来存储 '\0'

    1. string(const char* str)
    2. 	:_size(0)
    3. 	,_capacity(0)
    4. 	,_str(new char[1])
    5. {
    6. 	_str[0] = '\0';
    7. }

     2.3 合并

    我们可以使用缺省值，将两个构造函数合并

    这里的问题在于，如何设置缺省值？是 '\0' ，还是 nullptr， 还是 "\0" ？

    1. '\0' 不可以，问题在于左边类型为char*，而'\0'是字符，两者类型不同
    2. nullptr 也不可以，问题在于后面的strlen直接失效，并且没有 '\0'
    3. "\0" 不太合适，因为 “” 内默认有\0，所以缺省值应为“”
    1. string(const char* str = "")
    2. {
    3. 	_size = strlen(str);
    4. 	_capacity = _size;
    5. 	_str = new char[_capacity + 1];
    6. 	strcpy(_str, str);
    7. }

    注意：该构造函数代码之后会在operator<<处再次修改 

    3. 析构函数 

    • 释放new出的空间，并将_size与_capacity置空即可
    1. ~string()
    2. {
    3. 	delete[] _str;
    4. 	_str = nullptr;
    5. 	_size = _capacity = 0;
    6. }

    4. 拷贝构造函数 

    1. //拷贝构造
    2. string(const string& s)
    3. {
    4. 	_str = new char[s._capacity + 1];
    5. 	strcpy(_str, s._str);
    6. 	_size = s._size;
    7. 	_capacity = s._capacity;
    8. }

    注意：该构造函数代码之后会在operator<<处再次修改  

    5. c_str

    •  模拟string中的c_str函数功能，返回c形式的字符串，即返回 _str
    • 在函数后面加上const，可以使被const修饰的对象也可调用该函数
    1. const char* c_str() const
    2. {
    3.     return _str;
    4. }

    6. size

    •  返回_size即可
    1. size_t size() const
    2. {
    3. 	return _size;
    4. }

    7. operator[ ] 

    7.1 普通版

    • 为了可读可写，我们使用引用返回，因为返回的对象是数组内的元素，生命周期不在operator[ ]函数内，所以可以使用引用返回
    1. char& operator[](size_t pos)
    2. {
    3. 	assert(pos < _size);
    4.  
    5. 	return _str[pos];
    6. }

    7.2 const版本 

    • const版本只能读，与普通版本形成函数重载，调用函数时，编译器会调用最匹配的函数
    1. //const版本 只读
    2. const char& operator[](size_t pos) const
    3. {
    4. 	assert(pos < _size);
    5.  
    6. 	return _str[pos];
    7. }

    8. 迭代器—iterator 

    8.1 普通版iterator

    • 对于string类，迭代器可以使用指针实现，即迭代器就是指针（针对string类）
    1. //迭代器，在string这里就是指针
    2. typedef char* iterator;
    3.  
    4. iterator begin()
    5. {
    6. 	return _str;
    7. }
    8.  
    9. iterator end()
    10. {
    11. 	return _str + _size;
    12. }

     测试：

    1. #include
    2. #include"string模拟.h"
    3. using namespace my_string;
    4. using std::cout;
    5. using std::endl;
    6.  
    7. void test()
    8. {
    9. 	my_string::string s1("hello world");
    10. 	cout << s1.c_str() << endl;
    11.  
    12. 	string::iterator it = s1.begin();
    13. 	while (it != s1.end())
    14. 	{
    15. 		cout << *it << " ";
    16. 		++it;
    17. 	}
    18. 	cout << endl;
    19.  
    20. 	for (auto ch : s1)
    21. 	{
    22. 		cout << ch << "";
    23. 	}
    24. 	cout << endl;
    25. }
    1. hello world
    2. h e l l o  w o r l d
    3. hello world

    可以看到，我们在写完迭代器之后，范围for就可以直接使用了，因为它就是利用迭代器实现的，底层与使用迭代器遍历几乎一样。 

    如果我们把end()，改为End()，那么范围for就不可用了。所以，范围for是傻瓜式替换，找到类中的begin()，end()，字母错一个它都实现不了。

    8.2 const版本iterator

    • 当对象被const修饰，那么迭代器就要加上const，保证值不被修改
    1. typedef const char* const_iterator;
    2. const_iterator begin() const
    3. {
    4. 	return _str;
    5. }
    6.  
    7. const_iterator end() const
    8. {
    9. 	return _str + _size;
    10. }
    1. string::const_iterator cit = s1.begin();
    2. while (cit != s1.end())
    3. {
    4. 	cout << *cit << endl;
    5. 	++cit;
    6. }
    7. cout << endl;

     9. 尾插

    1. 判断是否要扩容，对于push_back() 函数可以进行2倍扩容；对于append() 函数，要进行大小判断，如果_size + strlen(str) > _ capacity 那么至少扩容到_size + len 的容量大小。
    2. 对于扩容操作，我们实现reserve() 函数，进行扩容处理
    1. void reserve(size_t n)
    2. {
    3. 	if (n > _capacity)
    4. 	{
    5.         //多开一个空间留给 '\0'
    6. 		char* tmp = new char[n + 1];
    7. 		strcpy(tmp, _str);
    8. 		delete[] _str;
    9. 		_str = tmp;
    10. 		_capacity = n;
    11. 	}
    12. }
    13.  
    14. void push_back(char ch)
    15. {
    16. 	if (_size == _capacity)
    17. 	{
    18. 		reserve(_capacity == 0 ? 4 : _capacity * 2);
    19. 	}
    20.  
    21. 	_str[_size] = ch;
    22. 	++_size;
    23. 	_str[_size] = '\0';
    24. }
    25.  
    26. void append(const char* str)
    27. {
    28. 	size_t len = strlen(str);
    29. 	if (_size + len > _capacity)
    30. 	{
    31. 		reserve(_size + len);
    32. 	}
    33.  
    34. 	strcpy(_str + _size, str);
    35. 	_size += len;
    36. }

     10. operator+=

    • 实现尾插之后，operator+=的实现就非常简单了，+=是有返回值的，返回的是string类型
    • 可以返回*this，因为*this是对象，对象的生命周期不在operator+=中，所以可以返回*this
    1. string& operator+=(char ch)
    2. {
    3. 	push_back(ch);
    4. 	return *this;
    5. }
    6.  
    7. string& operator+=(const char* str)
    8. {
    9. 	append(str);
    10. 	return *this;
    11. }

     11. insert

    1. 先判断下标是否合法
    2. 再判断是否要扩容
    3. 移位，移位时有“坑”，因为是size_t 类型，大于等于0，-1是最大正数，如果end改为int类型也不行，因为会发生隐式类型转换。这里有多种解决方案：可以强制类型转换、可以将end从end+n开始，进行end - n 赋给 end ，这样就不会到下标为0的地方、用npos判断（npos使用静态成员函数，赋值为-1，表示最大值）
    4. 插入数据
    5. 更新_size

    11.1 插入n个字符 

    1. void insert(size_t pos, size_t n, char ch)
    2. {
    3. 	//size_t大于0，不用判断
    4. 	assert(pos <= _size);
    5. 	if (_size + n > _capacity)
    6. 	{
    7. 		//至少扩容到 _size + n
    8. 		reserve(_size + n);
    9. 	}
    10. 	size_t end = _size;
    11. 	//size_t因为不小于0，当pos为0时，会陷入死循环
    12. 	//这里有多种方案，可以强制类型转换、可以将end从end+n开始、用npos判断
    13. 	while (end >= pos && end != npos)
    14. 	{
    15. 		_str[end + n] = _str[end];
    16. 		--end;
    17. 	}
    18.  
    19. 	for (size_t i = 0; i < n; i++)
    20. 	{
    21. 		_str[pos + i] = ch;
    22. 	}
    23.  
    24. 	_size += n;
    25. }

    11.2 插入字符串 

    • 同理，将n替换为len即可
    1. void insert(size_t pos, const char* str)
    2. {
    3. 	assert(pos <= _size);
    4.  
    5. 	size_t len = strlen(str);
    6. 	if (_size + len > _capacity)
    7. 	{
    8. 		reserve(_size + len);
    9. 	}
    10.  
    11. 	size_t end = _size;
    12. 	while (end >= pos && end != npos)
    13. 	{
    14. 		_str[end + len] = _str[end];
    15. 		--end;
    16. 	}
    17.  
    18. 	for (size_t i = 0; i < len; i++)
    19. 	{
    20. 		_str[pos + i] = str[i];
    21. 	}
    22.  
    23. 	_size += len;
    24. }

    12. erase 

    12.1 从pos位置开始删除

    1. 先判断下标合法
    2. 再判断是不是要删到尾部，如果是，直接把pos处改为 '\0' ，并修改_size值即可
    3. 如果不是，就是在内部删除，和insert操作类似，移动
    1. void erase(size_t pos, size_t len = npos)
    2. {
    3. 	assert(pos < _size);
    4. 	if (len == npos || pos + len >= _size)
    5. 	{
    6. 		_str[pos] = '\0';
    7. 		_size = pos;
    8.  
    9. 		_str[_size] = '\0';
    10. 	}
    11. 	else
    12. 	{
    13. 		size_t begin = pos + len;
    14. 		//等于size，把\0也移动过去
    15. 		while (begin <= _size)
    16. 		{
    17. 			_str[pos++] = _str[begin++];
    18. 		}
    19. 		_size -= len;
    20. 	}
    21. }

     13. find

    13.1 查找字符

    1. size_t find(char ch, size_t pos = 0)
    2. {
    3. 	assert(pos < _size);
    4. 	for (size_t i = pos; i < _size; i++)
    5. 	{
    6. 		if (_str[i] == ch)
    7. 			return i;
    8. 	}
    9. 	//找不到，返回npos
    10. 	return npos;
    11. }

     13.2 查找字符串

    1. size_t find(const char* str, size_t pos = 0)
    2. {
    3. 	assert(pos < _size);
    4. 	const char* ptr = strstr(_str, str);
    5. 	if (ptr)
    6. 	{
    7. 		return ptr - _str;
    8. 	}
    9. 	else
    10. 	{
    11. 		return npos;
    12. 	}
    13. }

    14. substr 

    • 注意for循环中 i < pos + n，别误写为 i < n
    1. string substr(size_t pos, size_t len = npos)
    2. {
    3. 	assert(pos < _size);
    4.  
    5. 	size_t n = len;
    6. 	if (len == npos || pos + len > _size)
    7. 	{
    8. 		n = _size - pos;
    9. 	}
    10.  
    11. 	string tmp;
    12. 	tmp.reserve(n);
    13. 	//注意i < pos + n
    14. 	for (size_t i = pos; i < pos + n; i++)
    15. 	{
    16. 		tmp += _str[i];
    17. 	}
    18.  
    19. 	return tmp;
    20. }

    15. reseve && resize

    1. 		void reserve(size_t n)
    2. 		{
    3. 			if (n > _capacity)
    4. 			{
    5. 				//多开一个放'\0'
    6. 				char* tmp = new char[n + 1];
    7. 				//strcpy(tmp, _str);
    8. 				memcpy(tmp, _str, _size + 1);
    9.  
    10. 				delete[] _str;
    11. 				_str = tmp;
    12. 				_capacity = n;
    13. 			}
    14. 		}

    1.         void resize(size_t n, char ch = '\0')
    2. 		{
    3. 			if (n < _size)
    4. 			{
    5. 				_size = n;
    6. 				_str[_size] = '\0';
    7. 			}
    8. 			else
    9. 			{
    10. 				//利用reserve进行扩容判断
    11. 				reserve(n);
    12. 				for (size_t i = _size; i < n; i++)
    13. 				{
    14. 					_str[i] = ch;
    15. 				}
    16.  
    17. 				_size = n;
    18. 				//由于ch不一定是\0，而且i < n没到最后的\0位置
    19. 				_str[_size] = '\0';
    20. 			}
    21. 		}

    16. operator<< 流插入

    流插入，有多少字符就输出多少字符，中间有'\0'也不终止

    注意将该函数放在命名空间域中，还是全局函数

    1. //流插入，有多少字符就输出多少字符，中间有'\0'也不终止
    2. 	std::ostream& operator<<(std::ostream& out, const string& s)
    3. 	{
    4. 		//要访问私有变量才用友元
    5. 		for (auto i : s)
    6. 		{
    7. 			out << s[i];
    8. 		}
    9.  
    10. 		return out;
    11. 	}

            直接使用 c_str 和 << 在一般情况是相同的，但是c_str是c字符串，遇到\0自动终止，而string则是依靠size来判断，size有多大，operator<<就打印多长 

    例如 ：

    1. void test()
    2. {
    3.  
    4. 	//与c的字符串不同，c的字符串遇到\0终止，而string是直到size终止
    5. 	string ss("hello world");
    6. 	ss += '\0';
    7. 	ss += "LLLLLLLLLL";
    8. 	cout << ss.c_str() << endl;
    9. 	cout << ss << endl;
    10. }
    11.  
    12. int main()
    13. {
    14.     test();
    15.     return 0;
    16. }
    1. hello world
    2. hello wordl LLLLLLLLLL

            可以看到第二个打印有空格，空格表示了 '\0'

            所以，有了\0，之前用的str系列的函数就需要修改了，因为str类型的函数遇到\0自动结束，而string是遇到size才停止，将之前的str函数改为memcpy函数

    • 对于构造函数，可以不修改，因为本身构造时，用的就是c字符串，strlen以及strcpy都不需要修改，这里修改strcpy是为了与下面一致
    1.         //构造
    2. 		string(const char* str = "")
    3. 		{
    4. 			_size = strlen(str);
    5. 			_capacity = _size;
    6. 			_str = new char[_capacity + 1];
    7. 			memcpy(_str, str, _size + 1);
    8. 		}
    9. 		//拷贝构造
    10. 		string(const string& s)
    11. 		{
    12. 			_str = new char[s._capacity + 1];
    13. 			memcpy(_str, s._str, s._size + 1);
    14. 			_size = s._size;
    15. 			_capacity = s._capacity;
    16. 		}
    • 对于reserve也需要更改
    • 对于append可以不更改，因为追加的是c字符串，为了一致性，改为memcpy，拷贝到时候都默认加一个1，因为strcpy默认拷贝\0
    1. 		void append(const char* str)
    2. 		{
    3. 			size_t len = strlen(str);
    4. 			if (_size + len > _capacity)
    5. 			{
    6. 				reserve(_size + len);
    7. 			}
    8.  
    9. 			//strcpy(_str + _size, str);
    10. 			memcpy(_str + _size, str, len + 1);

    17. operator>> 流提取

    1. 	//流提取（从终端提取数据），这里的s不能使用const，因为要往s里存放数据
    2. 	std::istream& operator>>(std::istream& in, string& s)
    3. 	{
    4. 		//不能写成 in >> s.str，因为s可能没空间来存放数据
    5. 		char ch;
    6. 		in >> ch;
    7. 		while (ch != ' ' && ch != '\n')
    8. 		{
    9. 			s += ch;
    10. 			in >> ch;
    11. 		}
    12. 		return in;
    13. 	}

            上面的代码有错误，当我们输入连续的字符时，不能读到空格和换行，就会陷入死循环，这是in本身的设定，以空格和换行符来区分多个数据，所以我们要使用 get 来提取终端数据 ——in.get()，可以读空格和换行

            当我们不想以空格为分隔符时，可以将 ch != '  ' 判断条件去掉

    1. 	//流提取（从终端提取数据），这里的s不能使用const，因为要往s里存放数据
    2. 	std::istream& operator>>(std::istream& in, string& s)
    3. 	{
    4. 		//不能写成 in >> s.str，因为s可能没空间来存放数据
    5. 		char ch = in.get();
    6. 		while (ch != ' ' && ch != '\n')
    7. 		{
    8. 			s += ch;
    9. 			ch = in.get();
    10. 		}
    11. 		return in;
    12. 	}

    对于cin操作，如果多次cin，应该会覆盖原先数据 ，即我们需要实现清理工作clear()

    1. 	void clear()
    2. 	{
    3. 		_str[0] = '\0';
    4. 		_size = 0;
    5. 	}
    6.  
    7.     //流提取（从终端提取数据），这里的s不能使用const，因为要往s里存放数据
    8. 	std::istream& operator>>(std::istream& in, string& s)
    9. 	{
    10. 		s.clear();
    11. 		//不能写成 in >> s.str，因为s可能没空间来存放数据
    12. 		char ch = in.get();
    13. 		while (ch != ' ' && ch != '\n')
    14. 		{
    15. 			s += ch;
    16. 			ch = in.get();
    17. 		}
    18. 		return in;
    19. 	}

            优化：循环里的+=效率不高，因为如果字符串过长可能经历多次扩容。我们当然可以提前reserve开一定空间，但是当字符串过短，那么如果空间开的过大就浪费了。

            在这里，我们开一个128的char数组，暂存从终端提取的数据，积累一些数据，当数据超过数组大小后，尾插 \0 后将该数组+=上去，并将下标置为0，再次提取数据。

            当数据不够128时，跳出循环，所以要再循环外判断数组内是否还存有数据，再进行+=

    1. 	std::istream& operator>>(std::istream& in, string& s)
    2. 	{
    3. 		s.clear();
    4. 		//不能写成 in >> s.str，因为s可能没空间来存放数据
    5. 		char ch = in.get();
    6. 		char buff[128];
    7. 		int i = 0;
    8. 		while (ch != ' ' && ch != '\n')
    9. 		{
    10. 			buff[i++] = ch;
    11. 			if (i == 127)
    12. 			{
    13. 				buff[i] = '\0';
    14. 				s += buff;
    15. 				i = 0;
    16. 			}
    17. 			ch = in.get();
    18. 		}
    19.  
    20. 		if (i != 0)
    21. 		{
    22. 			buff[i] = '\0';
    23. 			s += buff;
    24. 		}
    25. 		return in;
    26. 	}

            但是对于前有空格和换行，后面输入的数据就进不去，所以再进行优化，加一个while循环，将前空格和换行去除。

    1. 	//流提取（从终端提取数据），这里的s不能使用const，因为要往s里存放数据
    2. 	std::istream& operator>>(std::istream& in, string& s)
    3. 	{
    4. 		s.clear();
    5. 		//不能写成 in >> s.str，因为s可能没空间来存放数据
    6. 		char ch = in.get();
    7. 		//处理前缓冲区-流-前面的空格或者换行
    8. 		while (ch == ' ' || ch == '\n')
    9. 		{
    10. 			ch = in.get();
    11. 		}
    12.  
    13. 		char buff[128];
    14. 		int i = 0;
    15. 		while (ch != ' ' && ch != '\n')
    16. 		{
    17. 			buff[i++] = ch;
    18. 			if (i == 127)
    19. 			{
    20. 				buff[i] = '\0';
    21. 				s += buff;
    22. 				i = 0;
    23. 			}
    24. 			ch = in.get();
    25. 		}
    26.  
    27. 		if (i != 0)
    28. 		{
    29. 			buff[i] = '\0';
    30. 			s += buff;
    31. 		}
    32. 		return in;
    33. 	}

    18. string比较

    1. string按照ASCII进行比较大小
    2. 不能用strcmp，因为当遇到 例如：hello\0xxxxx 和 hello\0yyyyy 时，比较遇到 \0 就结束了，所以我们可以使用memcmp或手写
    3. 加const防止改变this值，以及可以使const对象调用该函数
    1.         //方法一：
    2. 		bool operator<(const string& s) const
    3. 		{
    4. 			int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
    5.  
    6. 			return ret == 0 ? _size < s._size : ret < 0;
    7. 		}
    8.  
    9.  
    10. 		方法二:
    11. 		//bool operator<(const string& s)
    12. 		//{
    13. 		//	//return strcmp(_str, s._str) < 0;由于\0，所以不能用strcmp
    14. 		//	size_t i1 = 0;
    15. 		//	size_t i2 = 0;
    16. 		//	while (i1 < _size && i2 < s._size)
    17. 		//	{
    18. 		//		if (_str[i1] < s._str[i2])
    19. 		//			return true;
    20. 		//		else if (_str[i1] > s._str[i2])
    21. 		//			return false;
    22. 		//		else
    23. 		//		{
    24. 		//			++i1;
    25. 		//			++i2;
    26. 		//		}
    27. 		//	}
    28. 		//	//在循环之外，只有一种情况是true
    29. 		//	//return i1 == _size && i2 != s._size;
    30.  
    31. 		//	//或者判断size大小
    32. 		//	return _size < s._size;
    33. 		//}

     其他比较复用即可

    1.         bool operator==(const string& s) const
    2. 		{
    3. 			//先比较size过滤各种情况
    4. 			return _size == s._size
    5. 				&& memcmp(_str, s._str, _size < s._size) == 0;
    6. 		}
    7. 		bool operator<=(const string& s) const
    8. 		{
    9. 			return (*this < s || *this == s);
    10. 		}
    11. 		bool operator>(const string& s) const
    12. 		{
    13. 			return !(*this <= s);
    14. 		}
    15. 		bool operator>=(const string& s) const
    16. 		{
    17. 			return !(*this < s);
    18. 		}
    19. 		bool operator!=(const string& s) const
    20. 		{
    21. 			return !(*this == s);
    22. 		}

     19. operator= 赋值运算符重载

     对于赋值，为深拷贝，则需要释放原空间，再开空间进行赋值

    方法一： 开空间，赋值，再释放，赋值

    1. 		//赋值运算符重载——深拷贝
    2. 		string& operator=(const string& s)
    3. 		{
    4. 			if (this != &s)
    5. 			{
    6.                 //先开空间，赋值，再释放，赋值
    7. 				char* tmp = new char[s._capacity];
    8. 				memcpy(tmp, s._str, s._size + 1);
    9. 				delete[] _str;
    10. 				_str = tmp;
    11.  
    12. 				_size = s._size;
    13. 				_capacity = s._capacity;
    14. 			}
    15.  
    16. 			return *this;
    17. 		}

    方法二：交换

            先根据s创建一个临时对象，再将临时对象和this的各个数据进行交换，这时this就指向了拷贝对象，临时对象tmp就指向了原空间，tmp出了作用域自动销毁，完美解决 

    1. 		//方法二：swap交换
    2. 		void swap(string& s)
    3. 		{
    4. 			std::swap(s._str, _str);
    5. 			std::swap(s._size, _size);
    6. 			std::swap(s._capacity, _capacity);
    7. 		}
    8.  
    9. 		string& operator=(const string& s)
    10. 		{
    11. 			if (this != &s)
    12. 			{
    13. 				//不能直接交换两个对象，会发生栈溢出、无穷递归
    14. 				//std::swap(tmp, *this);  一直调用赋值运算符重载
    15. 				string tmp(s);
    16.  
    17. 				//this->swap(tmp);
    18. 				swap(tmp);
    19.  
    20. 			}
    21.  
    22. 			//tmp是局部对象，出函数自动销毁
    23. 			return *this;
    24. 		}

     方法三：再次优化，将形参改为string tmp，直接拷贝构造tmp，出函数作用域直接析构，所以，对于赋值运算符重载，需要先进行拷贝构造

    1. 		void swap(string& s)
    2. 		{
    3. 			std::swap(s._str, _str);
    4. 			std::swap(s._size, _size);
    5. 			std::swap(s._capacity, _capacity);
    6. 		}
    7. 		//方法三：改变行参，直接拷贝构造tmp
    8. 		string& operator=(string tmp)
    9. 		{
    10. 			swap(tmp);
    11.  
    12. 			return *this;
    13. 		}

    wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

    由此又引出拷贝构造的现代写法 （即使用交换来实现功能），但是由于\0，这个拷贝构造并不能正确实现拷贝构造功能，所以还是采用原拷贝构造。

    1. 		string(const string& s)
    2. 			:_str(nullptr)
    3. 			,_size(0)
    4. 			,_capacity(0)
    5. 		{
    6. 			//使用初始化列表，避免对象各成员变量为nullptr
    7. 			string tmp(s._str);
    8. 			swap(tmp);
    9. 		}

     

     二、整体代码

    my_string.h

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5.  
    6. namespace my_string
    7. {
    8. 	class string
    9. 	{
    10. 	public:
    11. 		//迭代器，在string这里就是指针
    12. 		typedef char* iterator;
    13. 		typedef const char* const_iterator;
    14.  
    15. 		iterator begin()
    16. 		{
    17. 			return _str;
    18. 		}
    19.  
    20. 		iterator end()
    21. 		{
    22. 			return _str + _size;
    23. 		}
    24.  
    25. 		const_iterator begin() const
    26. 		{
    27. 			return _str;
    28. 		}
    29.  
    30. 		const_iterator end() const
    31. 		{
    32. 			return _str + _size;
    33. 		}
    34.  
    35. 		//构造
    36. 		string(const char* str = "")
    37. 		{
    38. 			_size = strlen(str);
    39. 			_capacity = _size;
    40. 			_str = new char[_capacity + 1];
    41. 			memcpy(_str, str, _size + 1);
    42. 		}
    43. 		//拷贝构造
    44. 		string(const string& s)
    45. 		{
    46. 			_str = new char[s._capacity + 1];
    47. 			memcpy(_str, s._str, s._size + 1);
    48. 			_size = s._size;
    49. 			_capacity = s._capacity;
    50. 		}
    51.  
    52. 		赋值运算符重载——深拷贝
    53. 		//string& operator=(const string& s)
    54. 		//{
    55. 		//	if (this != &s)
    56. 		//	{
    57. 		//		char* tmp = new char[s._capacity];
    58. 		//		memcpy(tmp, s._str, s._size + 1);
    59. 		//		delete[] _str;
    60. 		//		_str = tmp;
    61.  
    62. 		//		_size = s._size;
    63. 		//		_capacity = s._capacity;
    64. 		//	}
    65.  
    66. 		//	return *this;
    67. 		//}
    68.  
    69. 		//方法二：swap交换
    70. 		void swap(string& s)
    71. 		{
    72. 			std::swap(s._str, _str);
    73. 			std::swap(s._size, _size);
    74. 			std::swap(s._capacity, _capacity);
    75. 		}
    76.  
    77. 		//string& operator=(const string& s)
    78. 		//{
    79. 		//	if (this != &s)
    80. 		//	{
    81. 		//		//不能直接交换两个对象，会发生栈溢出、无穷递归
    82. 		//		//std::swap(tmp, *this);  一直调用赋值运算符重载
    83. 		//		string tmp(s);
    84.  
    85. 		//		//this->swap(tmp);新手才写this o.0
    86. 		//		swap(tmp);
    87.  
    88. 		//	}
    89. 		//	//tmp是局部对象，出函数自动销毁
    90. 		//	return *this;
    91. 		//}
    92.  
    93. 		//方法三：改变行参，直接拷贝构造tmp
    94. 		string& operator=(string tmp)
    95. 		{
    96. 			swap(tmp);
    97.  
    98. 			return *this;
    99. 		}
    100.  
    101. 		//析构
    102. 		~string()
    103. 		{
    104. 			delete[] _str;
    105. 			_str = nullptr;
    106. 			_size = _capacity = 0;
    107. 		}
    108.  
    109. 		const char* c_str() const
    110. 		{
    111. 			return _str;
    112. 		}
    113.  
    114. 		size_t size() const
    115. 		{
    116. 			return _size;
    117. 		}
    118.  
    119. 		char& operator[](size_t pos)
    120. 		{
    121. 			assert(pos < _size);
    122.  
    123. 			return _str[pos];
    124. 		}
    125.  
    126. 		//const版本 只读
    127. 		const char& operator[](size_t pos) const
    128. 		{
    129. 			assert(pos < _size);
    130.  
    131. 			return _str[pos];
    132. 		}
    133.  
    134. 		void reserve(size_t n)
    135. 		{
    136. 			if (n > _capacity)
    137. 			{
    138. 				//多开一个放'\0'
    139. 				char* tmp = new char[n + 1];
    140. 				//strcpy(tmp, _str);
    141. 				memcpy(tmp, _str, _size + 1);
    142.  
    143. 				delete[] _str;
    144. 				_str = tmp;
    145. 				_capacity = n;
    146. 			}
    147. 		}
    148.  
    149. 		void resize(size_t n, char ch = '\0')
    150. 		{
    151. 			if (n < _size)
    152. 			{
    153. 				_size = n;
    154. 				_str[_size] = '\0';
    155. 			}
    156. 			else
    157. 			{
    158. 				//利用reserve进行扩容判断
    159. 				reserve(n);
    160. 				for (size_t i = _size; i < n; i++)
    161. 				{
    162. 					_str[i] = ch;
    163. 				}
    164.  
    165. 				_size = n;
    166. 				//由于ch不一定是\0，而且i < n没到最后的\0位置
    167. 				_str[_size] = '\0';
    168. 			}
    169. 		}
    170.  
    171. 		void push_back(char ch)
    172. 		{
    173. 			if (_size == _capacity)
    174. 			{
    175. 				reserve(_capacity == 0 ? 4 : _capacity * 2);
    176. 			}
    177.  
    178. 			_str[_size] = ch;
    179. 			++_size;
    180. 			_str[_size] = '\0';
    181. 		}
    182.  
    183. 		void append(const char* str)
    184. 		{
    185. 			size_t len = strlen(str);
    186. 			if (_size + len > _capacity)
    187. 			{
    188. 				reserve(_size + len);
    189. 			}
    190.  
    191. 			//strcpy(_str + _size, str);
    192. 			memcpy(_str + _size, str, len);
    193. 			_size += len;
    194. 		}
    195.  
    196. 		string& operator+=(char ch)
    197. 		{
    198. 			push_back(ch);
    199. 			return *this;
    200. 		}
    201.  
    202. 		string& operator+=(const char* str)
    203. 		{
    204. 			append(str);
    205. 			return *this;
    206. 		}
    207.  
    208. 		void insert(size_t pos, size_t n, char ch)
    209. 		{
    210. 			//size_t大于0，不用判断
    211. 			assert(pos <= _size);
    212. 			if (_size + n > _capacity)
    213. 			{
    214. 				//至少扩容到 _size + n
    215. 				reserve(_size + n);
    216. 			}
    217.  
    218. 			size_t end = _size;
    219. 			//size_t因为不小于0，当pos为0时，会陷入死循环
    220. 			//这里有多种方案，可以强制类型转换、可以将end从end+n开始、用npos判断
    221. 			while (end >= pos && end != npos)
    222. 			{
    223. 				_str[end + n] = _str[end];
    224. 				--end;
    225. 			}
    226.  
    227. 			for (size_t i = 0; i < n; i++)
    228. 			{
    229. 				_str[pos + i] = ch;
    230. 			}
    231.  
    232. 			_size += n;
    233. 		}
    234.  
    235. 		void insert(size_t pos, const char* str)
    236. 		{
    237. 			assert(pos <= _size);
    238.  
    239. 			size_t len = strlen(str);
    240. 			if (_size + len > _capacity)
    241. 			{
    242. 				reserve(_size + len);
    243. 			}
    244.  
    245. 			size_t end = _size;
    246. 			while (end >= pos && end != npos)
    247. 			{
    248. 				_str[end + len] = _str[end];
    249. 				--end;
    250. 			}
    251.  
    252. 			for (size_t i = 0; i < len; i++)
    253. 			{
    254. 				_str[pos + i] = str[i];
    255. 			}
    256.  
    257. 			_size += len;
    258. 		}
    259.  
    260. 		void erase(size_t pos, size_t len = npos)
    261. 		{
    262. 			assert(pos < _size);
    263. 			if (len == npos || pos + len >= _size)
    264. 			{
    265. 				_str[pos] = '\0';
    266. 				_size = pos;
    267.  
    268. 				_str[_size] = '\0';
    269. 			}
    270. 			else
    271. 			{
    272. 				size_t begin = pos + len;
    273. 				//等于size，把\0也移动过去
    274. 				while (begin <= _size)
    275. 				{
    276. 					_str[pos++] = _str[begin++];
    277. 				}
    278. 				_size -= len;
    279. 			}
    280. 		}
    281.  
    282. 		string substr(size_t pos, size_t len = npos)
    283. 		{
    284. 			assert(pos < _size);
    285.  
    286. 			size_t n = len;
    287. 			if (len == npos || pos + len > _size)
    288. 			{
    289. 				n = _size - pos;
    290. 			}
    291.  
    292. 			string tmp;
    293. 			tmp.reserve(n);
    294. 			//注意i < pos + n
    295. 			for (size_t i = pos; i < pos + n; i++)
    296. 			{
    297. 				tmp += _str[i];
    298. 			}
    299.  
    300. 			return tmp;
    301. 		}
    302.  
    303. 		size_t find(char ch, size_t pos = 0)
    304. 		{
    305. 			assert(pos < _size);
    306. 			for (size_t i = pos; i < _size; i++)
    307. 			{
    308. 				if (_str[i] == ch)
    309. 					return i;
    310. 			}
    311. 			//找不到，返回npos
    312. 			return npos;
    313. 		}
    314.  
    315. 		size_t find(const char* str, size_t pos = 0)
    316. 		{
    317. 			assert(pos < _size);
    318. 			const char* ptr = strstr(_str, str);
    319. 			if (ptr)
    320. 			{
    321. 				return ptr - _str;
    322. 			}
    323. 			else
    324. 			{
    325. 				return npos;
    326. 			}
    327. 		}
    328.  
    329. 		void clear()
    330. 		{
    331. 			_str[0] = '\0';
    332. 			_size = 0;
    333. 		}
    334.  
    335. 		//方法一：
    336. 		bool operator<(const string& s) const
    337. 		{
    338. 			int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
    339.  
    340. 			return ret == 0 ? _size < s._size : ret < 0;
    341. 		}
    342.  
    343.  
    344. 		方法二:
    345. 		//bool operator<(const string& s)
    346. 		//{
    347. 		//	//return strcmp(_str, s._str) < 0;由于\0，所以不能用strcmp
    348. 		//	size_t i1 = 0;
    349. 		//	size_t i2 = 0;
    350. 		//	while (i1 < _size && i2 < s._size)
    351. 		//	{
    352. 		//		if (_str[i1] < s._str[i2])
    353. 		//			return true;
    354. 		//		else if (_str[i1] > s._str[i2])
    355. 		//			return false;
    356. 		//		else
    357. 		//		{
    358. 		//			++i1;
    359. 		//			++i2;
    360. 		//		}
    361. 		//	}
    362. 		//	//在循环之外，只有一种情况是true
    363. 		//	//return i1 == _size && i2 != s._size;
    364.  
    365. 		//	//或者判断size大小
    366. 		//	return _size < s._size;
    367. 		//}
    368.  
    369. 		bool operator==(const string& s) const
    370. 		{
    371. 			//先比较size过滤各种情况
    372. 			return _size == s._size
    373. 				&& memcmp(_str, s._str, _size < s._size) == 0;
    374. 		}
    375. 		bool operator<=(const string& s) const
    376. 		{
    377. 			return (*this < s || *this == s);
    378. 		}
    379. 		bool operator>(const string& s) const
    380. 		{
    381. 			return !(*this <= s);
    382. 		}
    383. 		bool operator>=(const string& s) const
    384. 		{
    385. 			return !(*this < s);
    386. 		}
    387. 		bool operator!=(const string& s) const
    388. 		{
    389. 			return !(*this == s);
    390. 		}
    391.  
    392. 	private:
    393. 		size_t _size;
    394. 		size_t _capacity;
    395. 		char* _str;
    396.  
    397. 		static size_t npos;
    398. 	};
    399.  
    400. 	size_t string::npos = -1;
    401.  
    402. 	//流插入（向终端插入数据），有多少字符就输出多少字符，中间有'\0'也不终止
    403. 	std::ostream& operator<<(std::ostream& out, const string& s)
    404. 	{
    405. 		//要访问私有变量才用友元
    406. 		for (auto ch : s)
    407. 		{
    408. 			out << ch;
    409. 		}
    410.  
    411. 		return out;
    412. 	}
    413.  
    414. 	//流提取（从终端提取数据），这里的s不能使用const，因为要往s里存放数据
    415. 	std::istream& operator>>(std::istream& in, string& s)
    416. 	{
    417. 		s.clear();
    418. 		//不能写成 in >> s.str，因为s可能没空间来存放数据
    419. 		char ch = in.get();
    420. 		//处理前缓冲区前面的空格或者换行
    421. 		while (ch == ' ' || ch == '\n')
    422. 		{
    423. 			ch = in.get();
    424. 		}
    425.  
    426. 		char buff[128];
    427. 		int i = 0;
    428. 		while (ch != ' ' && ch != '\n')
    429. 		{
    430. 			buff[i++] = ch;
    431. 			if (i == 127)
    432. 			{
    433. 				buff[i] = '\0';
    434. 				s += buff;
    435. 				i = 0;
    436. 			}
    437. 			ch = in.get();
    438. 		}
    439.  
    440. 		if (i != 0)
    441. 		{
    442. 			buff[i] = '\0';
    443. 			s += buff;
    444. 		}
    445. 		return in;
    446. 	}
    447.  
    448. };
    449.

    wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

    三、写时拷贝 

            我们再次回顾深浅拷贝问题

    浅拷贝问题：

            1.析构两次

            2. 一个对象修改会影响另一个

            仔细分析，我们能发现，深拷贝效率不如浅拷贝，因为还要开辟另一块空间。此时，有了浅拷贝的改进：

    1. 对于第一个问题：进行引用计数 ，每有一个对象指向该空间，计数+1，每析构一次，计数-1，直至最后为0时，真正的析构（最后走的人关灯）
    2. 对于第二个问题，如果计数不是1，则进行深拷贝，再修改值（有博弈的成分，如果有只拷贝不修改值的情况，那么就赚了；对于需要修改值的，那么就进行深拷贝，不赚不赔）

     

    想了解更多关于写时拷贝的内容，可以看大佬的文章

    C++ STL string的Copy-On-Write技术 | 酷 壳 - CoolShell 

    sizeof (s)是多少呢？

            并不是12，是28（32位平台），这是由于vs2019优化，给了buf数组缓存，以空间换时间

    • 当 size < 16 那么就没必要开空间，直接存在buf数组内
    • 当size >= 16 字符串存在_ptr指向的堆空间

    总结

            我们模拟实现的string，具有部分功能，还有一部分没有实现，有兴趣的同学可以参照std的string再进行模拟实现，下节我们将讲解vector并进行实现。

            最后，如果小帅的本文哪里有错误，还请大家指出，请在评论区留言（ps：抱大佬的腿），新手创作，实属不易，如果满意，还请给个免费的赞，三连也不是不可以（流口水幻想）嘿！那我们下期再见喽，拜拜！

  • 相关阅读:
    项目管理逻辑:项目如何算是做完?什么是项目管理中的PPP模式?
    一款兼容Win和Mac的iOS设备管理软件iMazing 3 for Windows新功能介绍
    【Linux】vim_gcc_动静态库
    【PAT甲级 - C++题解】1096 Consecutive Factors
    云耀服务器L实例部署Discuz！Q论坛｜华为云云耀云服务器L实例评测使用体验
    安全漏洞分类之CNNVD漏洞分类指南
    用python实现在卷积神经网络中，如何计算各层感受野的大小
    别再到处乱放配置文件了！试试我司使用 7 年的这套解决方案，稳的一秕
    mac下nodejs的卸载与安装
    JQuery 高级使用 高阶函数 委托模式 全局css变量
  • 原文地址：https://blog.csdn.net/prodigy623/article/details/133580419