C++11 左值右值引用区别与移动语义解决传值返回对象销毁问题

列表初始化 + pair 隐式类型转换

map<string, int> map1 = {{"apple", 5}, {"blue", 9}};
// map<string, int> & map2({ "apple", 5 }, { "blue" , 9 }); // 报错没有匹配的构造函数的类型

右值引用和移动语义

左值和右值的区别：右值不可以取地址，左值可以取地址。

左值引用给左值取别名，右值引用给右值取别名。

// 左值引用给左值取别名
int& r1 = b;
int*& r2 = p;
int& r3 = *p;
string& r4 = s;
char& r5 = s[0];

// 右值引用给右值取别名
int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);
string&& rr4 = string("11111");

左值不能直接引用右值，但是加了 const 的左值可以引用；右值也不能直接引用左值，但是可以引用 move 左值。补充：move 的本质就是进行强制类型转换。

注意：从语义和内存本质的角度，左值引用和右值引用都是'别名'，本身不额外开辟新的对象存储空间，在底层实现上通常以指针的形式存在。右值引用可以给右值起别名，但右值引用变量本身是左值属性。所以变量表达式都是左值属性。

引用延长生命周期

总结：右值引用可以延长被引用对象的生命周期，被引用对象可以通过非 const 的引用修改；左值引用不能延长对象生命周期，但是 const 左值引用可以延长生命周期，被引用对象不能通过 const 的引用修改。

int main() {
    std::string s1 = "happy";
    std::string&& a1 = std::move(s1);
    const std::string& a2 = s1 + s1; // 到 const 的左值引用延长生命周期
    // a2 += "happy"; // error: 没有与这些操作数匹配的 "+=" 运算符
    // 错误：不能通过到 const 的引用修改
    std::cout << a2 << '\n'; // print: happyhappy
    std::string&& a3 = s1 + s1; // 右值引用延长生存期
    a3 += "exercise"; // 能通过到非 const 的引用修改
    std::cout << a3 << '\n'; // print: happyhappyexercise
    return 0;
}

左值和右值的参数匹配

C++11 以后，分别重载左值引用、const 左值引用、右值引用作为形参的 f 函数，那么实参是左值会匹配 f(左值引用)，实参是 const 左值会匹配 f(const 左值引用)，实参是右值会匹配 f(右值引用)。

#include <iostream>
#include <string>
using namespace std;

void f(int& x) { cout << "左值引用重载调用" << endl; }
void f(const int& x) { cout << "const 左值引用重载调用" << endl; }
void f(int&& x) { cout << "右值引用重载调用" << endl; }

int main() {
    int i = 1;
    const int ci = 2;
    int&& x = 3;
    f(1); // print: 右值引用重载调用 (实际可能因优化不同)
    f(ci); // print: const 左值引用重载调用
    f(x); // print: 左值引用重载调用
    f(std::move(x)); // print: 右值引用重载调用
    return 0;
}

右值引用和移动语义的使用场景

面试题插入：左值引用和右值引用的区别：

左值引用是'对象的别名'，用于共享访问和避免拷贝；右值引用是'临时资源的所有权标识'，用于移动语义和完美转发，是 C++11 后提升性能的关键特性。左值引用和右值引用的目的都是减少拷贝，提高效率。

优点：左值引用可以修改参数/返回值，方便使用； 缺点：但是在有些场景下，左值引用在对象函数栈帧中结束了会销毁，不能使用左值引用返回。当前函数局部对象，出了当前函数作用域生命周期到了就销毁了，不能用左值返回，只能传值返回。

问题：那么如何解决只能传值返回，但是返回对象在函数栈帧结束之后会销毁的问题？

解决场景： 方案一：不用返回值，用输出型参数。不足：一定程度上牺牲了可读性； 方案二：编译器优化； 方案三：新标准新语法处理（右值引用），而右值引用可以延长函数对象的生命周期。

编译器不优化的场景是拷贝构造 + 拷贝赋值。VS2019 debug 版本传参有优化，对于 ret 赋值的没有优化到还是有拷贝构造和拷贝赋值，二代优化只有一次拷贝赋值，没有出现临时对象，没有拷贝构造。将构造和拷贝构造合二为一。 C++11 之后彻底不优化，但是调用了移动赋值和移动构造，这样会直接调用移动构造和移动赋值，传值返回的代价约等于 0。

在没有移动构造和移动赋值的情况下

构造场景

编译器如果不优化：先产生一个临时对象，str 函数哈哈栈帧结束后，临时对象接收 str 中存储的数据（一次拷贝构造），临时对象又会将内部存储的值拷贝构造给 main() 函数栈帧中的 ret。总体上来说是两次拷贝构造。

