c++ 右值引用

1. 左值和右值

　　简单的定义来说，能够放在赋值等号左边的就是左值，反之则是右值（所有表达式不是左值就是右值，左右值不存在交集）——但是这个解释实在有点鸡肋。下面对定义结合例子做些补充。

• 右值：在内存中不占有内存的表达式
• 左值：在内存中占有一定内存位置的表达式

int i;
i = 2; //合法
2 = i; //非法

　　例子合法性很好理解——可以在结合左右值的定义。

#include<iostream>
int main()
{
    int t;
    int* q = &(t + 1);//非法，t+1在内存中没有位置

    int arr[] = { 1,2,3 }; int r[] = { 1,2,3 };
    int* i = arr; //合法
    std::cout << arr << std::endl; // 006FF808
    arr = r; // 非法
    *(arr) = 10;//合法
}

　　在这里，我们需要理解下第八行，arr 作为右值—— 注意 arr 是内存地址，是一个地址，不同于第一个例子中的 i 。在第九行可以看到打印的 arr 代表的地址内容，第十行也就必定是错误的（是右值就不可能作为左值）。

　　而第11行，arr 貌似变成了左值——也就是左值和右值在一定程度上是可以转换的。其中扮演关键角色的就是 * 解引用。既然是左值，按照我们前面说的，那应该在内存中存在一处分配的内存位置，*arr 解引用之后的确是存了 1 这个数，所以可以重新赋值10。

2. 右值引用

　　通过下面的例子来理解：

#include<iostream>
#include<string>
using namespace std;
struct A
{
    // 构造函数
    explicit A(size_t _size = 0) :size(_size),ptr(new int[_size]()) {
        cout << "construct..."<< endl;
    }

    // 拷贝赋值运算符
    A& operator=(const A& tmp) {
        if (&tmp != this)
        {
            this->ptr = new int[tmp.size];
            for (size_t i = 0; i < tmp.size; ++i) {
                this->ptr[i] = tmp.ptr[i];
            }
        }
        cout << "copy assignment 等于..." << endl;
        return *this;
    }

    // 拷贝构造函数
     A(const A& tmp) {
        this->ptr = new int[tmp.size];
        for (size_t i = 0; i < tmp.size; ++i) {
            this->ptr[i] = tmp.ptr[i];
        }
        cout << "copy construct..." << endl;
    }

    // 析构函数
    ~A() {
        if (ptr) 
        {
            delete[] ptr;
            size = 0;
            cout << "destructor..." << endl;
        }
    }

private:
    int* ptr;
    size_t size;
};

int main()
{
    A a(10);
    A b;

    cout<< "=====start=====" <<endl;
    b = a;
    cout << "=====end=====" << endl << endl;

    cout << "=====start2=====" << endl;
    A c = a;//是拷贝构造。或者加上explicit改成A c(a) 可能更好理解
    cout << "=====end2=====" << endl << endl;

    A d;
    cout << "=====start3=====" << endl;
    d = A(5);
    cout << "=====end3=====" << endl << endl;

    return 0;
}

 　　结果上看，应该都比较好理解。

　　其中第三处是要引出的重点，可以看到应该使用了 d = A（10），这条语句，A() 是一个临时变量，在完成 construct -> copy assignment 之后就进行了 destructor。我们来讨论下这一句赋值语句的内部过程，A(10) 调用构造函数并申请了内存空间，然后去实现拷贝赋值运算符，临时变量A(10)的内容【copy】给 d 变量，随后 A(10) 被销毁。而我们知道在 copy assignment （拷贝赋值运算符）方法中，我们又为 d 变量同样申请了 大小为10的数组空间，这就出现了一定的“低效处理”。不妨这样想，如果我们将A(10)申请的空间，通过拷贝赋值运算符，直接将这个空间给变量d，这样d就不用再去申请空间（反正A(10)的空间申请了，马上就会释放。相当于白白多申请和释放了一次，不如直接将A(10)的空间转移到d变量名下）。

　　这就引入了右值引用，如下例子：

#include<iostream>
#include<string>
using namespace std;
struct A
{
    // 构造函数
    explicit A(size_t _size = 0) :size(_size),ptr(new int[_size]()) {
        cout << "construct..."<< endl;
    }

    // 拷贝赋值运算符
    A& operator=(const A& tmp) {
        if (&tmp != this)
        {
            this->ptr = new int[tmp.size];
            for (size_t i = 0; i < tmp.size; ++i) {
                this->ptr[i] = tmp.ptr[i];
            }
        }
        cout << "copy assignment 等于..." << endl;
        return *this;
    }

    // 使用右值引用的拷贝赋值运算符
    A& operator=(A&& tmp) {
        if (&tmp != this)
        {
            this->ptr = tmp.ptr;
            this->size = tmp.size;

            tmp.ptr = nullptr;
            tmp.size = 0;
        }
        cout << "copy assignment 等于2..." << endl;
        return *this;
    }

