【C++11】移动语义

回顾

const int c的c是可以被取地址的，尽管是常量。所以以是否为常量来判断是否为右值是错误的。

左值与右值正确的区分方法是是否能够被取地址。（能被取地址也就代表着是一个持久状态，即有持久的存储空间的值）

常见的左值有我们定义的变量、对象，或者解引用表达式和传引用返回。（比如`string s(“2077”);然后s[0]就是一个传引用返回值，也就是一个左值）

常见的右值有常量、（表达式求值过程中创建的）临时对象、匿名对象。

左值引用和右值引用可以交叉引用但是有条件：

• const左值引用可以引用右值

• 右值引用可以引用move(左值)

  （move是库里面的一个函数模版，本质内部是进行强制类型转换，涉及一些引用折叠的知识）

类型是我们对内存里一块空间的定义，而C++是可以对类型进行转换的，也就是对内存空间不同的解释。

类型决定了语法意义上我们怎么对这块空间的数据进行处理。
拿链表指针和迭代器举个例子：

这里ptr和it同样都是4个字节存放地址，但是却解释为不同的类型，意义就不同了、
所以我们知道，内存存的是数据，但只是存储数据本身没什么意义，而将数据解释为不同的类型，意义就千变万化了。

3.延长生命周期

这一般指的是临时对象、匿名对象。因为它们一般生命周期只在当前行，而延长后可以与整个域生命周期一样长。但将其从一个栈帧延长到另一个栈帧，是做不到的。

比如这个str的生命周期不可能延长到main栈帧里去
因为延长生命周期没有改变它的存储位置

在这里，main函数里调用了函数Func1，调用结束后Func1的栈帧是要回收的，下次调用Func2还占用的是这块空间，所以怎么可能将Func1中的str单独延长生命周期呢？
所以要搞清楚延长生命周期的对象是指的谁。
延长生命周期没有改变存储位置。
再看一例：

这里创建一个匿名对象，我们可以看到它在下一句代码之前就析构了，说明匿名对象的生命周期只在这一行。

那么现在使用const左值引用对其生命周期进行延长：

可以看到延长之后它的生命周期就跟着引用走了

注意：
右值引用延长生命周期效果同样如此。

4.编译器对拷贝的优化之所以复杂，有两方面的因素：一方面要支持c++委员会制定的语法新规则，另一方面要为了c++的高效适当进行优化。
左值引用和右值引用最终目的都是减少拷贝提高效率（左值引用还有其他使用场景比如输出型参数，修改参数或返回值）

（补充）输出型参数：

在C++中，输出型参数通常通过指针或引用来实现，因为函数参数默认是按值传递的，直接传递普通变量无法修改外部变量的值。以下是C++中输出型参数的实现方式：

1. 使用指针作为输出型参数

通过传递指针，函数可以修改指针所指向的内存地址中的值。

#include <iostream>
using namespace std;// 函数定义，使用指针作为输出型参数
void calculate(int a, int b, int* sum, int* product) {*sum = a + b;       // 修改sum指向的值*product = a * b;   // 修改product指向的值
}int main() {int x = 5, y = 10;int sumResult, productResult;// 传递变量的地址calculate(x, y, &sumResult, &productResult);cout << "Sum: " << sumResult << endl;         // 输出：Sum: 15cout << "Product: " << productResult << endl; // 输出：Product: 50return 0;
}

说明：

int* sum 和 int* product 是指针参数，用于接收外部变量的地址。

在函数内部通过 *sum 和 *product 修改外部变量的值。

2. 使用引用作为输出型参数

引用是C++中更安全和直观的方式，可以直接操作外部变量。

#include <iostream>
using namespace std;// 函数定义，使用引用作为输出型参数
void calculate(int a, int b, int& sum, int& product) {sum = a + b;       // 直接修改sum引用的值product = a * b;   // 直接修改product引用的值
}int main() {int x = 5, y = 10;int sumResult, productResult;// 传递变量的引用calculate(x, y, sumResult, productResult);cout << "Sum: " << sumResult << endl;         // 输出：Sum: 15cout << "Product: " << productResult << endl; // 输出：Product: 50return 0;
}

说明：

int& sum 和 int& product 是引用参数，直接绑定到外部变量。

在函数内部可以直接操作 sum 和 product，无需解引用。

3.指针和引用的对比

4. 使用输出型参数的场景！

• 需要从函数中返回多个值。

• 需要修改传入的参数值。

• 避免返回大型对象（通过引用或指针传递，避免拷贝开销）。

5. 示例：返回多个值

以下是一个返回多个值的示例，使用引用作为输出型参数：

#include <iostream>
#include <tuple> // 如果需要返回多个值，也可以使用std::tuple
using namespace std;void getResults(int a, int b, int& sum, int& diff, int& product) {sum = a + b;diff = a - b;product = a * b;
}int main() {int x = 10, y = 4;int sum, diff, product;getResults(x, y, sum, diff, product);cout << "Sum: " << sum << endl;         // 输出：Sum: 14cout << "Difference: " << diff << endl; // 输出：Difference: 6cout << "Product: " << product << endl; // 输出：Product: 40return 0;
}

5.左值引用的不足：
部分函数返回场景，只能传值返回，不能左值引用返回。
当前函数的局部对象，出了当前函数的作用域生命周期到了销毁了不能左值引用返回，只能传值返回。

class Solution 
{
public:// 这⾥的传值返回拷⻉代价就太⼤了 vector<vector<int>> generate(int numRows) {vector<vector<int>> vv(numRows);for(int i = 0; i < numRows; ++i){vv[i].resize(i+1, 1);}for(int i = 2; i < numRows; ++i){for(int j = 1; j < i; ++j){vv[i][j] = vv[i-1][j] + vv[i-1][j-1];}}return vv;}
};
int main()
{vector<vector<int>> ret = Solution().generate(100);return 0;
}

不优化的情况下编译器还要拷贝两次：

如果new的话，忘记释放可能会导致内存泄漏。

一种较老的比较好的解决方式（输出型参数）：

class Solution 
{
public:void generate(int numRows,vector<vector<int>>& vv) {for(int i = 0; i < numRows; ++i){vv[i].resize(i+1, 1);}for(int i = 2; i < numRows; ++i){for(int j = 1; j < i; ++j){vv[i][j] = vv[i-1][j] + vv[i-1][j-1];}}}
};int main()
{vector<vector<int>> ret;Solution().generate(100,ret);return 0;
}

但这样写，用的角度，多多少少很别扭。

因为c++委员会更新标准较晚，编译器的设计者选择先从编译器的角度进行优化。

编译器的第一轮优化：“跳过中间商”

（从左边这样到右边这样）

namespace bit
{ string addStrings(string num1, string num2){string str;int end1 = num1.size() - 1, end2 = num2.size() - 1;int next = 0;while (end1 >= 0 || end2 >= 0){int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;int ret = val1 + val2 + next;next = ret / 10;ret = ret % 10;str += ('0' + ret);}if (next == 1)str += '1';reverse(str.begin(), str.end());cout << "******************************" << endl;return str;}
}// 场景1 
int main()
{bit::string ret = bit::addStrings("11111", "2222");cout << ret.c_str() << endl;return 0;
}

把优化全关掉的场景：

这里前两组的构造+拷贝构造是"11111"与 "2222"的，最后的两个拷贝构造一次是str去拷贝构造临时对象，一次是临时对象去拷贝构造ret。

VS2019下的优化，合二为一：

可以看到参数的构造与拷贝构造合二为一了，返回值的两次拷贝构造也合二为一。

2代优化非常恐怖：

可以看到是从构造+拷贝构造+拷贝构造到1代的构造+拷贝构造，再到2代的构造

最后变成了，干脆不创建str了，直接创建ret，让str变成ret的别名。
这种优化的思路很像上面说的输出型参数：

vector<vector<int>> ret;
Solution().generate(100,ret);

（编译器优化后，右值引用没有意义了吗？）
答：优化是有限度的，能解决一些问题，但是一些问题也解决不了。

比如在这个场景中：

现在不是构造+两次拷贝构造而是构造+一次拷贝构造+一次拷贝赋值的场景
彻底不优化是这样的：

一代优化：

可以看到，传参是合二为一优化了，但是拷贝构造+拷贝赋值没有优化
2代优化：

2代优化是去掉了拷贝构造，本质是让构造和拷贝构造合二为一成一次构造了。相当于一上来就构造了临时对象，让str是临时对象的别名。
编译器优化也是有限度的，优化终止于此了。
C++11出来后这个程序是如何解决的？
如果编译器彻底不优化，是这样的：

即使这样这个效率也高，因为移动构造只是抢夺资源，不会拷贝，代价极低。
……
总结就是C++11之前很依赖编译器的优化，有了移动拷贝和赋值之后，对编译器的优化的依赖很小，只是锦上添花不再是雪中送炭。
一个问题：每个类在C++11后都要写移动构造移动赋值吗？
深拷贝的自定义类型（如string、vector、map…）写才有价值。
而对于浅拷贝的类型来说，编译器的优化小赚一笔，所以移动语义+编译器优化是很无敌的存在。