1. 右值引用
C++11以前，右值被认为是无用的资源，所以在C++11中引入了右值引用，就是为了重用右值。定义右值引用需要使用&&。
右值引用一定不能被左值所初始化，只能用右值初始化。那么为什么呢？因为右值引用的目的是为了延长用来初始化对象的生命周期，对于左值，其生命周期与其作用域有关，你没有必要去延长。既然是延长，那么就出现了下面的情况：
int x = 20; // 左值
int&& rx = x * 2; // x*2的结果是一个右值，rx延长其生命周期
int y = rx + 2; // 因此你可以重用它：42
rx = 100; // 一旦你初始化一个右值引用变量，该变量就成为了一个左值，可以被赋值
复制代码1.1. 右值引用作用
1.1.1. 延长生命周期
在C++11以前，我们常写如下例子：
class A
{
public:
A() : m_ptr(new int(0))
{
cout << "construct" << endl;
}
A(const A& rhs) : m_ptr(new int(*rhs.m_ptr)) // 拷贝构造函数
{
cout << "copy construct" << endl;
}
~A()
{
cout << "destruct" << endl;
delete m_ptr;
}
private:
int* m_ptr;
};
A Get(bool flag)
{
A a, b;
if (flag)
{
return a;
}
return b;
}
int main()
{
A a = Get(false);//调用拷贝构造函数
return 0;
}
执行结果：
construct
construct
copy construct
destruct
destruct
destruct
复制代码问题：上述例子中Get函数会返回临时变量，然后通过这临时变量拷贝构造一个新的对象a，临时变量在拷贝构造完成之后就销毁了，如果堆内存很大，这个拷贝构造就比较消耗时间，带来性能的损耗，是否有方法避免临时对象的拷贝构造呢？即改成如下形式：
class A
{
public:
A() : m_ptr(new int(0))
{
cout << "construct" << endl;
}
A(const A& rhs) : m_ptr(new int(*rhs.m_ptr)) // 拷贝构造函数
{
cout << "copy construct" << endl;
}
A(A&& rhs) : m_ptr(rhs.m_ptr) //移动构造函数
{
rhs.m_ptr = nullptr;
cout << "move construct" << endl;
}
~A()
{
cout << "destruct" << endl;
delete m_ptr;
}
private:
int* m_ptr;
};
A Get(bool flag)
{
A a, b;
if (flag)
{
return a;
}
return b;
}
int main()
{
A a = Get(false);//调用拷贝构造函数
return 0;
}
执行结果：
construct
construct
move construct
destruct
destruct
destruct
复制代码改进之后，不再调用拷贝构造函数，而是调用了移动构造函数(move construct)。从移动构造函数的实现可以看到，它的参数是一个右值引用类型的参数T&&，这里没有深拷贝，只有浅拷贝，这样就避免了对临时对象的深拷贝，和资源的重复申请和释放，提高了性能；延长了临时对象的生命周期，即上述例子中把返回值临时对象的生命周期交由给main函数中的a对象。
1.1.2. 转移不可拷贝的资源
如果资源是 不可拷贝 (non-copyable) 的，那么装载资源的对象也应该是不可拷贝的。
如果资源对象不可拷贝，一般需要定义 移动构造/移动赋值 函数，并禁用 拷贝构造/拷贝赋值 函数。例如，智能指针 std::unique_ptr只能移动 (move only)：
template<typename T>
class unique_ptr {
public:
unique_ptr(const unique_ptr& rhs) = delete;
unique_ptr(unique_ptr&& rhs) noexcept; // move only
private:
T* data_ = nullptr;
};
unique_ptr::unique_ptr(unique_ptr&& rhs) noexcept {
auto &lhs = *this;
lhs.data_ = rhs.data_;
rhs.data_ = nullptr;
}
复制代码1.2. 右值引用几点说明
- 右值引用就是对一个右值进行引用的类型，因为右值不具名，因此只能通过引用的方式找到它；
- 通过右值引用的声明，该右值又“重获新生（生命周期延长，原本是生命周期是要结束）”，其生命周期与右值引用类型变量的生命周期一样；
- 无论声明为右值引用还是左值引用都必须立即初始化；
1.3. 右值引用解决如下问题
1.3.1. 移动语义std::move
移动语义是通过右值引用来匹配临时值的，那么，普通的左值是否也能借助移动语义来优化性能呢？
C++11为了解决上述问题，提供了std::move方法来将左值转换为右值，从而方便应用移动语义，即无论你传给它的是左值还是右值，通过std::move之后都变成了右值；move实际上并不能移动任何东西，他唯一的功能是将一个左值强制转换为一个右值引用，使我们可以通过右值引用使用该值；
class string {
public:
string(const string& other); // Copy constructor, exists pre C++11
string(string&& other) { // Move constructor, new in C++11
length = other.length;
capacity = other.capacity;
data = other.data;
other.data = nullptr; // 将临时对象的指针设置为空，other.data = nullptr;。若不将other.data设置为空，other.data 将被释放两次，导致程序异常。
}
private:
size_t length;
size_t capacity;
const char* data;
};
int main(){
string a(get_string()); // move constructor
string b(a); // copy constructor
string c(std::move(b)); // move constructor
return 0;
}
复制代码**注意：**若string中没有移动构造函数string(string&& other)，上述的string c(std::move(b))仍然将调用拷贝构造函数进行构造，因为string(const string& other)的参数是const reference。
C++11中，编译器将会在类中自动添加移动构造函数和移动赋值操作符，因此C++11中，声明一个类，编译器会默认添加构造函数、拷贝构造函数、析构函数、移动构造函数和移动赋值操作，号称类中的"5驾马车"，而不是C++11之前的“3驾马车”。
若用户自定义拷贝构造函数，编译器将不会自动添加移动构造函数和移动赋值操作。可以在这些函数之后添加 = delete，显示的阻止编译器自动添加对应的函数。
通过std::move将左值转移成右值后，即原来的变量放弃了内存的所有权，后续代码不能使用该变量来访问对象；如果使用，会出现 未定义行为。
std::string base_url = tag->GetBaseUrl();
if (!base_url.empty()) {
UpdateQueryUrl(std::move(base_url) + "&q=" + word_); //若执行了，后续base_url不能使用，若使用会出现未定义行为。
}
LOG(INFO) << base_url; // |base_url| may be moved-from
复制代码而被移动的对象处于于合法但未指定状态：
- 基本要求）能正确析构（不会重复释放已经被移动了的资源，例如
std::unique_ptr::~unique_ptr()检查指针是否需要delete） - （一般要求）重新赋值后，和新的对象没有差别（
C++标准库基于这个假设） - （更高要求）恢复为默认值（例如
std::unique_ptr恢复为nullptr）
auto p = std::make_unique<int>(1);
auto q = std::move(p);
assert(p == nullptr); // OK: reset to default
p.reset(new int{2}); // or p = std::make_unique<int>(2);
assert(*p == 2); // OK: reset to int*(2)
复制代码由于基本类型不包含资源，其移动和拷贝相同：被移动后，保持为原有值。
int i = 1;
int j = std::move(i);
assert(i == j)
复制代码1.3.2. 完美转发std::forward
完美转发实现了参数在传递过程中保持其值属性的功能，即若是左值，则传递之后仍然是左值，若是右值，则传递之后仍然是右值。
void func(int &arg) {
std::cout << "func lvalue" << std::endl;
}
void func(int &&arg) {
std::cout << "func rvalue" << std::endl;
}
template <typename T>
void wrapper(T &&args) { //无论args是什么引用类型，args都是左值
func(args);
}
int main() {
int a = 10;
wrapper(a); //传递左值
wrapper(20); //传递右值
return 0;
}
以上函数输出：
func lvalue
func lvalue
复制代码上述例子并没有做到对应的调用，其对应原因是：在wrapper函数中调用func函数时，对应的引用类型不能保持不变，即引用属性不能进行传递。所以，C++11提供了std::forward()函数用于完美转发。即，在转发过程中，左值引用在被转发之后仍然保持左值属性，右值引用在被转发之后依然保持右值属性。修改之后的代码如下：
void func(int &arg) {
std::cout << "func lvalue" << std::endl;
}
void func(int &&arg) {
std::cout << "func rvalue" << std::endl;
}
template <typename T>
void wrapper(T &&args) {
func(std::forward<T>(args));
}
int main() {
int a = 10;
wrapper(a);
wrapper(20);
return 0;
}
结果输出如下：
func lvalue
func rvalue
复制代码2. 拷贝省略
尽管C++引入了移动语义，移动的过程 仍有优化的空间 —— 与其调用一次 没有意义的移动构造函数，不如让编译器 直接跳过这个过程 —— 于是就有了拷贝省略(copy elision)。
然而，很多人会把移动语义和拷贝省略 混淆：
- 移动语义是 语言标准 提出的概念，通过编写遵守移动语义的 移动构造函数、右值限定成员函数，逻辑上 优化 对象内资源 的转移流程
- 拷贝省略是（
C++ 17前）非标准的 编译器优化，跳过移动/拷贝构造函数，让编译器直接在 移动后的对象 内存上，构造 被移动的对象
std::unique_ptr<int> foo() {
auto ret = std::make_unique<int>(1);
//...
return std::move(ret); // -> return ret;
}
复制代码没必要使用 std::move() 移动非引用返回值。C++ 会把 即将离开作用域的 非引用类型的 返回值当成 右值，对返回的对象进行移动构造（语言标准）；如果编译器允许拷贝省略，还可以省略这一步的构造，直接把 ret 存放到返回值的内存里（编译器优化）。
3. std::move和std::forward的用处
3.1. case1——不移动右值引用参数
std::unique_ptr<int> bar(std::unique_ptr<int>&& val) {
//...
return val; // not compile
// -> return std::move/forward(val);
}
复制代码上述代码的问题在于：没有对返回值使用 std::move()（编译器提示 std::unique_ptr(const std::unique_ptr&) = delete 错误）。
因为不论 左值引用 还是 右值引用 的变量（或参数）在初始化后，都是左值。所以，返回右值引用变量时，需要使用 std::move()/std::forward() 显式的 移动转发 或 完美转发，将变量 “还原” 为右值（右值引用类型）。