c++新特性之右值引用和移动语义

// 示例 1

int a = 5 ;

int & ref_a = a ; // 左值引用指向左值，编译通过

int & ref_a = 5 ; // 左值引用指向了右值，会编译失败

// 示例 2 （ const左值引用是可以指向右值的）

const int & ref_a = 5 ; // 编译通过，const左值引用不会修改指向值

// 实例3 （ const & 作为函数参数）

void push_back ( const value_type & val ); // 编译通过，const左值引用不会修改指向值

引用是变量的别名，由于右值没有地址，没法被修改，所以左值引用无法指向右值。

2.右值引用

再看下右值引用，右值引用的标志是 && ，顾名思义，右值引用专门为右值而生， 可以指向右值，不能指 向左值 ：

代码如下（示例）：

int && ref_a_right = 5 ; // ok

int a = 5 ;

int && ref_a_left = a ; // 编译不过，右值引用不可以指向左值

ref_a_right = 6 ; // 右值引用的用途：可以修改右值

3 对左右值引用本质的讨论

左右值引用的本质。

3.1 右值引用有办法指向左值吗？

有办法，使用 std::move ：

代码如下（示例）：

int a = 5 ; // a 是个左值

int & ref_a_left = a ; // 左值引用指向左值

int && ref_a_right = std::move ( a ); // 通过 std::move 将左值转化为右值，可以被右值引用指向

cout << a ; // 打印结果： 5

不理解左右值概念的人们往往以为它能把一个变量里的内容移动到另一个变量；
但事实上std::move移动不了什么，唯一的功能是把左值强制转化为右值，让右值引用可以指向左值。其实现等同于一个类型转换： static_cast<T&&>(lvalue) 。所以，单纯的std::move(xxx) 不会有性能提升。

同样的， 右值引用能指向右值 ，本质上也是把右值提升为一个左值，并定义一个右值引用通过 std::move 指向该左值：

int && ref_a = 5 ;

ref_a = 6 ;

等同于以下代码：

int temp = 5 ;

int && ref_a = std::move ( temp ); // 此时 temp 等于右值

ref_a = 6 ;

3.2 左值引用、右值引用本身是左值还是右值？

被声明出来的左、右值引用都是左值。因为被声明出的左右值引用是有地址的，也位于等号左边。仔细看下边代码：

// 形参是个右值引用

void change ( int && right_value ) {

        right_value = 8 ;

}

int main () {

        int a = 5 ; // a 是个左值

        int & ref_a_left = a ; // ref_a_left 是个左值引用

        int && ref_a_right = std::move ( a ); // ref_a_right 是个右值引用

        change ( a ); // 编译不过， a 是左值， change 参数要求右值

        change ( ref_a_left ); // 编译不过，左值引用 ref_a_left 本身也是个左值

        change ( ref_a_right ); // 编译不过，右值引用 ref_a_right 本身也是个左值

        change ( std::move ( a )); // 编译通过

        change ( std::move ( ref_a_right )); // 编译通过

        change ( std::move ( ref_a_left )); // 编译通过

        change ( 5 ); // 当然可以直接接右值，编译通过



         // 打印下面三个左值的地址，都是一样的

        cout << & a << ' ' ;

        cout << & ref_a_left << ' ' ;

        cout << & ref_a_right ;

}

作为函数返回值的 && 是右值，直接声明出来的 && 是左值

结论

从性能上讲，左右值引用没有区别，传参使用左右值引用都可以避免拷贝。
右值引用可以直接指向右值，也可以通过std::move指向左值；而左值引用只能指向左值(const左值引用也能指向右值)。
作为函数形参时，右值引用更灵活。虽然const左值引用也可以做到左右值都接受，但它无法修改，有一定局限性。

4、右值引用和std::move使用场景

std::move 只是类型转换工具，不会对性能有好处；

右值引用在作为函数形参时更具灵活性。他们有什么实际应用场景吗？

4.1 func(const T&)优化性能，避免浅拷贝

浅拷贝重复释放

对于含有堆内存的类，我们需要提供深拷贝的拷贝构造函数，如果使用默认构造函数，会导致堆内存的重复删除，比如下面的代码：

#include <iostream>
using namespace std;
class A
{
public:
    A() :m_ptr(new int(0)) {
        cout << "constructor A" << endl;
    }
    ~A(){
        cout << "destructor A, m_ptr:" << m_ptr << endl;
        delete m_ptr;
        m_ptr = nullptr;
    }
private:
    int* m_ptr;
};

// 为了避免返回值优化，此函数故意这样写
A Get(bool flag)
{
    A a;
    A b;
    cout << "ready return" << endl;
    if (flag)
        return a;
    else
        return b;
    }
int main()
{
    {
        A a = Get(false); // 运行报错
    }
    cout << "main finish" << endl;
    return 0;
}

// 上面代码运行结果

constructor A

constructor A

ready return

destructor A, m_ptr: 0xf87af8

destructor A, m_ptr:0xf87ae8

destructor A, m_ptr: 0xf87af8

main finish

深拷贝构造函数

在上面的代码中，默认构造函数是浅拷贝，main 函数的 a 和 Get 函数的 b 会指向同一个指针 m_ptr ，在析构的时候会导致重复删除该指针。正确的做法是提供深拷贝的拷贝构造函数，比如下面的代码：

#include <iostream>
using namespace std;
class A
{
public:
    A() :m_ptr(new int(0)) {
        cout << "constructor A" << endl;
    }
    A(const A& a) :m_ptr(new int(*a.m_ptr)) {
        cout << "copy constructor A" << endl;
    }
    ~A(){
        cout << "destructor A, m_ptr:" << m_ptr << endl;
        delete m_ptr;
        m_ptr = nullptr;
    }
private:
    int* m_ptr;
};

