【C++】11新特性：左右值引用、移动语义move、完美转发forward

C++11新增了右值引用，C++11引入了右值引用的概念，使得我们把引用与右值进行绑定。使用两个“取地址符号”：

int&& rvalue_ref = 10;

在学习右值引用之前，有一些相关概念需要了解。

一、相关概念

1.1 左值和右值

• 通过等号划分

  • 左值：可以放到等号左边的东西叫左值。
  • 右值：不可以放到等号左边的东西就叫右值。

• 通过是否可取地址划分

  • 左值：可以取地址并且有名字的东西就是左值。
  • 右值：不能取地址的没有名字的东西就是右值。

举例：

int a = b + c;

a是左值，有变量名，可以取地址，也可以放到等号左边, 表达式b+c的返回值是右值，没有名字且不能取地址，&(b+c)不能通过编译，而且也不能放到等号左边。

int a = 4; // a是左值，4作为普通字面量是右值

左右值的区别很明显：

左值有持久的状态，而右值要么是字面常量，要么是在表达式求值过程中创建的临时对象。

左值一般有：

• 函数名和变量名
• 返回左值引用的函数调用
• 前置自增自减表达式++i、–i
• 由赋值表达式或赋值运算符连接的表达式(a=b, a += b等)
• 解引用表达式*p
• 字符串字面值"abcd"（跟其他字面量有点不太一样）

1.2 纯右值和将亡值

纯右值和将亡值都属于右值。

• 纯右值

运算表达式产生的临时变量、不和对象关联的原始字面量、非引用返回的临时变量、lambda表达式等都是纯右值。

举例：

• 除字符串字面值外的字面值
• 返回非引用类型的函数调用
• 后置自增自减表达式i++、i–
• 算术表达式(a+b, a*b, a&&b, a==b等)
• 取地址表达式等(&a)

• 将亡值

将亡值是指C++11新增的和右值引用相关的表达式，通常指将要被移动的对象、T&&函数的返回值、std::move函数的返回值、转换为T&&类型转换函数的返回值。

将亡值可以理解为即将要销毁的值，通过“盗取”其它变量内存空间方式获取的值，在确保其它变量不再被使用或者即将被销毁时，可以避免内存空间的释放和分配，延长变量值的生命周期，常用来完成移动构造或者移动赋值的特殊任务。

举例：

class A {
    xxx;
};
A a;
auto c = std::move(a); // c是将亡值
auto d = static_cast<A&&>(a); // d是将亡值

二、左值引用和右值引用

通过名字也能大概明白：

• 左值引用就是对左值进行引用的类型；
• 右值引用就是对右值进行引用的类型。

他们都是引用，都是对象的一个别名，并不拥有所绑定对象的堆存，所以都必须立即初始化。

type &name = exp; // 左值引用
type &&name = exp; // 右值引用

• 左值引用

示例：

int a = 5;
int &b = a; // b是左值引用
b = 4;
int &c = 10; // error，10无法取地址，无法进行引用
const int &d = 10; // ok，因为是常引用，引用常量数字，这个常量数字会存储在内存中，可以取地址

可以得出结论：

对于左值引用，等号右边的值必须可以取地址，如果不能取地址，则会编译失败，或者可以使用const引用形式，但这样就只能通过引用来读取输出，不能修改数组，因为是常量引用。

• 右值引用

如果使用右值引用，那表达式等号右边的值需要时右值，可以使用std::move函数强制把左值转换为右值。

int a = 4;
int &&b = a; // error, a是左值
int &&c = std::move(a); // ok

三、移动语义

谈移动语义前，首先需要了解深拷贝与浅拷贝的概念

• 浅拷贝

示例:

class A {
public:
    A(int size) : size_(size) {
        data_ = new int[size];
    }
    A(){}
    A(const A& a) {
        size_ = a.size_;
        data_ = a.data_;
        cout << "copy " << endl;
    }
    ~A() {
        delete[] data_;
    }
    int *data_;
    int size_;
};
int main() {
    A a(10);
    A b = a;
    cout << "b " << b.data_ << endl;
    cout << "a " << a.data_ << endl;
    return 0;
}

上面代码中，两个输出的是相同的地址，a和b的data_指针指向了同一块内存，这就是浅拷贝，只是数据的简单赋值，那再析构时data_内存会被释放两次，导致程序出问题，这里正常会出现double free导致程序崩溃的，这样的程序肯定是有隐患的，如何消除这种隐患呢？

• 深拷贝

示例：

class A {
public:
    A(int size) : size_(size) {
        data_ = new int[size];
    }
    A(){}
    A(const A& a) {
        size_ = a.size_;
        data_ = new int[size_];// mark
        cout << "copy " << endl;
    }
    ~A() {
        delete[] data_;
    }
    int *data_;
    int size_;
};
int main() {
    A a(10);
    A b = a;
    cout << "b " << b.data_ << endl;
    cout << "a " << a.data_ << endl;
    return 0;
}

深拷贝就是再拷贝对象时，如果被拷贝对象内部还有指针引用指向其它资源，自己需要重新开辟一块新内存存储资源，而不是简单的赋值。

• 移动语义

移动语义可以理解为转移所有权，之前的拷贝是对于别人的资源，自己重新分配一块内存存储复制过来的资源。