string addstring1(string nums1, string nums2) {
    string str;
    int end1 = nums1.size() - 1, end2 = nums2.size() - 1;
    int next = 0;
    ...
    str += ('0' + ret);
    ...
    return str;
}
int main() {
    // 构造场景
    string ret = addstring1("xndx", "lzdx");
    cout << ret.c_str() << endl;
    return 0;
}

不优化：会调用很多次构造。先构造参数，每一次参数的构造完成，还会调用拷贝构造； 一代优化：合二为一，没有临时对象的产生，只产生了一次拷贝构造，构造 + 拷贝构造。 二代优化：合三为一，直接构造。

赋值场景

不优化版本下：产生一个临时对象，str 在函数栈帧结束之前将内部资源拷贝构造给临时对象，由临时对象拷贝赋值给 main 函数中的 ret。参数构造 + 拷贝构造，最后还有一次拷贝赋值。 一代优化：多个参数构造，一次拷贝构造 + 一次拷贝赋值； 二代优化：拷贝构造和构造合二为一，最后一次拷贝赋值。

有移动构造和移动赋值 C++11 环境下

构造场景

不优化版本：str 先将内部资源移动构造给临时对象，main 函数中 ret 接收临时对象中的资源，也是移动构造，每一个参数构造 + 移动构造；

1 代优化：没有产生临时对象，编译器识别到 str 是'即将被返回的局部对象'，会将其视为右值；执行 return str; 时，触发移动构造：直接将 str 的资源'转移'给临时对象（而非拷贝）；进一步优化中，临时对象和 main 中的 ret 会'合二为一'（省略临时对象的构造），最终 str 的资源直接移动构造到 ret 中。此过程仅触发一次移动构造，资源转移效率极高（无额外拷贝）。构造参数 + 最终一次移动构造。

2 代优化（比如在 VS2022 编译器下）中甚至没有产生 str，只有 ret，也就是说 str 本质是 ret 对象的引用，实际上没有产生 str，一旦产生，函数栈帧销毁，局部对象 str 销毁，ret 就是野引用，所以 str 没有产生，其底层使用指针形式实现，这个时候打印出 str 和 ret 的地址 cout << &ret << endl; cout << &str << endl; 会发现他们的地址是相同的。这时候会直接构造，没有移动构造。

赋值的场景

不优化版本下：产生一个临时对象，str 在函数栈帧结束之前将内部资源拷贝构造给临时对象，由临时对象拷贝赋值给 main 函数中的 ret。参数构造 + 移动构造，最后还有一次移动赋值。 一代优化：多次构造，一次移动构造 + 一次移动赋值； 二代优化：构造和移动构造合二为一，只有构造和移动赋值。

总体来说：如果代码中有拷贝构造和拷贝赋值，也有移动构造和移动赋值，编译器一定会优先执行移动构造和移动赋值，因为选择的都是效率高的。当编译器升级 + C++ 支持移动构造和移动赋值，传值返回的效率变高。

问题：那么移动构造和移动赋值的效率这么高，需不需要在每一个类型中都实现？ 对于深拷贝的自定义类型（vector/string/map…），实现移动构造和移动赋值的价值很大，一定程度上比拷贝构造和拷贝赋值的效率高很多。 对于浅拷贝的自定义类型（如 Date/pair<int,int>…）不需要额外实现移动构造和移动赋值，因为浅拷贝的传值返回和移动构造移动赋值相比，浅拷贝没有指向资源，拷贝代价不大，效率差不多。

引用折叠

类型别名的引用折叠

int main() {
    typedef int& lref; // lref 是'int 的左值引用'类型
    typedef int&& rref; // rref 是'int 的右值引用'类型
    int n = 0;
    lref& r1 = n; // r1 的类型是 int&
    lref&& r2 = n; // r2 的类型是 int&
    rref& r3 = n; // r3 的类型是 int&
    rref&& r4 = 1; // r4 的类型是 int&&
    return 0;
}

总结：只要嵌套中存在左值引用（&），最终结果就是左值引用；只有纯右值引用（&&）嵌套时，才是右值引用。

模板函数的引用行为

// 由于引用折叠限定，f1 实例化以后总是一个左值引用
template<class T>
void f1(T& x) // 模板参数是左值引用，实例化的时候只能接受左值（n),无论 T 是什么类型，x 始终是左值引用（无折叠空间，因为参数已固定为& ）。
{}

// 由于引用折叠限定，f2 实例化后可以是左值引用，也可以是右值引用
template<class T>
void f2(T&& x) // 模板参数是万能引用（T&&）
{}

