1 右值引用和移动语义
1.1 左值引用和右值引用
传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。
在讲解右值引用之前我们来回答一下什么是左值 ❓什么是右值 ❓
❗️❗️❗️ 左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值。右值不能取地址+不能赋值。
左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。
比如：
int main() { // 以下的p、b、c、*p都是左值 int* p = new int(0); int b = 1; const int c = 2; // 以下几个是对上面左值的左值引用 int*& rp = p; int& rb = b; const int& rc = c; int& pvalue = *p; return 0; }
右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。
用法：
int main() { double x = 1.1, y = 2.2; // 以下几个都是常见的右值 10; x + y; min(x, y); // 以下几个都是对右值的右值引用 int&& rr1 = 10; double&& rr2 = x + y; double&& rr3 = fmin(x, y); // 这里编译会报错：error C2106: “=”: 左操作数必须为左值 10 = 1; x + y = 1; min(x, y) = 1; return 0; }
需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用，是不是感觉很神奇，这个了解一下实际中右值引用的使用场景并不在于此，这个特性也不重要。
int main() { double x = 1.1, y = 2.2; int&& rr1 = 10; const double&& rr2 = x + y; rr1 = 20; rr2 = 5.5; // 报错 return 0; }
💯左值引用和右值引用的总结:💯
1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值。
3. 右值引用只能右值，不能引用左值。
4. 但是右值引用可以move以后的左值
😄验证:😄
int main() { // 左值引用只能引用左值，不能引用右值。 int a = 10; int& ra1 = a; // ra为a的别名 int& ra2 = 10; // 编译失败，因为10是右值 // const左值引用既可引用左值，也可引用右值。 const int& ra3 = 10; const int& ra4 = a; return 0; }
int main() { // 右值引用只能右值，不能引用左值。 int&& r1 = 10; // error C2440: “初始化”: 无法从“int”转换为“int &&” // message : 无法将左值绑定到右值引用 int a = 10; int&& r2 = a; // 右值引用可以引用move以后的左值 int&& r3 = std::move(a); return 0; }
但是要注意右值引用引用左值及其一些更深入的使用场景分析。
比如下面这种场景：
int main() { string s1("hello world"); string s2(s1); string s3(std::move(s1)); return 0; }
我们调试起来看：
我们发现执行了string s3(std::move(s1))后s1的被置空了，这个我们后面会着重讲解，叫做资源转移现象。所以使用move函数时大家一定要特别注意。
1.2 右值引用的使用场景
像我们上面讲解的应用场景实际中我们并不会这么简单的应用。前面我们可以看到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引用呢❓是不是化蛇添足呢❓下面我们来看看左值引用的短板，右值引用是如何补齐这个短板的！
grm::string to_string(int value) { bool flag = true; if (value < 0) { flag = false; value = 0 - value; } grm::string str; while (value > 0) { int x = value % 10; value /= 10; str += ('0' + x); } if (flag == false) { str += '-'; } std::reverse(str.begin(), str.end()); return str; }
我们来看看上面的代码：通过左值引用我们可以减少拷贝优化效率，但是上面这种情况我们在to_string函数的内部定义了一个局部对象str,从左值引用的角度我们已经不能在做出优化了，因为你不能返回一个局部对象来用引用接收。有人或许又想到了另外一种方法：那我们返回 grm::string&& 不就行了吗？
大家想想这种方式可行吗？依旧是不行的，因为str是临时变量，出了作用域是要被销毁的，你拿引用接受不就是在访问一个不属于你的空间吗？
我们可以用下面这种方式来延长临时对象的生命周期：
const grm::string& s1 = grm::to_string(1234);
注意：这种方式是将局部对象拷贝给了临时对象，通过const&的方式延长临时对象的生命周期，并不是延长了局部对象的生命周期。
除了上面的方法外，那我们应该怎样优化呢❓
在C++中右值被分为纯右值和将亡值。纯右值指的是我们前面举的例子像一些常数啥的。而将亡值顾名思义，就是该值即将死亡。我们发现其实上面代码中的str其实就是一个将亡值。那我们如果要在外面用一个string来接受to_string后的数据，不妨直接转移str的资源到外部变量即可。
而这种资源转移的方式我们称为移动语义。
那我们应该怎样实现资源转移呢？
我们不妨借用下当初自己模拟实现string的代码：
namespace grm { class string { public: typedef char* iterator; iterator begin() { return _str; } iterator end() { return _str + _size; } string(const char* str = "") :_size(strlen(str)) , _capacity(_size) { //cout << "string(char* str)" << endl; _str = new char[_capacity + 1]; strcpy(_str, str); } // s1.swap(s2) void swap(string& s) { ::swap(_str, s._str); ::swap(_size, s._size); ::swap(_capacity, s._capacity); } // 拷贝构造 string(const string& s) :_str(nullptr) { cout << "string(const string& s) -- 深拷贝" << endl; string tmp(s._str); swap(tmp); } // 赋值重载 string& operator=(const string& s) { cout << "string& operator=(string s) -- 深拷贝" << endl; string tmp(s); swap(tmp); return *this; } ~string() { delete[] _str; _str = nullptr; } char& operator[](size_t pos) { assert(pos < _size); return _str[pos]; } void reserve(size_t n) { if (n > _capacity) { char* tmp = new char[n + 1]; strcpy(tmp, _str); delete[] _str; _str = tmp; _capacity = n; } } void push_back(char ch) { if (_size >= _capacity) { size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2; reserve(newcapacity); } _str[_size] = ch; ++_size; _str[_size] = '\0'; } //string operator+=(char ch) string& operator+=(char ch) { push_back(ch); return *this; } const char* c_str() const { return _str; } private: char* _str; size_t _size; size_t _capacity; // 不包含最后做标识的\0 };
我们给出下面的测试程序：
int main() { grm::string ret1 = grm::to_string(1234); return 0; }
不加上移动构造和移动赋值前，结果是什么呢❓
如果编译器没有做出优化，那么将会是两次拷贝构造，编译器做了优化后将从两次拷贝构造优化成一次拷贝构造。如果对于这里没有理解的老哥可以移步博主的另外一篇文章：【类和对象中的编译器优化】
但是我们不妨增加一个移动构造的版本：
// 移动构造 string(string&& s) :_str(nullptr) , _size(0) , _capacity(0) { cout << "string(string&& s) -- 移动语义" << endl; swap(s); }
这样我们再次运行时：
这样资源转移后我们就不用再担心深拷贝的代价问题了，直接将将亡值的资源转移给我接受。
这里同样是有编译器的优化的，先应该是将局部对象str的资源先转移给临时对象，然后再将临时对象的资源转移给ret1。这里编译器将两次移动构造优化成了一次移动构造。
当我们不实现移动赋值时，写下面的测试代码，大家能够分析出打印结果吗❓
