【C++11】移动语义

在这里，main函数里调用了函数Func1，调用结束后Func1的栈帧是要回收的，下次调用Func2还占用的是这块空间，所以怎么可能将Func1中的str单独延长生命周期呢？这里前两组的构造+拷贝构造是"11111"与 "2222"的，最后的两个拷贝构造一次是str去拷贝构造临时对象，一次是临时对象去拷贝构造ret。总结就是C++11之前很依赖编译器的优化，有了移动拷贝和赋值之后，对编译器的优化的

Octopus2077

1099人浏览 · 2025-03-11 16:27:14

Octopus2077 · 2025-03-11 16:27:14 发布

回顾

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: 15
    cout << "Product: " << productResult << endl; // 输出：Product: 50

    return 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: 15
    cout << "Product: " << productResult << endl; // 输出：Product: 50

    return 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: 14
    cout << "Difference: " << diff << endl; // 输出：Difference: 6
    cout << "Product: " << product << endl; // 输出：Product: 40

    return 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…）写才有价值。
而对于浅拷贝的类型来说，编译器的优化小赚一笔，所以移动语义+编译器优化是很无敌的存在。