C11性能之道：右值引用

1、左值与右值

　　C++11中新增了一种类型，右值引用，标记为T &&。

　　首先来介绍什么是左值和右值，左值是指表达式结束后依旧存在的持久对象，而右值是指表达式结束之后就不再存在的临时对象。一个区分左值与右值的简单方法就是：

　　能不能对表达式取值，如果能，则是左值，否则为右值。所有具名变量或对象都是左值，右值不具名。

　　其中，右值又有两个概念，将亡值和纯右值。非引用返回的临时变量、运算表达式产生的临时变量、原始字面量和lambda表达式都是纯右值。将亡值在C++11中引进，将要移动的对象、T &&函数返回值、std::move返回值和转换为T &&的类型转换函数的返回值都是将亡值。

2、&&的特性

　　右值引用是对一个右值进行引用，因为右值不具名，所以只能通过引用的方式找到。右值引用不拥有绑定对象的内存，所以必须立即初始化，右值引用其实就是延长右值临时变量的生命周期，只要该右值引用变量存在，该临时右值变量则会一直存在。

#include <iostream>

using namespace std;

int g_construct_count = ;
int g_copyconstruct_count = ;
int g_destruct_count = ;

struct A
{
    A()
    {
        cout << "construct:" << ++g_construct_count << endl;
    }

    A(const A &a)
    {
        cout << "copyconstruct:" << ++g_copyconstruct_count << endl;
    }

    ~A()
    {
        cout << "destruct:" << ++g_destruct_count << endl;
    }
};

A GetA()
{
    return A();
}

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

    return ;
}

　　当GCC使用编译参数-fno-elide-constructors关闭返回值优化结果，会有以下输出结果：

construct:
copyconstruct:
destruct:
copyconstruct:
destruct:
destruct:

　　如果开起返回值优化，那么结果如下：

construct:
destruct:

　　这种优化是来自编译器优化，并不是C++标准，但是我们可以通过&&来做优化，也就是右值引用，当我们开起-fno-elide-constructors,再来看结果：

//调用代码
int main()
{
    A &&a = GetA();

    return ;
}

//执行结果：
construct:
copyconstruct:
destruct:
destruct:

　　通过右值引用，比之前要少一次拷贝构造和析构，也就是在A &&a = GetA();的时候发生的，在这个时候使临时变量的生命周期延长。
　　其实不用C++11，使用C++98/03同样可以达到以上效果，将代码改成const A& a = GetA(),常量左值引用可以接收左值、右值、常量左值和常量右值，但是普通的左值引用不接受右值，如A& a = GetA()会编译不过，非常量左值只接受左值。
　　T&&并不是表示右值，有可能表示左值，也有可能表示右值。但是T &&必须被初始化，被右值初始化就是右值，被左值初始化就是左值。

template<typename T>
void f(T && param);

f();   //10是右值
int x = ;
f(x);    //x是左值

　　当有自动推导的时候（模板自动推导，auto），&&是一个未定义的引用类型。

template<typename T>
void f(T&& param); 　　　　 //类型需要推导，&&是一个未定义引用类型

template<typename T>
class Test
{
   Test(Test && ths);     //右值，定义特定类型，没有类型推断
}

void f(Test && param);    //右值，定义确定类型，没有类型推断

template<typename T>
void f(std::vector<T> && param); //右值，vector<T>已经确定类型

template<typename T>
void f(const T && param);        //右值，加上const修饰改变未定义引用

　　当未定义引用类型仅在T&&的时候有效，任何附加条件都会使其失效变成一个普通的右值引用。这种类型变化在C++11中成为折叠引用，其规则如下：

• 　　所有的右值引用叠加到右值引用还是右值引用；
• 　　所有的其他引用类型之间的叠加都变成左值引用。

int &&var1 = x; 　　　　　　　　//var1->int &&，右值引用
auto &&var2 = var1; 　　　　   //var2存在类型推导，未定义引用类型，var2->int &，左值引用