// 为了避免返回值优化，此函数故意这样写
A Get(bool flag)
{
    A a;
    A b;
    cout << "ready return" << endl;
    if (flag)
        return a;
    else
        return b;
}
int main()
{
    {
        A a = Get(false); // 正确运行
    }
    cout << "main finish" << endl;
    return 0;
}

// 上面代码运行结果

constructor A

constructor A

ready return

copy constructor A

destructor A, m_ptr:0xea7af8

destructor A, m_ptr:0xea7ae8

destructor A, m_ptr:0xea7b08

main finish

移动构造函数

这样就可以保证拷贝构造时的安全性，但有时这种拷贝构造却是不必要的，比如上面代码中的拷贝构造就是不必要的。上面代码中的 Get 函数会返回临时变量，然后通过这个临时变量拷贝构造了一个新的对象 b，临时变量在拷贝构造完成之后就销毁了，如果堆内存很大，那么，这个拷贝构造的代价会很大，带来了额外的性能损耗。有没有办法避免临时对象的拷贝构造呢？答案是肯定的。看下面的代码：

#include <iostream>
using namespace std;
class A
{
public:
    A() :m_ptr(new int(0)) {
        cout << "constructor A" << endl;
    }
    A(const A& a) :m_ptr(new int(*a.m_ptr)) {
        cout << "copy constructor A" << endl;
    }
    // 移动构造函数，可以浅拷贝
    A(A&& a) :m_ptr(a.m_ptr) {
        a.m_ptr = nullptr; // 为防止a析构时delete data，提前置空其m_ptr
        cout << "move constructor A" << endl;
    }
    ~A(){
        cout << "destructor A, m_ptr:" << m_ptr << endl;
        if(m_ptr)
        delete m_ptr;
    }
private:
    int* m_ptr;
};

// 为了避免返回值优化，此函数故意这样写
A Get(bool flag)
{
    A a;
    A b;
    cout << "ready return" << endl;
    if (flag)
        return a;
    else
        return b;
    }
int main()
{
    {
        A a = Get(false); // 正确运行
    }
    cout << "main finish" << endl;
    return 0;
}

// 上面代码运行结果

constructor A

constructor A

ready return

move constructor A

destructor A, m_ptr:0

destructor A, m_ptr:0xfa7ae8

destructor A, m_ptr:0xfa7af8

main finish

上面的代码中没有了拷贝构造，取而代之的是移动构造（ Move Construct ）。从移动构造函数的实现中可以看到，它的参数是一个右值引用类型的参数 A&& ，这里没有深拷贝，只有浅拷贝，这样就避免了对临时对象的深拷贝，提高了性能。这里的 A&& 用来根据参数是左值还是右值来建立分支，如果是临时值，则会选择移动构造函数。移动构造函数只是将临时对象的资源做了浅拷贝，不需要对其进行深拷贝，从而避免了额外的拷贝，提高性能。这也就是所谓的移动语义（ move 语义）， 右值引用的一个重 要目的是用来支持移动语义的。

移动语义可以将资源（堆、系统对象等）通过浅拷贝方式从一个对象转移到另一个对象，这样能够减少 不必要的临时对象的创建 、拷贝以及销毁，可以大幅度提高 C++ 应用程序的性能，消除临时对象的维护（创建和销毁）对性能的影响。

4.2 移动(move )语义

move是将对象的状态或者所有权从一个对象转移到另一个对象，只是转义，没有内存拷贝。要 move 语义起作用，核心在于需要对应类型的构造函数支持。

#include <vector>
#include <cstdio>
#include <cstdlib>
#include <string.h>
using namespace std;
class MyString {
private:
    char* m_data;
    size_t m_len;
    void copy_data(const char *s) {
        m_data = new char[m_len+1];
        memcpy(m_data, s, m_len);
        m_data[m_len] = '\0';
    }
public:
    MyString() {
        m_data = NULL;
        m_len = 0;
    }
    MyString(const char* p) {
        m_len = strlen (p);
        copy_data(p);
    }
    MyString(const MyString& str) {
        m_len = str.m_len;
        copy_data(str.m_data);
        std::cout << "Copy Constructor is called! source: " << str.m_data <<
        std::endl;
    }
    MyString& operator=(const MyString& str) {
        if (this != &str) {
            m_len = str.m_len;
            copy_data(str.m_data);
        }
        std::cout << "Copy Assignment is called! source: " << str.m_data <<
        std::endl;
        return *this;
    }
    
    // 用c++11的右值引用来定义这两个函数
    MyString(MyString&& str) {
        std::cout << "Move Constructor is called! source: " << str.m_data <<
        std::endl;
        m_len = str.m_len;
        m_data = str.m_data; //避免了不必要的拷贝
        str.m_len = 0;
        str.m_data = NULL;
    }
    MyString& operator=(MyString&& str) {
        std::cout << "Move Assignment is called! source: " << str.m_data <<
        std::endl;
        if (this != &str) {
            m_len = str.m_len;
            m_data = str.m_data; //避免了不必要的拷贝
            str.m_len = 0;
            str.m_data = NULL;
        }
        return *this;
    }
    virtual ~MyString() {
        if (m_data) free(m_data);
    }
};

int main()
{
    MyString a;
    a = MyString("Hello"); // Move Assignment
    MyString b = a; // Copy Constructor
    MyString c = std::move(a); // Move Constructor is called! 将左值转为右值
    std::vector<MyString> vec;
    vec.push_back(MyString("World")); // Move Constructor is called!
    return 0;
}

有了func(const T&)引用和转移语义，我们在设计和实现类时，对于需要动态申请大量资源的类，应该设计右值引用的拷贝构造函数和赋值函数，以提高应用程序的效率。