c++11——右值引用

1. 左值和右值

左值是表达式结束之后仍然存在的持久化对象，而右值是指表达式结束时就不再存在的临时对象。
c++11中，右值分为两种类型：将亡值(xvalue, expiring value)，另一个是纯右值(prvalue, pure rvalue). 非引用返回的临时变量、运算表达式产生的临时变量、原始字面量和lambda表达式等都是纯右值；将亡值是c++11新增的、与右值引用相关的表达式，比如，将要被移动的对象、T&&函数返回值、std::move返回值和转换为T&&的类型的转换函数的返回值。

2. 左值引用

左值引用是对左值进行引用的类型，分为常量左值引用和非常量左值引用。其中，常量左值引用可以引用常量左值、非常量左值、常量右值、非常量右值；而非常量左值引用只能引用非常量左值。

    int x = 1;
    const int y = 2;
    int& p1 = x;
    int& p2 = y; //出错，非常量左值引用无法引用常量
    const int& p3 = x;
    const int& p4 = y;

3. 右值引用

c++11增加了右值引用类型，实现对一个右值进行引用，标记为T&&. 因为右值不具名，因此只能通过引用的方式找到它。

右值引用延长右值的生命期
左值引用和右值引用必须在声明的时候立即初始化，因为引用本身并不拥有所绑定对象的内存，只是该对象的一个别名。通过右值引用的声明，该右值又“重获新生”，其生命周期变得和右值引用类型变量的生命期一样长，只要该变量还活着，该右值临时量将会一直存活下去。

利用右值引用延长右值生命期，可以避免一些临时对象的构造和析构，从而提高性能。比如：

class A{
public:
    A(){
        cout << "construct..." << endl;
    }
    ~A(){
        cout << "Destruct..." << endl;
    }
    A(const A&a a){
        cout << "Copy construct..." << endl;
    }
private:
};
A GetA(){
    return A();
}
int main(){
    A a = GetA();
    return 0;
}

以上代码，如果禁止编译器自动进行RVO优化，完全尊造c++的语法规则，则程序的输出为

其中，GetA()函数内部的A()函数生成一个内部的对象obj1时调用构造函数；在函数返回时，临时对象obj2通过拷贝构造函数拷贝了该内部对象的内容；函数返回之后，内部对象obj1调用析构函数销毁；然后 A a = obj2，通过调用拷贝构造函数，a拷贝obj2；a赋值结束之后，obj2 调用析构函数销毁；最后程序结束时，a调用析构函数销毁。

这整个过程中，在调用函数GetA时会构造和析构临时对象obj2，因此造成不必要的浪费。在c++98/03中可以通过const A& a = GetA()来将临时对象obj2赋值给一个常量左值引用a，延长了该临时对象的生命期；而在c++11中，也可以通过右值引用来延长函数返回时的临时对象（右值）的生命期，而不是在a = GetA()一结束就销毁。

其中，GetA()函数内部的A()函数生成一个内部的对象obj1时调用构造函数；在函数返回时，临时对象obj2通过拷贝构造函数拷贝了该内部对象的内容；函数返回之后，内部对象obj1调用析构函数销毁；然后 const A& a = obj2或者 A&& a = obj2，此时都是对引用进行初始化，没有对象的构造和析构；当程序结束时，obj2（也就是a）进行析构。

4. T&&的赋值

（1）左值和右值是独立于他们的类别的，右值引用类型可能是左值也可能是右值
（2）auto&& 或者函数参数类型自动推导的T&&是一个未定的引用类型，被称为universal reference，它可能是左值引用类型也可能是右值引用类型，取决于初始化的值类型。
（3）所有的右值引用叠加到右值引用上仍然是一个右值引用，其他引用叠加都为左值引用。当T&&为模板参数时，输入左值，它将会变成左值引用，而输入右值时则变为具名的右值引用。
（4）编译器会将已命名的右值引用视为左值，而将未命名的右值引用视为右值。