而对于移动语义，类似于转让或者资源窃取的意思，对于那块资源，转为自己所拥有，别人不再拥有也不会再使用，通过C++11新增的移动语义可以省去很多拷贝负担，怎么利用移动语义呢，是通过移动构造函数。

class A {
public:
    A(int size) : size_(size) {
        data_ = new int[size];
    }
    A(){}
    A(const A& a) {
        size_ = a.size_;
        data_ = new int[size_];
        cout << "copy " << endl;
    }
    A(A&& a) {
        this->data_ = a.data_;
        a.data_ = nullptr;//
        cout << "move " << endl;
    }
    ~A() {
        if (data_ != nullptr) {
         delete[] data_;
        }
    }
    int *data_;
    int size_;
};
int main() {
    A a(10);
    A b = a;
    A c = std::move(a); // 调用移动构造函数
    return 0;
}

如果不使用std::move()，会有很大的拷贝代价，使用移动语义可以避免很多无用的拷贝，提供程序性能，C++所有的STL都实现了移动语义，方便使用。例如：

std::vector<string> vecs;
...
std::vector<string> vecm = std::move(vecs); // 免去很多拷贝

注意：移动语义仅针对于那些实现了移动构造函数的类的对象，对于那种基本类型int、float等没有任何优化作用，还是会拷贝，因为它们实现没有对应的移动构造函数。

四、完美转发

当我们将一个右值引用传入函数时，他在实参中有了命名，所以继续往下传或者调用其他函数时，根据C++ 标准的定义，这个参数变成了一个左值。那么他永远不会调用接下来函数的右值版本，这可能在一些情况下造成拷贝。

为了解决这个问题 C++ 11引入了完美转发，根据右值判断的推倒，调用forward 传出的值，若原来是一个右值，那么他转出来就是一个右值，否则为一个左值。这样的处理就完美的转发了原有参数的左右值属性，不会造成一些不必要的拷贝。

示例：

#include 
using namespace std;

void PrintV(int &t)
{
    cout << "lvalue" << endl;
}

void PrintV(int &&t)
{
    cout << "rvalue" << endl;
}

template <typename T>
void Test(T &&t)
{
    PrintV(t);
    PrintV(std::forward<T>(t));

    PrintV(std::move(t));
}

int main()
{
    Test(1); // lvalue rvalue rvalue
    int a = 1;
    Test(a);                       // lvalue lvalue rvalue
    Test(std::forward<int>(a));    // lvalue rvalue rvalue
    Test(std::forward<int &>(a));  // lvalue lvalue rvalue
    Test(std::forward<int &&>(a)); // lvalue rvalue rvalue
    return 0;
}

分析

• Test(1)：1是右值，模板中T &&t这种为万能引用，右值1传到Test函数中变成了右值引用（具名的右值引用是左值），但是调用PrintV()时候，t变成了左值，因为它变成了一个拥有名字的变量，所以打印lvalue，而PrintV(std::forward(t))时候，会进行完美转发，按照原来的类型转发，所以打印rvalue，PrintV(std::move(t))毫无疑问会打印rvalue。
• Test(a)：a是左值，模板中T &&t这种为万能引用，左值a传到Test函数中变成了左值引用，所以有代码中打印。
• Test(std::forward(a))：转发为左值还是右值，依赖于T，T是左值那就转发为左值，T是右值那就转发为右值。

五、总结

右值引用作为是C++11中最重要的新特性之一，解决了C++中大量的历史遗留问题，使C++标准库的实现在多种场景下消除了不必要的额外开销（如std::vector, std::string)，也使得另外一些标准库（如std::unique_ptr, std::function）成为可能。

即使我们在开发过程中不使用右值引用，也可以通过标准库，简介从这一新特性中受益。

右值引用至少可以解决以下场景中的移动语义缺失问题：

• 按值传入参数

  string func(string name){
      string sname = move(name);
  }
  

• 按值返回

  • 在函数中返回stl对象时，会优先调用移动构造函数，如果不符再调用拷贝构造函数。尽管v是左值，仍然会优先采用移动语义，返回vector从此变得云淡风轻。此外，无论移动或是拷贝，可能的情况下仍然适用编译器优化，但语义不受影响。

  • 对于std::unique_ptr来说，这简直就是福音。

    unique_ptr<SomeObj> create_obj(/*...*/) {
      unique_ptr<SomeObj> ptr(new SomeObj(/*...*/));
      ptr->foo(); // 一些可能的初始化
      return ptr;
    }
    

• 接收右值表达式

• 对象存入容器

  • 这个问题和前面的构造函数传参是类似的。不同的是这里是按两种引用分别传参。参见std::vector的push_back函数。

    void push_back( const T& value ); // (1)
    void push_back( T&& value ); // (2)
    
    

  • 不用多说自然是左值调用1右值调用2。如果你要往容器内放入超大对象，那么版本2自然是不2选择。

    vector<vector<string>> vv;
    
    vector<string> v = {"123", "456"};
    v.push_back("789"); // 临时构造的string类型右值被移动进容器v
    vv.push_back(move(v)); // 显式将v移动进vv
    

当然还有其他好多地方可以用，暂时就先介绍我见过的一些了。