右值引用与移动构造函数、移动赋值

  有一阵子没看C++了，翻开C++Primer又陌生了一些，想了想引用，于是乎来看了下右值引用。

int a=5;
int &b=a;

  这是左值引用，若我们这样修改：

int a=5;
int &b=a+1;

  编译器会报错：非常量引用的初始值必须为左值。也就是右边的a+1是常量，常量给非常量引用赋值就报错。
我们可以这样修改就不报错了：

int a=5;
const int &b=a+1;

  此时我们可以试一试：

    int a = 5;
    const int &b = a+1;
    a++;
    cout << b;

  发现b的结果为6,也就是a++并没有影响到b，也就是说b指向的地址并不是a，而是一个新的地址存放着a+1的值，但是由于b被const修饰，我们无法修改b的值。
  C++11新增了右值引用，那什么是右值引用呢？右值引用用&&表示，右值可以是常量，或者一些表达式以及返回值的函数，如上面的左值引用，需要修改为const才能够把常量给赋值过来，而右值引用就如下：

    int a=5;
    int &&b=a+1;
    a++;
    cout<<b;

  该代码和上面的那串代码结果一样，其中变量b的地址是存放着a+1值的地址，不同点就是我们可以自由的修改b的值，而不像左值引用那样被const给限制。

移动语义和右值引用

  那么问题就来了，右值引用有什么用呢？我们来看看在类中的使用吧：

class A {
private:
    static int count;
    char *str;
    int len;
public:
    A(int n = 0, char ch = ' ') :len(n) {
        str = new char[n];
        for (int i = 0; i < n; i++)
        {
            str[i] = ch;
        }
        count++;
        showdata();
        cout << "构造函数" << endl;
    }
    ~A()
    {
        cout << "析构函数 :" << (void*)str << endl;
        delete[]str;
        str = nullptr;
    }
    A(const A &copy)
    {
        len = copy.len;
        str = new char[len];
        for (int i = 0; i < len; i++)
        {
            str[i] = copy.str[i];
        }
        count++;
        showdata();
        cout << "拷贝构造函数" << endl;
    }
    A(A &&copy)
    {
        str = copy.str;
        len = copy.len;
        copy.str = nullptr;
        copy.len = 0;
        count++;
        showdata();
        cout << "移动构造函数" << endl;
    }
    A operator+(const A &test)
    {
        A temp(len + test.len);
        for (int i = 0; i < len; i++)
        {
            temp.str[i] = str[i];
        }
        for (int i = 0; i < test.len; i++)
        {
            temp.str[i + len] = test.str[i];
        }
        return temp;
    }
    A operator=(const A &test)
    {
        if (this == &test)
            return *this;
        delete str;
        len = test.len;
        str = new char[len];
        for (int i = 0; i < len; i++)
            str[i] = test.str[i];
        return *this;
    }
    void showdata()
    {
        cout << count << endl;
        cout << "Len: " << len << endl;
        cout << "address: " << (void *)str << endl;
    }
    void Aprint()
    {
        if (len == 0)
            cout << "NULL" << endl;
        else
            for (int i = 0; i < len; i++)
                cout << str[i];
        cout << endl;
    }
};
int A::count = 0;
int main()
{
    A a(3, 'x'), b(2, 'o');
    A c(a+b);
    A d = a;
    cout << "a:";
    a.Aprint();
    cout << "b:";
    b.Aprint();
    cout << "c";
    c.Aprint();
    cout << "d:";
    d.Aprint();
    return 0;
}

结果：

代码、结果分析：
  首先，数字1、2下面对应的是a与b对象生成，调用构造函数，然后到a+b调用operator+,然后返回一个临时对象temp(调用构造函数)，然后就到c(temp)，此时并不是调用拷贝构造函数，而是移动构造函数，然后我们把原来的a+b产生的临时对象的str成员置成nullptr，于是调用了析构函数，析构0000000的位置(因为我们置临时对象为空了)，而我们的c就相当于窃取了temp的内容(改变了对象里面的str指针)，所以最后c的str地址没变，还是01052598而内容变为temp的。

  那么，这和拷贝构造有什么区别呢？区别就是，若我们使用拷贝构造函数，我们将会重新生成临时对象，然后对临时的数据进行批量的复制，然后又清除，很费力，而使用移动构造我们可以直接让数据指向临时数据所指向的数据，而不用进行批量的复制操作。就例如我们上面的代码，若不使用移动构造函数，a+b产生的临时对象让c调用拷贝构造，然后批量复制数据，若数据越大，就越影响计算机性能。

移动赋值

  同样的，我们既然可以这样修改构造函数为移动构造函数，我们也可以修改operator=，通过判断是否是自我复制，若不是，则将我们类的指针成员指向另一个对象的指针成员，省去很多操作，代码如下：

A operator=(A &&test) //此时的参数不能为const，因为我们要修改test的成员
    {
        if (this == &test)
            return *this;
        delete str;
        len = test.len;
        str = test.str;
        test.str = nullptr;
        test.len = 0;
        cout << "调用移动赋值" << endl;
        return *this;
    }

  若我们要使用移动赋值，我们可以将要让赋的值不是左值，看起来像右值，然后调用移动赋值运算，我们可以使用static_cast<>将对象的类型强制转换为classtype &&，除此之外,C++11提供了一种方式，通过使用utility头文件，使用std::move()。
如下：

    A a(3, 'x'), b(2, 'o');
    //a=static_cast<A>(b);
    a=std::move(b);
    a.Aprint();
    b.Aprint();

结果：

  可以看见对象b的值被置为空，而a的str值为对象b的str值。