4.1 左值和右值是独立于他们的类别的，右值引用类型可能是左值也可能是右值
int && a = xxxx;中a本身的类型为右值引用，但它是一个具名的变量，为左值

    int &&var1 = 10; //var1为右值引用
    auto&& var2 = var1; //var2此时为一个universial reference，但是由于var1本身是一个左值，因此var2 为左值引用
    int w1, w2;
    auto&& v1 = w1; //左值引用
    decltype(w1)&& v2 = w2; //int &&v2 = w2; //此时对一个右值引用初始化为一个左值，出错！！

4.2 auto&& 或者函数参数类型自动推导的T&&是一个未定的引用类型，被称为universal reference，它可能是左值引用类型也可能是右值引用类型，取决于初始化的值类型。

    auto&& a = 10; //a直接由一个右值初始化，则a为一个右值引用类型
    int x = 20;
    auto&& b = x; //b由一个左值进行初始化，则b为一个左值引用类型
    template<typename T>
    void func(T&& a){
    cout << a << endl;
    }
    ....
    func(10); //被一个右值初始化，a为右值引用类型, a类型为 int&&
    int x = 10;
    func(x); //左值引用类型， a为int& !!!!!
    void f(std:vector<T>&& param); //这里需要注意，这里既有推导类型T，又有确定类型vector。。。。在实际
    //应用时，调用该函数之前，Vector<T>中的推断类型T已经确定了，所以到调用该f函数的时候就没有类型推
    //则 param为右值引用
    template<typenmae T>
    void f(const T&& param){ //这里虽然有类型推导，但是由于带有const限定，则仍然为右值引用
    }

即右值操作符&&只在 auto && / T&& ，且不带cv限定符的时候，才需要推断具体为左值还是右值引用，否则一律为右值引用。

4.3 所有的右值引用叠加到右值引用上仍然是一个右值引用，其他引用叠加都为左值引用。
当T&&为模板参数时，输入左值，它将会变成左值引用，而输入右值时则变为具名的右值引用。

引用折叠
由于存在T&&这种未定引用类型，当它作为参数时，有可能被一个左值引用或者右值引用的参数初始化，这时经过类型推导的T&&类型，相比右值引用（&&）会发生类型的变化，这种变化成为引用折叠。

    typedef const int T;
    typedef T& TR;
    TR v

TR的定义	v的定义	v的实际类型
T&	TR v	T&
T&	TR& v	T&
T&	TR&& v	T&
T&&	TR v	T&&
T&&	TR& v	T&
T&&	TR&& v	T&&

从而，可以看出 所有的右值引用叠加到右值引用上仍然是一个右值引用，其他引用叠加都为左值引用。

4.4 编译器会将已命名的右值引用视为左值，而将未命名的右值引用视为右值

    void print(int& i){
        cout << "lvalue " << i << endl;
    }
    void print(int&& i){
        cout << "rvalue " << i << endl;
    }
    void forward(int&& i){
        print(i);
    }
    forward(10); //10为右值，进入forward之后，10变为i，i为一个变量，变为左值。
    //因此，输出 "lvalue " << i << endl;

5. 右值引用优化性能，避免深拷贝

对于含有堆内存的类，需要提供深拷贝的拷贝构造函数，如果使用默认构造函数，将会导致堆内存的重复删除。

class A{
public:
    A(): m_ptr(new int(0)){};
    ~A(){
        delete m_ptr;
    }
private:
    int *m_ptr;
};
A Get(bool flag){
    A a;
    A b;
    if (flag)
        return a;
    else
        return b;
}
int main(){
    A a = Get(false);   //默认的拷贝构造函数，只是简单的将m_ptr进行赋值
    //在 Get函数内部的b被析构的时候delete m_ptr, 当程序结束的时候a析构也delete m_ptr，二者m_ptr相同。造成内存的重复析构
    return 0;
}