    // 拷贝构造函数
     A(const A& tmp) {
        this->ptr = new int[tmp.size];
        for (size_t i = 0; i < tmp.size; ++i) {
            this->ptr[i] = tmp.ptr[i];
        }
        cout << "copy construct..." << endl;
    }

    // 析构函数
    ~A() {
        if (ptr) 
        {
            delete[] ptr;
            size = 0;
            cout << "destructor..." << endl;
        }
    }

private:
    int* ptr;
    size_t size;
};

int main()
{
    A a(10);
    A b;

    cout<< "=====start=====" <<endl;
    b = a;
    cout << "=====end=====" << endl << endl;

    cout << "=====start2=====" << endl;
    A c = a;//是拷贝构造。或者加上explicit改成A c(a) 可能更好理解
    cout << "=====end2=====" << endl << endl;

    A d;
    cout << "=====start3=====" << endl;
    d = A(10);
    cout << "=====end3=====" << endl << endl;

    return 0;
}

 　　可以看到通过使用右值引用，执行一样的 d = A（5）操作会调用右值引用的拷贝运算符方法。这样写就能达到如下效果：A(5)申请了临时空间，但是这空间通过拷贝运算符方法（右值引用）直接被 d 变量接管，d 变量无需再去申请空间了。注意：第31，32行代码不能不写，经过28，29行之后，d 变量和 A(5) 临时变量的指针都指向了同一块内存，而之后 A(5) 将被销毁，所以需要将 A(5) 的指针置为 nullptr，但这部分内存由 d 对象接管。注意：这里看上去好像少了临时变量 A(5) destructor（没有打印），其实对象 A(5) 也是执行了析构，析构时释放这个类——也就是临时A(5)这个类，但是因为我析构函数有个if条件，所以只是看上去没有打印罢了，反正依旧会执行析构。

3. std::move()

 　　我们先看下面的例子：

#include<iostream>
using namespace std;
void f(int&& i) {
    cout << "右值引用" << endl;
}

void f(int& i) {
    cout << "左值引用" << endl;
}

int main()
{
    f(4); // 右值引用
    int i = 3;
    f(i); // 左值引用
    f(int());// 右值引用.int() 调用默认构造函数，返回 0 值

    f(std::move(i));  // 右值引用
    f(std::move(3)); // 左值引用
}

　　因为我们已经知道了如果分辨左值和右值，所以输出应该都在意料之内。

　　但是请比较第15行 和 第18行，可以看到同一个变量 i 怎么还能输出不同的结果？其中的关键就是 std::move()，请注意：std::move() 并不是如上文提到的内存接管，而是将 左值->变换成-> 右值。

3.1 实例一：移动构造函数　

#include<iostream>
using namespace std;
class Test
{
public:
    Test()
    {
        cout << "constructor " << endl;
    }

    Test(const Test& t)
    {
        cout << "copy constructor " << endl;
    }

    Test& operator = (const Test& t)
    {
        cout << "copy = constructor" << endl; return *this;
    }

    Test(Test&& t)   
    {
         cout << "move constructor" << endl;
    }

    Test& operator =(Test&& t)
    {

        cout << "move = constructor" << endl; return *this;
    }

    ~Test()
    {
        cout << "destructor " << endl;

    }
};

int main()
{
    Test a;
    cout << "start " << endl;
    Test b = std::move(a);  
    cout << "end " << endl << endl;

    cout << "start2 " << endl;
    Test c = a;   
    cout << "end2 " << endl << endl;
    return 0;
}

　

 　注意：如果没有 21~24行的移动构造函数，则结果如下，再构造 Test b 的时候会使用赋值构造函数

3.2 实例二 移动赋值函数

　　改变main 函数中的两句话：

#include<iostream>
using namespace std;
class Test
{
public:
    Test()
    {
        cout << "constructor " << endl;
    }

    Test(const Test& t)
    {
        cout << "copy constructor " << endl;
    }

    Test& operator = (const Test& t)
    {
        cout << "copy = constructor" << endl;
        return *this;
    }

    Test(Test&& t)   
    {
         cout << "move constructor" << endl;
    }

    Test& operator =(Test&& t)
    {

        cout << "move = constructor" << endl;
        return *this;
    }

    ~Test()
    {
        cout << "destructor " << endl;

    }
};

int main()
{
    Test a;
    Test b;
    cout << "start " << endl;
    b = std::move(a);
    cout << "end " << endl << endl;

    Test c;
    cout << "start2 " << endl;
    c = a;
    cout << "end2 " << endl << endl;
    return 0;
}

完结，撒花。*★,°*:.☆(￣▽￣)/$:*.°★* 。