1 左值和左值引用
在说右值引用之前，需要先说一下左值引用。当然，在右值引用出现之前，左值引用也不叫左值引用，就叫引用。现在一般也直接将左值引用称作引用，将右值引用称作右值引用。左值引用类似于 c 语言中经常使用的指针，c++ 引入左值引用，在一定程度上可以代替指针。
什么是左值，简单来说，左值是等号左边的值，是可以取地址的。左值引用就是左值的别名，左值引用和左值指向同一块内存；左值引用就像人的小名，指的是同一个人，这个人长高了 5cm，那么说这个人的大名和小名的时候，都长高了 5cm。
如下代码，是左值引用的例子：
（1）左值引用需要在声明的时候初始化
（2）左值引用不能指向一个右值，但是 const 左值引用可以用一个右值进行初始化
#include <iostream>
#include <string>
int main() {
int a = 10;
int &b = a;
printf("a = %d, b = %d\n", a, b);
b = 20;
printf("a = %d, b = %d\n", a, b);
// int &c; // 编译错误，左值引用在声明的时候必须初始化
// int &d = 10; // 编译错误，左值引用不能使用一个右值初始化
const int &e = 10;
printf("&a = %p, &b = %p, &e = %p\n", &a, &b, &e);
return 0;
}
下图打印出了 a 和 e 的地址，从地址可以看出来，对于 e 来说，虽然是用一个右值进行初始化，但是这个右值也是保存在栈上的。const 左值引用，类似于如下两句代码，只不过栈上这块内存是编译器内部分配的，开发者不感知。
int temp = 10;
int &e = temp ;
const 左值引用能使用一个右值进行初始化，这种情况在调用函数传参的时候也会遇到。如果函数形参是一个非 const 左值引用的话，那么调用函数的时候，如果直接传右值，会报编译错误；形参是 const 左值引用的话，那么可以直接传右值。当我们看到一个函数的形参是 const 左值引用的时候，总是习以为常，其实 const 左值引用还起到这样的作用，即可以直接传右值。
#include <iostream>
#include <string>
void Test(const int &data, int a, int b) {
int la = 10;
printf("data = %d\n", data);
int lb = 20;
printf("&data = %p, &a = %p, &b = %p\n", &data, &a, &b);
printf("&la = %p, &lb = %p\n", &la, &lb);
}
int main() {
int a = 10;
Test(a, 10, 20);
printf("----------------\n");
Test(100, 30, 40); // 如果形参不是 const 左值引用的话，那么这句话编译会报错
int b = 20;
printf("main, &a = %p, &b = %p\n", &a, &b);
return 0;
}
代码运行结果如下，从运行结果来看，当传值 100 的时候，实参保存在了 main 函数的栈里，而不是和另外两个形参 a 和 b 挨着保存。
2 右值和右值引用
右值是不能取地址的，等号右边的值。
如下代码，说明如下：
（1）Test() 函数的第一个形参是右值引用，这样的话在调用函数的时候，第一个实参可以直接传右值，而不需要像左值引用那样，形参必须是 const 左值引用，才可以传右值。
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <string>
void Test(int &&a, int b, int c) {
int la = 100;
printf("a = %d, b = %d, c = %d\n", a, b, c);
printf("&a = %p, &b = %p, &c = %p\n", &a, &b, &c);
int lb = 100;
printf("&la = %p, &lb = %p\n", &la, &lb);
return;
}
int main() {
int a = 100;
Test(1, 2, 3);
Test(4, 5, 6);
Test(7, 8, 9);
int b = 200;
printf("\n--------------------------------\n");
printf("main, &a = %p, &b = %p\n", &a, &b);
int &&c = 10;
printf("&c = %p\n", &c);
c = 100;
printf("c = %d, &c = %p\n", c, &c);
return 0;
}
（2）运行结果如下，在函数 Test() 中打印了形参 a、b、c 的地址，发现 b 和 c 的存储是挨着的，a 和它俩并不是挨存储的。a 存储在 main() 函数的栈里，并且多次调用的时候，使用的是一块相同的地址。多次调用复用一块地址。
使用右值引用的时候，稍有不慎就很容易出现 bug。c++ 中引用的出现本来就是为了代替 c 语言中的指针，简化使用的，但是随着版本的迭代，引用却越来越复杂。
本人在工作中就遇到过右值引用使用不当导致的 bug，链接放在下边。
[c++] 记录一次引用使用不当导致的 bug
（3）右值引用，只不过是 c++ 中的一个语法，右值引用的底层实现和 const 左值引用是类似的，也是有自己的存储内存的，上边的例子就是保存在栈上，只不过这块内存是编译器来分配的，开发者不感知；右值引用和 const 左值引用的区别是，前者可以修改，后者不可以修改。
（4）右值引用本身是一个左值，因为右值引用在 = 左边，可以取地址
如下代码，左值引用可以使用 a 进行初始化，a 和 b 指向同一块内存区域。
#include <iostream>
#include <string>
int main() {
int &&a = 10;
int &b = a;
printf("a = %d, b = %d\n", a, b);
b = 100;
printf("a = %d, b = %d, &a = %p, &b = %p\n", a, b, &a, &b);
return 0;
}
（5）右值引用不能使用左值进行初始化
类似于左值引用在声明的时候需要初始化，右值引用在声明的时候也需要初始化。
非 const 左值引用不能使用右值初始化，同样的，右值引用也不能使用左值进行初始化。如下面的代码 int &&c = a; int &&d = b，这两行代码都会导致编译错误。可以使用 std::move() 将左值转换为右值，从打印地址来看，c 和 a 指向同一个地址，d 和 b 指向同一个地址。
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <string>
int main() {
int a = 10;
int &&b = 20;
// int &&c = a; // cannot bind rvalue reference of type ‘int&&’ to lvalue of type ‘int’
// int &&d = b; // cannot bind rvalue reference of type ‘int&&’ to lvalue of type ‘int’
printf("a = %d, b = %d, &a = %p, &b = %p\n", a, b, &a, &b);
int &&c = std::move(a);
int &&d = std::move(b);
c = 100;
d = 200;
printf("a = %d, b = %d, &a = %p, &b = %p\n", a, b, &a, &b);
printf("c = %d, d = %d, &c = %p, &d = %p\n", c, d, &c, &d);
return 0;
}
从 std::move 的官方说明也能看出来，std::move() 可以将变量类型转变为右值引用类型。
3 为什么要引入右值引用
右值引用，理解和使用起来，都有点难度，并且使用时容易出错，但是在某些场景下，那为什么还要引入右值引用呢，使用右值引用对代码能带来什么优化 ？
3.1 移动语义
右值引用，最明显的意义是支持移动语义。在右值引用之前，c++ 中是不支持移动语义的，比如我要移动一个对象，那么会首先进行拷贝，将旧对象的数据拷贝到新对象中，然后旧对象销毁。这种方式我们习以为常，但这种方式的效率却是比较低下的。假想我们搬家的场景，也是我们的生活物品移动的过程，我们会先把物品再重新买一份，然后把旧物品销毁吗，当然不会的。
c++ 中移动语义通过 std::move() 来实现，移动的意思就是将对象中的内容移动到新对象中了，那么旧对象就不再使用了。
如下代码，是将 std::string 进行移动，将 str 移动到 str1 中。
#include <iostream>
#include <string>
#include <stdlib.h>
#include <stdio.h>
int main() {
std::string str = "hello world, hello world";
std::cout << "1, str " << str << ", str size " << str.size() << std::endl;
printf("str addr = %p\n", str.c_str());
std::string str1 = std::move(str);
std::cout << "2, str " << str << ", str size " << str.size() << ", capacity " << str.capacity() << std::endl;
printf("str1 addr = %p, str addr = %p\n", str1.c_str(), str.c_str());
std::string str2 = str1;
printf("str2 addr = %p\n", str2.c_str());
return 0;
}
运行结果如下，从运行结果我们可以得到以下几点：
（1）str 通过 std::move() 被移动到 str1 之后，str 中就没有字符串了，size 是 0
（2）打印出了 str 和 str1 的字符串的地址，可以看到两者是相等的，这也能说明，在 str 移动到 str1 的过程中，没有进行拷贝，而是将字符串的地址赋值给了 str1；str2 使用 str1 进行赋值，没有使用 std::move()，那么就时通过拷贝来完成的。
（3）上边的代码，字符串长度大于 15，这样才能观察到移动的现象；如果字符串长度不大于 15 的话，每个 std::string 都会有一个自带的数组来保存字符串，这种情况下仍然会拷贝，而不是移动，因为当字符串不大于 15 的时候，std::string 不会申请内存，而是使用自带的字符串。
3.2 移动构造
移动构造也是一种构造方式，形参是右值引用数据类型。移动构造在如下 3 种情况下会调用:
（1）显示使用 std::move() 构造一个新对象时
（2）使用 std::move() 进行函数传参时
（3）函数返回对象值的时候。这种情况下默认会有返回值优化，看不到移动的过程，如果编译的时候将返回值优化关闭，则可以看到移动过程
#include <iostream>
#include <string>
class Test {
public:
Test(int data) : data_(data) {
std::cout << "constructor " << data_ << std::endl;
}
Test(const Test& o) : data_(o.data_) {
std::cout << "copy constructor " << data_ << std::endl;
}
Test(Test&& o) noexcept : data_(o.data_) {
std::cout << "move constructor " << data_ << std::endl;
}
void PrintData() {
std::cout << "data = " << data_ << std::endl;
}
private:
int data_;
};
void func1(Test t) {
t.PrintData();
}
Test func2(Test t) {
return t;
}
Test func3() {
Test t(10);
return t;
}
int main() {
Test t1(1);
Test t2(std::move(t1)); // 显示调用 std::move() 进行构造
func1(std::move(t2)); // 显式调用 std::move() 进行传参
Test t3(3);
func2(t3); // 函数返回 t 对象
Test t4 = func3(); // 默认有返回值优化，只构造一次，如果编译时使用 -fno-elide-constructors 关闭返回值优化，则在函数内构造一次，返回和赋值的时候后 move 两次
return 0;
}
移动构造函数在什么情况下才会默认生成 ？ 移动构造默认生成的限制条件是比较多的，不想拷贝构造函数，用户不显式声明的话，编译器就会隐式生成。以下条件都满足的情况下，编译器才会隐式生成移动构造函数。
（1）用户没有定义拷贝构造函数。如果用户定义了拷贝构造函数，那么编译器不会生成移动构造函数。
（2）用户没有定义拷贝赋值运算符。如果用户定义了拷贝赋值运算符，那么编译器不会生成移动构造函数。
（3）用户自定义了移动构造函数。如果用户自定义了移动构造函数，那么编译不再默认生成。
（4）用户没有定义析构函数。如果用户定义了析构函数，那么编译器不会生成默认的移动构造函数。
std::vector 中的数据使用一个动态数组来维护的。如果一直向 vector 中 push 数据的话，那么就会频繁出现数组扩容的情况，数组扩容的话，就是申请一块新的内存，然后将旧数组中的数据拷贝到新数组中，然后销毁旧数组。
如果对象支持移动构造的话，那么在 std::vector 扩容的时候就会使用移动构造来移动数组中的元素，而不是使用拷贝加销毁的方式来移动元素。
#include <iostream>
#include <string>
#include <vector>
class Test {
public:
Test(int data) : data_(data) {
std::cout << "constructor " << data_ << std::endl;
}
Test(const Test& o) : data_(o.data_) {
std::cout << "copy constructor " << data_ << std::endl;
}
Test(Test&& o) noexcept : data_(o.data_) {
std::cout << "move constructor " << data_ << std::endl;
}
void PrintData() {
std::cout << "data = " << data_ << std::endl;
}
private:
int data_;
};
int main() {
std::vector<Test> v;
std::cout << "1, v size = " << v.size() << ", capacity = " << v.capacity() << std::endl;
Test t1(1);
v.push_back(t1);
std::cout << "2, v size = " << v.size() << ", capacity = " << v.capacity() << std::endl;
Test t2(2);
v.push_back(t2);
std::cout << "3, v size = " << v.size() << ", capacity = " << v.capacity() << std::endl;
return 0;
}
运行结果如下，从运行结果可以看出来，在向数组中 push_back t2 之前，数组容量是 1，所以需要扩容，扩容的时候，对于数组中已经存在 t1，使用了移动构造的方式，而不是使用拷贝构造。
移动构造函数声明为 noexcept 的时候，编译器才会使用移动构造；如果没有 noexcept 修饰，那么仍然使用拷贝构造。
移动构造的形参是右值引用，右值引用的意思是这个值是一个临时值，函数返回之后，生命周期就结束了。std::move() 的意思也是，被 move 之后的对象只剩下一个空壳子了。std::move() 和右值引用结合起来使用，语义是一致的。
3.3 移动赋值运算符
移动赋值运算符，拷贝赋值运算符有些类似，当给一个已经创建的对象赋值的时候，才会调用赋值运算符；如果这个对象还不存在，那么调用的是拷贝构造函数或者移动构造函数。
在满足如下条件之后，编译器才会生成默认的移动赋值运算符。有一点需要注意，如果显式声明了移动构造函数，那么也不会默认生成移动赋值。
如下是官方的例子。
#include <iostream>
#include <string>
#include <utility>
struct A
{
std::string s;
A() : s("test") {}
A(const A& o) : s(o.s) { std::cout << "move failed!\n"; }
A(A&& o) : s(std::move(o.s)) {
std::cout << "move construct\n";
}
A& operator=(const A& other)
{
s = other.s;
std::cout << "copy assigned\n";
return *this;
}
A& operator=(A&& other)
{
s = std::move(other.s);
std::cout << "move assigned\n";
return *this;
}
};
A f(A a) { return a; }
struct B : A
{
std::string s2;
int n;
// implicit move assignment operator B& B::operator=(B&&)
// calls A's move assignment operator
// calls s2's move assignment operator
// and makes a bitwise copy of n
};
struct C : B
{
~C() {} // destructor prevents implicit move assignment
};
struct D : B
{
D() {}
~D() {} // destructor would prevent implicit move assignment
D& operator=(D&&) = default; // force a move assignment anyway
};
int main()
{
A a1, a2;
std::cout << "Trying to move-assign A from rvalue temporary\n";
a1 = f(A()); // move-assignment from rvalue temporary
std::cout << "Trying to move-assign A from xvalue\n";
a2 = std::move(a1); // move-assignment from xvalue, A 中显式定义了移动赋值运算符
std::cout << "\nTrying to move-assign B\n";
B b1, b2;
std::cout << "Before move, b1.s = \"" << b1.s << "\"\n";
b2 = std::move(b1); // calls implicit move assignment，B 中没有显式定义移动赋值运算符，也没有定义拷贝构造，移动构造，拷贝赋值，析构函数，所以会生成默认的移动赋值运算符
std::cout << "After move, b1.s = \"" << b1.s << "\"\n";
std::cout << "\nTrying to move-assign C\n";
C c1, c2;
c2 = std::move(c1); // calls the copy assignment operator，定义了析构函数，那么移动构造和移动赋值运算符都不会默认生成
std::cout << "\nTrying to move-assign D\n";
D d1, d2;
d2 = std::move(d1); // 定义了析构函数，但是使用 default 强制生成了默认移动构造，所以会调用移动构造
}
4 参考
std::move - cppreferenc.com
Move constructors - cppreference.com
Move assignment operator - cppreference.com