f1(T& x)：模板参数是左值引用，实例化时只能接受左值（如 n），且无论 T 推导为何，x 始终是左值引用（无折叠空间，因为参数已固定为 &）。 f2(T&& x)：模板参数是万能引用（T&&），实例化时：传入左值（如 n），T 推导为 int&，x 类型为 int& && → 折叠为 int&（左值引用）。传入右值（如 1），T 推导为 int，x 类型为 int&&（右值引用）。

结论：f1 只能处理左值引用，f2 可通过引用折叠同时处理左值和右值引用（万能引用的特性）。

f1(T& x) 本质是左值引用参数，显式实例化后仍为左值引用，非 const 时仅接受左值，const 时可接受左值和右值。 f2(T&& x) 是万能引用，显式实例化后通过引用折叠可变为左值或右值引用，需严格匹配实参的左值 / 右值属性。

总结：左值只能绑定左值引用，右值引用可以绑定右值引用和 const 左值引用。

// 由于引用折叠限定，f1 实例化以后总是一个左值引用
template<class T>
void f1(T& x) // 模板参数是左值引用，实例化的时候只能接受左值（n),无论 T 是什么类型，x 始终是左值引用（无折叠空间，因为参数已固定为& ）。
{}

// 由于引用折叠限定，f2 实例化后可以是左值引用，也可以是右值引用
template<class T>
void f2(T&& x) // 模板参数是万能引用（T&&）
{}

int main() {
    typedef int& lref; // lref 是'int 的左值引用'类型
    typedef int&& rref; // rref 是'int 的右值引用'类型
    lref& r1 = n; // r1 的类型是 int&
    lref&& r2 = n; // r2 的类型是 int&
    rref& r3 = n; // r3 的类型是 int&
    rref&& r4 = 1; // r4 的类型是 int&&
    int n = 0;
    // 没有折叠->实例化为 void f1(int& x)
    f1<int>(n); // n 是左值，可绑定到 int&；
    f1<int>(0); // 0 是右值，无法绑定到非 const 的 int& → 报错。
    // 折叠 f1<int&>(n); // n 是左值，可以绑定到 int& &
    f1<int&>(0); // 0 是右值，无法绑定，改正：f1<const int&>(0);
    // 折叠 f1<int&&>(n); // T=int&& → 参数类型为 (int&&)&（引用折叠为 int&）。n（左值）可绑定到 int&；
    f1<int&&>(0); // 0（右值）不可 → 后者报错。
    // 折叠->实例化为 void f1(const int& x)
    f1<const int&>(n); // T=const int& → 参数类型为 const int&（const 左值引用）。
    f1<const int&>(0); // 左值（n）和右值（0）都能绑定到 const int& → 均合法。
    // 折叠 f1<const int&&>(n); // const 右值引用
    f1<const int&&>(0); // 没有折叠->实例化为 void f2(int&& x)
    f2<int>(n); // T = int → 参数类型为 int &&（右值引用）。
    f2<int>(0); // 0 是右值，参数类型是 int &&(右值引用）
    // 折叠->实例化为 void f2(int& x)
    f2<int&>(n); // T = int& &&, n 是左值，左值引用和左值，不报错
    f2<int&>(0); // 左值引用和 0 会报错，左值无法引用右值，报错改正：f2<const int&>(0);
    // 折叠->实例化为 void f2(int&& x)
    f2<int&&>(n); // T=int&& → 参数类型为 (int&&)&&（折叠为 int&&，右值引用）。n（左值）无法绑定到 int&&；
    f2<int&&>(0); // 0（右值）可绑定 → 前者报错。
    return 0;
}

Function(T&& t) 函数模板程序中，假设实参是 int 右值，模板参数 T 的推导 int，实参是 int 左值，模板参数 T 的推导 int&，再结合引用折叠规则，就实现了实参是左值，实例化出左值引用版本形参的 Function，实参是右值，实例化出右值引用版本形参的 Function。

template<class T>
void Function(T && t) // 模板参数是万能引用（T&&）
{
    int a = 0;
    T x = a; // x++;// 所以 Function 内部会编译报错，x 不能++,error：不能给常量赋值
    cout << &a << endl;
    cout << &x << endl << endl;
}

int main() {
    Function(10); // 10 是右值，推导出 T 为 int，模板实例化为 void Function(int&& t)
    int a;
    Function(a); // a 是左值，推导出 T 为 int&，引用折叠，模板实例化为 void Function(int& t)
    Function(std::move(a)); // std::move(a) 是右值，推导出 T 为 int，模板实例化为 void Function(int&& t)
    const int b = 8;
    Function(b); // b 是左值，推导出 T 为 const int&, 引用折叠，模板实例化为 void Function(const int&& t)
    Function(std::move(b)); // std::move(b) 右值，推导出 T 为 const int，模板实例化为 void Function(const int&&t)
    return 0;
}