【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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

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);
}
1
2
3
4
5
6
7

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

string tmp(s._str);
1

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

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

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