一、左值、纯右值和将亡值

左值：左值是可以放在赋值号左边，可以被赋值的值，左值必须要在内存中有实体，且能够用&取地址，例如函数名、变量名以及前置自增/自减运算符表达式等。

右值：右值分为纯右值和将亡值。纯右值要么本身就是一个字面值（只能用它的值来称呼它，如数字以及true和false等），要么其求值结果相当于字面值或是一个不具名的临时对象（如后置自增/自减运算符表达式等）。将亡值是由右值引用的产生而提出的，它一般是返回右值引用或转换为右值引用的函数表达式。

一个对象被用作右值时，使用的是它的内容（值），被当作左值时，使用的是它的地址。当我们用左值去初始化一个对象时，会调用拷贝构造函数来拷贝资源，而当用一个右值（包括纯右值和将亡值）来初始化时，会调用移动构造函数来移动资源，从而避免拷贝，提高效率。而当该右值完成初始化对象的任务时，它的资源已经移动给了被初始化的对象，因此该右值也将会被马上被销毁（析构）。

二、左值引用和右值引用

左值引用和右值引用：左值引用就是一级引用，即类型 &引用名 = 左值表达式，它必须被绑定到一个左值上，而不能被绑定到表达式或者字面常量等右值上。右值引用是二级引用，即类型 &&引用名 = 右值表达式，它必须被绑定到一个右值上。

#include <iostream>

using namespace std;

int main(int argc, char const *argv[]) {
    
    
    int num = 1;
    int &l_ref = num;
    int &&r_ref = num * 2;

    cout << "l_ref = " << l_ref << endl;
    cout << "r_ref = " << r_ref << endl;

    return 0;
}

atreus@MacBook-Pro % clang++ main.cpp -o main -std=c++11                                                         
atreus@MacBook-Pro % ./main 
l_ref = 1
r_ref = 2
atreus@MacBook-Pro % 

三、移动构造函数与移动语义

下面的代码基于拷贝构造函数实现了一个深拷贝的例子：

#include <iostream>

using namespace std;

class Data {
    
    
public:
    Data() {
    
     cout << "Data()" << endl; }

    Data(const Data &data) {
    
     cout << "Data(const Data &data)" << endl; }

    ~Data() {
    
     cout << "~Data()" << endl; }
};

class A {
    
    
public:
    Data *m_data;

public:
    A() {
    
    
        m_data = new Data;
    }

    /* 拷贝构造函数 */
    A(const A &a) {
    
    
        m_data = new Data(*a.m_data);
    }

    virtual ~A() {
    
    
        delete m_data;
    }
};

A func() {
    
    
    A t;
    return t;
}

int main() {
    
    
    A a = func();

    return 0;
}

atreus@MacBook-Pro % clang++ main.cpp -o main -fno-elide-constructors -std=c++11
atreus@MacBook-Pro % ./main                                                     
Data()                 // 构造func中的t
Data(const Data &data) // 将func中的t复制到一个临时变量中
~Data()                // 析构func中的t
Data(const Data &data) // 将func返回的临时变量复制到主函数中的a中
~Data()                // 析构func返回的临时变量
~Data()                // 析构主函数中的a
atreus@MacBook-Pro % 

从执行结果可以看出，由于函数在返回非引用对象时会通过临时变量来进行返回值的传递，因此在构造主函数中的a的过程中，func中的t与临时变量分别new了一个Data，而这两个Data在a构造后又被销毁。如果Data是一个非常复杂的类，这个过程会造成很大的堆内存浪费。

为了解决类似的内存浪费问题，引入了右值引用以及移动构造函数。

我们可以为类A添加一个移动构造函数：

/* 移动构造函数 */
A(A &&a) noexcept {
    
    
    m_data = a.m_data;
    a.m_data = nullptr;
}

atreus@MacBook-Pro % clang++ main.cpp -o main -fno-elide-constructors -std=c++11
atreus@MacBook-Pro % ./main                                                     
Data()  // 构造func中的t
~Data() // 析构主函数中的a
atreus@MacBook-Pro % 

不难看出，在添加了移动构造函数后，func中的t在最开始new了一个Data，然后该Data对应的堆内存空间被依次传递给了func返回的临时变量和主函数中的a，从而减少了两次Data的构造，避免了资源的重复申请和释放，提高了性能。

扫描二维码关注公众号，回复： 14707518 查看本文章

而这就是所谓的移动语义（move semantic），右值引用的一个重要目的就是支持移动语义。

此外，还有三点需要注意：