而如果为类的拷贝构造函数提供了深拷贝，则在程序产生临时对象的时候会出现大量的内存拷贝，降低性能。此时可以使用移动构造函数进行改进。

class A{
public:
    A(): m_ptr(new int(0)){};
    A(const A& a):m_ptr(new int(*a.m_ptr)){}; //深拷贝的拷贝构造函数
    A(A&& a):m_ptr(a.m_ptr){    //移动构造函数
        a.m_ptr = NULL;
    }
 
    ~A(){
        delete m_ptr;
    }
private:
    int *m_ptr;
};
A Get(bool flag){
    A a;
    A b;
    if (flag)
        return a;
    else
        return b;
}
int main(){
    A a = Get(true); //调用移动构造函数
    A b = a;         //调用拷贝构造函数
    return 0;
}

使用移动构造函数，其参数是一个右值引用类型的参数 A&&, 没有深拷贝，只有浅拷贝，避免了对临时对象的深拷贝，提高了性能。这里的A&&用来根据参数是左值还是右值来建立分支，如果是临时值，则会选择移动构造函数；否则，则会选择拷贝构造函数。
在拷贝的源对象为临时的时候，调用移动构造函数，该函数将原来临时对象的资源移动到了拷贝的目的对象，并且将源对象的资源赋空。则之后，源对象被析构，资源已经被转移到目的对象。

除了使用移动构造补充拷贝构造，还可以使用移动赋值操作符代替拷贝赋值操作符。

class A{
public:
    A(): m_ptr(new int(0)){};
    A(const A& a):m_ptr(new int(*a.m_ptr)){}; //深拷贝的拷贝构造函数
    A(A&& a):m_ptr(a.m_ptr){    //移动构造函数
        a.m_ptr = NULL;
    }
    A& operator=(const A& a){
        m_ptr = new int(*a.m_ptr);
    }
    A& operator=(A&& a){
        m_ptr = a.m_ptr;
        a.m_ptr = NULL;
    }
    ~A(){
        delete m_ptr;
    }
private:
    int *m_ptr;
};
A Get(bool flag){
    A a;
    A b;
    if (flag)
        return a;
    else
        return b;
}
int main(){
    A a = Get(true); //调用移动构造函数
    A b = a;         //调用拷贝构造函数
 
    a = Get(false); //调用移动赋值操作符
    a = b;  //调用拷贝赋值操作符
    return 0;
}

上面添加了move版本的构造函数和赋值函数，对原来的类产生了一些影响：如果提供了move版本的构造函数，则不会生成默认的构造函数。另外，编译器永远不会自动生成move版本的构造函数和赋值函数，他们需要手动显式的添加。
当添加了move版本的构造函数和赋值函数的重载形式后，某一个函数调用应当使用哪一个重载版本呢？下面是按照判决的优先级列出的3条规则：
（1）常量值只能绑定到常量引用上，不能绑定到非常量引用上
（2）左值优先绑定到左值引用上，右值优先绑定到右值引用上
（3）非常量值优先绑定到非常量引用上

c++类的拷贝构造函数和赋值操作符：

class A{
public:
　　A(int x){
　　　　x_ = x;
 
　　};
　　A(const A& a){
　　　　x_ = a.x_;
　　}
     A& operator=  (const A& a){
　　　　x_ = a.x_;
　　}
private:
　　int x_;
};
A　 getA(int x){
　　return A(x);
} ;
A a = getA(1);  //拷贝构造函数
A b = getA(2); //拷贝构造函数　
b = a;　　　　//赋值操作符

拷贝构造函数是在构造类的对象的时候调用的，即 A a = getA(1); 这句新建了一个类A的对象a，调用拷贝构造函数。而赋值操作符是对一个已经存在的对象进行重新赋值，不重新生成对象。

参考

http://www.cnblogs.com/hujian/archive/2012/02/13/2348621.html