int i1,i2;
auto && v1 = i1;  　　　　　　  //左值，被左值初始化
decltype(i1) && v2 = i2; 　　  //error，右值引用不能被左值初始化

　　对于左值初始化右值引用可以使用std::move;

decltype(i1) && v2 = std::move(i2);

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

#include <iostream>

using namespace std;

int g_lvalue = ;
int g_rvalue = ;

void PrintValue(int &i)
{
    cout << "Lvalue:" << i << endl;
}

void PrintValue(int &&i)
{
    cout << "Rvalue:" <<  i << endl;
}

void Forward(int &&i)
{
    PrintValue(i);  //转发之后变成左值，右值变成一个命名对象，编译器当成左值
}

int main()
{
    int i = ;
    PrintValue(i);
    PrintValue();
    Forward();

    return ;
}

　　执行结果：

Lvalue:
Rvalue:
Lvalue:

　　总结：
　　左值引用和右值引用独立于他们的类型，右值引用类型可能值左值也可能是右值；
　　auto &&或函数参数类型自动推导的T &&是一个未定的引用类型，可能是左值引用也可能是右值引用，取决于初始化类型；
　　所有的右值引用叠加到右值引用是一个右值引用，其它类型都为左值引用；
　　编译器会将已命名的右值引用视为左值，未命名的右值引用视为右值。

2、右值引用，避免深拷贝

　　当一个类含有堆内存，我们需要提供深拷贝的拷贝函数，如果使用默认构造函数会出现内存的重复删除。

#include <iostream>

class A
{
public:
    A() :m_ptr(new int()){}

    ~A()
    {
        delete m_ptr;
    }
private:
    int *m_ptr;
};

int main()
{
    A a;
    A b;

    b = a; //运行出错
    return ;
}

　　上述例子中，a和b指向统一指针m_ptr，析构时重复删除该指针。正确的做法应该是提供深拷贝函数。

#include <iostream>

using namespace std;

class A
{
public:
    A() :m_ptr(new int())
    {
        cout << "construct" << endl;
    }

    ~A()
    {
        cout << "destruct" << endl;
        delete m_ptr;
    }

    A(const A & a):m_ptr(new int(*a.m_ptr))
    {
        cout << "copy construct" << endl;
    }

private:
    int *m_ptr;
};

A GetA()
{
    A a;

    return a;
}

int main()
{
    A a = GetA();
    return ;
}

//运行结果：
construct
copy construct
destruct
copy construct
destruct
destruct

　　虽然可以解决问题，但是多次的拷贝确实不必要的，临时变量拷贝完就删除了，如果堆内存黑大，拷贝的代价就会很大。

#include <iostream>

using namespace std;

class A
{
public:
    A() :m_ptr(new int())
    {
        cout << "construct" << endl;
    }

    A(const A & a):m_ptr(new int(*a.m_ptr))
    {
        cout << "copy construct" << endl;
    }

    A(A && a):m_ptr(a.m_ptr)
    {
        a.m_ptr = nullptr;
        cout << "move construct" << endl;
    }

    ~A()
    {
        cout << "destruct" << endl;
        delete m_ptr;
    }

private:
    int *m_ptr;
};

A GetA()
{
    A a;

    return a;
}

int main()
{
    A a = GetA();
    return ;
}

//运行结果：
construct
move construct
destruct
move construct
destruct
destruct

　　很明显，减少了一次拷贝构造，取而代之的是移动构造，在内存方面没有变化，避免了临时对象的深拷贝，提升了性能。这里A &&根据参数是左值还是右值来建立分支，如果是临时值，则会使用移动构造函数。
　　移动语义可以将资源（堆、系统对象）通过浅拷贝方式从一个对象转移到另一个对象，减少不必要的临时对象的创建、拷贝和销毁，大幅提高性能。