• 两段代码在编译过程中都使用了-fno-elide-constructors选项。实际上，C++允许编译器省略创建一个只是为了初始化另一个同类型对象的临时对象（即上述代码中func中的临时对象），而此编译选项表示关闭此优化，强调对拷贝构造函数的使用。
• 当我们在代码中声明类的移动构造函数时，通常会使用noexcept关键字来修饰对应的移动构造函数。实际上，在使用STL时为了保证容器类型的内存安全，在大多数情况下只会调用被标记为不会抛出异常的移动构造函数，否则便会调用其拷贝构造函数来作为代替。这是因为移动构造函数在移动资源后有可能会导致原本的资源所有者发生异常，而拷贝构造函数却不会，因此我们在使用移动构造函数时需要强调它的无异常。
• 上述代码中func中的临时变量其实就是一个将亡值，因为在完成初始化或赋值的任务时，它的资源已经移动给了被初始化者或被赋值者，同时它也将会马上被销毁。

四、std::move和std::forward

std::move和std::forward本质都是类型转换函数。std::move执行到右值的无条件转换，std::forward执行到右值的有条件转换，在参数都是右值时，二者就是等价的。std::move和std::forward就是在C++11基本规则之上封装的语法糖。

std::move执行到右值的无条件转换，就其本身而言，它没有move任何东西。

下面的例子通过std::move将a转换为一个右值并通过移动构造函数来对t进行赋值：

#include <iostream>

using namespace std;

class Data {
    
    
public:
    Data() {
    
     cout << "Data()" << endl; }

    Data(const Data &data) {
    
     cout << "Data(const Data &data)" << endl; }

    ~Data() {
    
     cout << "~Data()" << endl; }
};

class A {
    
    
public:
    Data *m_data;

public:
    A() {
    
    
        m_data = new Data;
    }

    /* 拷贝构造函数 */
    A(const A &a) {
    
    
        m_data = new Data(*a.m_data);
    }

    /* 移动构造函数 */
    A(A &&a) noexcept {
    
    
        m_data = a.m_data;
        a.m_data = nullptr;
    }

    virtual ~A() {
    
    
        delete m_data;
    }
};

int main() {
    
    
    A a;
    A t = std::move(a);

    return 0;
}

atreus@MacBook-Pro % clang++ main.cpp -o main -std=c++11
atreus@MacBook-Pro % ./main                             
Data()  // 构造a
~Data() // 析构t
atreus@MacBook-Pro % 

std::forward只有在它的参数绑定到一个右值上的时候，它才转换它的参数到一个右值。完美转发实现了参数在传递过程中保持其值属性的功能，即若是左值，则传递之后仍然是左值，若是右值，则传递之后仍然是右值。

而std::forward的完美转发是借助于引用折叠来实现的，即T & &、T & &&、T && &都会折叠成左值引用T &，而只有T && &&会折叠为右值引用T &&。

下面的例子分别向std::forward传递了左值参数和右值参数，所以依次调用了拷贝构造和移动构造：

#include <iostream>

using namespace std;

class Data {
    
    
public:
    Data() {
    
     cout << "Data()" << endl; }

    Data(const Data &data) {
    
     cout << "Data(const Data &data)" << endl; }

    ~Data() {
    
     cout << "~Data()" << endl; }
};

class A {
    
    
public:
    Data *m_data;

public:
    A() {
    
    
        m_data = new Data;
    }

    /* 拷贝构造函数 */
    A(const A &a) {
    
    
        m_data = new Data(*a.m_data);
    }

    /* 移动构造函数 */
    A(A &&a) noexcept {
    
    
        m_data = a.m_data;
        a.m_data = nullptr;
    }

    virtual ~A() {
    
    
        delete m_data;
    }
};

template<typename T>
void func(T &&a) {
    
    
    A t = std::forward<T>(a);
}

int main() {
    
    
    {
    
    
        A a;
        func(a);
    }
    printf("----------\n");
    {
    
    
        A a;
        func(std::move(a));
    }

    return 0;
}

atreus@MacBook-Pro % clang++ main.cpp -o main -std=c++11
atreus@MacBook-Pro % ./main                             
Data()
Data(const Data &data)
~Data()
~Data()
----------
Data()
~Data()
atreus@MacBook-Pro % 

总的来说，std::move执行到右值的无条件转换，但就其本身而言它没有move任何东西。而std::forward只有在它的参数绑定到一个右值上的时候，它才转换它的参数到一个右值，但它也没有转发任何东西。此外std::forward()不仅可以保持左值或者右值不变，同时还可以保持const、validate等属性不变。

参考：

https://www.jianshu.com/p/4538483a1d8a
https://www.jianshu.com/p/b90d1091a4ff
https://www.jianshu.com/p/61ea80fcf943
https://zhuanlan.zhihu.com/p/55856487