【C++修炼之路 第五章】string类 的传统写法 与 现代写法：关于 构造函数的复用 和 swap函数的巧用

在我们模拟实现 一个 string 类时，我们设计的 构造函数、拷贝构造函数、赋值运算符重载 都有一个重复的部分：开空间+拷贝strcpy

思考：我们可不可以 直接老实的实现一个函数，另外两个复用这个函数即可，减少代码重复性，同时提高可读性

答：这就是 string类 的 现代写法，需要通过 swap 函数控制

声明：无论是 传统写法 还是 现代写法，在效率上没有很大差别，就是代码精简了

1、string类 的传统写法：三者有大部分重复

namespace bit
{
	string::string(const char* str)
		: _size(strlen(str))
	{
		_str = new char[_size + 1];
		_capacity = _size;
		// 拷贝过来：strcpy(目的地，源头)
		strcpy(_str, str); 
	}

	string::string(const string& s)
	{
		_str = new char[s._capacity + 1];  // 开新空间，拷贝别人的字符串，若直接 str = s.str 就是浅拷贝了
		strcpy(_str, s._str);
		_size = s._size;
		_capacity = s._capacity;
	}

	string& string::operator=(const string& s)
	{
		if (*this != s) {
			char* newCapacity = new char[s._capacity + 1];  // 记住，开空间一定要给 '\0' 留一个位置
			delete[] _str;
			_str = newCapacity;
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
		}
		return *this;
	}
}

2、string类 的现代写法：

核心：在 需要复用的函数中 定义 临时string类对象，对这个 临时对象 操作，最后将 这个临时对象 的一切 和 你要操作的那个对象 交换数据

实现间接操作

具体看下面

2.1 拷贝构造函数 的现代写法

我们将 拷贝构造函数 写成：

string::string(const string& s)
{
	string tmp(s._str);
	std::swap(this->_str, tmp._str);
	std::swap(this->_size, tmp._size);
	std::swap(this->_capacity, tmp._capacity);
}

这段代码的意思是：
第一步：使用传递过来的对象 s，直接构造一个临时对象
这里调用了 一般构造函数：

string tmp(s._str);

第二步：使用 库里面的 swap 函数，将 tmp 的 _str 、_size 、_capacity 全部和 你自己的对象交换数据

std::swap(this->_str, tmp._str);
std::swap(this->_size, tmp._size);
std::swap(this->_capacity, tmp._capacity);

这样：在不用直接操作自己的情况下，还达到目的（拷贝了一个对象）
（这种行为有点像 不道德的 代孕 😐）

2.2 赋值运算符重载函 的现代写法

同理：赋值运算符重载函数也可以这样操作

namespace bit
{
	string& string::operator=(const string& s)
	{
		if (*this != s) {
			string tmp(s._str);
			
			std::swap(this->_str, tmp._str);
			std::swap(this->_size, tmp._size);
			std::swap(this->_capacity, tmp._capacity);
		}
		return *this;
	}
}

---

更厉害的写法：属实把传参玩明白了

我们函数的参数，如果是 传值传参，则会直接拷贝一份对象，而我们上面代码中，本就要 创建一个对象tmp
我们就可以将这两者的步骤合并 ， 代码量更少了

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

2.3 封装 string 类的 swap 函数

因为上面这两段代码都有一部分重复的地方：swap 的三句代码，
我们直接封装成一个函数：string 类专属的 swap 函数

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

3. 最终的代码

namespace bit
{
	string::string(const char* str)
		: _size(strlen(str))
	{
		_str = new char[_size + 1];
		_capacity = _size;
		// 拷贝过来：strcpy(目的地，源头)
		strcpy(_str, str);
	}
	
	// 这两个函数都换成 现代写法了
	string::string(const string& s)
	{
		string tmp(s._str);
		swap(tmp);
	}

	string& string::operator=(const string& s)
	{
		if (*this != s) {
			string tmp(s._str);
			swap(tmp);
		}
		return *this;
	}

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