右值引用与转移语义

右值引用 (Rvalue Referene) 它实现了转移语义 (Move Sementics) 和精确传递 (Perfect Forwarding)。它的主要目的有两个方面：

1. 消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率
2. 能够更简洁明确地定义泛型函数

右值与右值的定义

　　C++( 包括 C) 中所有的表达式和变量要么是左值，要么是右值。通俗的左值的定义就是非临时对象，那些可以在多条语句中使用的对象。所有的变量都满足这个定义，在多条代码中都可以使用，都是左值。右值是指临时的对象，它们只在当前的语句中有效。区分左右值最便捷的方式是对其&操作，也就是对其取地址。

int a=0;//a是左值，0是右值
((i>0) ? i : j) = 1;//右值也可以出现在复制号的右边,但是不能作为赋值的对象，因为右值只在当前语句有效，赋值没有意义 

　　但是如果临时对象通过一个接受右值的函数传递给另一个函数时，就会变成左值，因为这个临时对象在传递过程中，变成了命名对象。

转移语义（move）

　　右值引用是用来支持转移语义的。转移语义可以将资源 ( 堆，系统对象等 ) 从一个对象转移到另一个对象，这样能够减少不必要的临时对象的创建、拷贝以及销毁，能够大幅度提高 C++ 应用程序的性能。临时对象的维护 ( 创建和销毁 ) 对性能有严重影响

　　通过转移语义，临时对象中的资源能够转移其它的对象里。

　　在现有的 C++ 机制中，我们可以定义拷贝构造函数和赋值函数。要实现转移语义，需要定义转移构造函数，还可以定义转移赋值操作符。对于右值的拷贝和赋值会调用转移构造函数和转移赋值操作符。如果转移构造函数和转移拷贝操作符没有定义，那么就遵循现有的机制，拷贝构造函数和赋值操作符会被调用。

　　普通的函数和操作符也可以利用右值引用操作符实现转移语义。

注意：

1. 参数（右值）的符号必须是右值引用符号，即“&&”
2. 参数（右值）不可以是常量，因为我们需要修改右值
3. 参数（右值）的资源链接和标记必须修改。否则，右值的析构函数就会释放资源。转移到新对象的资源也就无效了

　　既然编译器只对右值引用才能调用转移构造函数和转移赋值函数，而所有命名对象都只能是左值引用，如果已知一个命名对象不再被使用而想对它调用转移构造函数和转移赋值函数，也就是把一个左值引用当做右值引用来使用，怎么做呢？标准库提供了函数 std::move，这个函数以非常简单的方式将左值引用转换为右值引用。

#include <iostream>
#include <cstring>
using namespace std;

void print(const int &i)//接受左值 
{
    cout<<"left value print:"<<i<<endl;
}
void print(const int &&i)//接受有值 
{
    cout<<"right value print:"<<i<<endl;
}
void forward_value(const int &&i)
{
    //临时对象通过一个接受右值的函数传递给另一个函数时就会变成左值，因为传递过程中
    //临时对象变成了命名对象 
    print(i);
}

class my_string
{
    public:
        my_string()
        {
            data=nullptr;
            len=0;
            cout<<" empty construct"<<endl;
        }
        void print()
        {
            cout<<data<<endl;
        }
        //普通的构造函数，拷贝构造函数，赋值构造函数 
        my_string(const char *d)
        {
            len=strlen(d);
            init_data(d);
            cout<<" args construct"<<endl;
        }
        my_string(const my_string &s)
        {
            len=s.len;
            init_data(s.data);
            cout<<" copy construct"<<endl;
        }
        my_string &operator=(const my_string &s)
        {
            if(this!=&s)
            {
                len=s.len;
                init_data(s.data);
            }
            cout<<" operator= construct"<<endl;
            return *this;
        }
        
        //转移构造函数和转移赋值构造函数
        my_string(my_string &&s) 
        {
            len=s.len;
            data=s.data;
            //链接资源的标记必须修改，否则当临时对象析构时转移到新对象的资源无效 
            s.len=0;
            s.data=nullptr;
            cout<<" move construct"<<endl;
        }
        my_string &operator=(my_string &&s)
        {
            if(this!=&s)
            {
                len=s.len;
                data=s.data;
                s.len=0;
                s.data=nullptr;
            }
            cout<<" move operator ="<<endl;
            return *this;
        }
    private:
        char *data;
        int len;
        void init_data(const char *s)
        {
            data=new char[len+1];
            memcpy(data,s,len);
            data[len]='';
        }
};
int main()
{
    int a=0;//a是左值，0是右值
    print(a);
    print(move(a));//把左值当做右值来使用 
    print(1);
    forward_value(2);
     
    //测试普通的拷贝构造函数和赋值构造函数 
    my_string ms("hello word");
    my_string ms1=ms;//copy construct
    my_string ms2;
    ms2=ms1;        //operator = construct 
    
    //my_string("very goog");会生成临时对象也就是右值，但仍会调用operator=，
    //造成对临时对象的申请和释放空间 
    my_string ms3;
    ms3=my_string("very good");
    
    //ms.print();
    return 0;
}

move对swap的帮助

 template <class T> swap(T& a, T& b) 
 { 
       T tmp(std::move(a)); // move a to tmp 
       a = std::move(b);    // move b to a 
       b = std::move(tmp);  // move tmp to b 
 }

　　通过move，一个简单的 swap 函数就避免了 3 次不必要的拷贝操作

精确传递

　　精确传递适用于这样的场景：需要将一组参数原封不动的传递给另一个函数。“原封不动”不仅仅是参数的值不变，在 C++ 中，除了参数值之外，还有一下两组属性：

　　　　左值／右值和 const/non-const。 精确传递就是在参数传递过程中，所有这些属性和参数值都不能改变。在泛型函数中，这样的需求非常普遍。

　　函数 forward_value 是一个泛型函数，它将一个参数传递给另一个函数 process_value

template <typename T> void forward_value(const T& val) 
{ 
 process_value(val); 
} 
template <typename T> void forward_value(T& val) 
{ 
 process_value(val); 
}

　　函数 forward_value 为每一个参数必须重载两种类型，T& 和 const T&，否则，下面四种不同类型参数的调用中就不能同时满足  :

int a = 0; 
 const int &b = 1; 
 forward_value(a); // int& 
 forward_value(b); // const int& 
forward_value(2); // int&

　　对于一个参数就要重载两次，也就是函数重载的次数和参数的个数是一个正比的关系。这个函数的定义次数对于程序员来说，是非常低效的。我们看看右值引用如何帮助我们解决这个问题  :

template <typename T> void forward_value(T&& val) 
{ 
 process_value(val); 
}

　　只需要定义一次，接受一个右值引用的参数，就能够将所有的参数类型原封不动的传递给目标函数。四种不用类型参数的调用都能满足，参数的左右值属性和 const/non-cosnt 属性完全传递给目标函数 process_value。

int a = 0; 
const int &b = 1; 
forward_value(a); // int& 
forward_value(b); // const int& 
forward_value(2); // int&&

　　C++11 中定义的 T&& 的推导规则为：右值实参为右值引用，左值实参仍然为左值引用。一句话，就是参数的属性不变。这样也就完美的实现了参数的完整传递。

 move与forward：https://www.cnblogs.com/catch/p/3507883.html