左值和右值

 

这个问题牵涉到得首先是左值(L-value)和右值(R-value)的概念;

  1. 我查资料的时候发现很多地方都引用一句话:"通俗的讲，左值就是能够出现在赋值符号左面的东西，而右值就是那些可以出现在赋值符号右面的东西了。"我觉得这句话在刚开始理解的时候是什么用都没有的一句废话.因为我们都不知道哪些东西应该放在赋值符号的左边,哪些东西又应该放在赋值符号的右边这样说是没有意义的.

2.接着我找到个比较靠谱的定义:左值是指具有对应的可由用户访问的存储单元，并且能由用户改变其值的量。如一个变量就是一个左值，因为它对应着一个存储单元，并可由编程者通过变量名访问和改变其值。

               (下面的第三点是c++primer中的)

 3.变量和文字常量都有存储区，并且有相关的类型。区别在于变量是可寻址的（addressable）对于每一个变量都有两个值与其相联：

       1).它的数据值，存储在某个内存地址中。有时这个值也被称为对象的右值（rvalue,读做are-value）.我们也可认为右值的意思是被读取的值（read   value）。   文字常量和变量都可  被用作右值。   

       2).它的地址值——即存储数据值的那块内存的地址。它有时被称为变量的左值（lvalue，读作ell-value）。我们也可认为左值的意思是位置值location   value文字常量不能被用作左值

 

有些变量既可以当左值右可以当右值。

• 左值(Lvalue) →→ Location

  表示内存中可以寻址，可以给它赋值(const类型的变量例外)

• 右值Rvalue) →→ Read

  表示可以知道它的值（例如常数）

一个典型的例子

a++ ： 先使用a的值，再给a加1，作为 右值

// a++的实现
int temp = a;
a = a + 1;
return temp;

• ++a ： 先加再用，作为 左值

a = a + 1;
return a;

左值符号 &

右值符号 &&

在C++中，临时对象不能作为左值，但是可以作为常量引用，const &。

C++ 11中的std::move可将左值引用转化成右值引用。

 

左值和右值

 

左值：指表达式结束后依然存在的持久对象，可以取地址，具名变量或对象 
右值：表达式结束后就不再存在的临时对象，不可以取地址，没有名字。 
比如 int a = b + c;，a 就是一个左值，可以对a取地址，而b+c 就是一个右值，对表达式b+c 取地址会报错。C++11中右值又由两个概念组成：将亡值和纯右值。

纯右值和将亡值

在C++98中，右值是纯右值，纯右值指的是临时变量值、不跟对象关联的字面量值。包括非引用的函数返回值、表达式等，比如 2、‘ch’、int func()等。将亡值是C++11新增的、与右值引用相关的表达式。

• 纯右值：非引用返回的临时变量( int func(void) )、运算表达式产生的临时变量(b+c)、原始字面量(2)、lambda表达式等。
• 将亡值：将要被移动的对象、T&&函数返回值、std::move返回值和转换为T&&的类型的转换函数的返回值。

将亡值可以理解为通过“盗取”其他变量内存空间的方式获取到的值。在确保其他变量不再被使用、或即将被销毁时，通过“盗取”的方式可以避免内存空间的释放和分配，能够延长变量值的生命期。

右值引用和左值引用

介绍

右值引用就是对一个右值进行引用的类型，标记为 T&&。因为右值不具名，是以引用的形式找到它，用引用来表示，右值引用也是引用的引用（我目前是这么想的）。

左值引用就是对一个左值进行引用的类型。

引用本身不拥有所绑定对象的内存，只是该对象的一个别名，左值引用就是有名变量的别名，右值引用是不具名变量的别名。因此无论左值引用还是右值引用都必须立即进行初始化。

通过右值引用，这个将亡的右值又“重获新生”，它的生命周期与右值引用类型变量的生命周期一样，只要这个右值引用类型的变量还活着，那么这个右值临时量就会一直活着，这是一重要特性，可利用这一点会一些性能优化，避免临时对象的拷贝构造和析构。

左值引用包括常量左值引用和非常量左值引用。非常量左值引用只能接受左值，不能接受右值；常量左值引用是一个“万能”的引用类型，可以接受左值（常量左值、非常量左值）、右值。不过常量左值所引用的右值在它的“余生”中只能是只读的。

int &a = 2;       // 非常量左值引用 绑定到 右值，编译失败

int b = 2;        // b 是非常量左值
const int &c = b; // 常量左值引用 绑定到 非常量左值，编译通过

const int d = 2;  // d 是常量左值
const int &e = d; // 常量左值引用 绑定到 常量左值，编译通过
const int &f =2;  // 常量左值引用 绑定到 右值，编译通过

右值引用通常不能绑定到任何的左值，要想绑定一个左值到右值引用，通常需要std::move()将左值强制转换为右值。比如：

int a;
int &&r1 = a;             // 编译失败
int &&r2 = std::move(a);  // 编译通过

•  

右值引用特点

右值引用独立于左值和右值。意思是右值引用类型的变量可能是左值也可能是右值。比如：

int&& val1 = x;

var1类型为右值引用，但var1本身是左值，因为具名变量都是左值。

T&& 并不一定表示右值，它绑定的类型是未定的，既可能是左值又可能是右值。

template<typename T>
void f(T&& param){}

f(10); //param是右值

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

T&& param，表示param实际上是一个未定的引用类型，称为universal references，可以认为它是一种未定的引用类型，它必须被初始化，它是左值还是右值引用取决于它的初始化，如果&&被一个左值初始化，它就是一个左值；如果它被一个右值初始化，它就是一个右值。 
上面例子，当参数为右值10的时候，根据universal references的特点，param 被一个右值初始化，那么 param 就是右值；当参数为左值 x 时，param 被一个左值引用初始化，那么 param 就是一个左值。

只有发生自动类型推断时（如函数模板的类型自动推导，或auto关键字），T&& 才是一个universal references。比如

template<typename T>
void func(T&& param)   //T需要推导，&&是一个universal references

template<typename T>
class Test {
    Test(Test&& rhs); 
};

上面的例子中，param是universal references，rhs 是 Test&& 右值引用，因为模版函数 func 发生了类型推断，而 Test&& 并没有发生类型推导，因为 Test&& 是确定的类型了.

再看一个例子：

template<typename T>
void func(const T&& param);

上面的例子中param不是 universal references，它其实是一个右值引用。universal references 仅仅在 T&& 下发生，任何一点附加条件都会使之失效，所以上面被 const 修饰之后就成了右值引用了。

引用折叠规则

经过类型推导的 T&& 类型，相比右值引用(&&)会发生类型变化，这种变化被称为引用折叠或崩塌。规则：

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

总之是，所有的右值引用叠加到右值引用上仍然是一个右值引用，其他引用折叠都是左值引用。

T& &、T& &&和T&& & 都折叠成类型 T& 
T&& &&折叠成 T&&

右值函数模版参数类型推导

template<typename T>
void foo(T&&);

1. 当传给foo函数的参数是一个左值时，例如：

int i = 29;
foo(i);//i为左值引用

此时，T的类型为int的左值引用：int&，参数类型为int& &&，（即T&&），结合上面的引用折叠规则，最终参数的类型为int的左值引用：int&。 

2. 当传给foo函数的参数是一个右值时，例如：

foo(29);

此时，T的类型为int，参数类型为int&&，（即T&&）。

还在理解ing，感觉好复杂，也不会用呢，先到这。

还有一点，忘了加上。 
编译器会把已命名的右值引用视为左值，而将未命名的右值引用视为右值。

#include <iostream>
#include <string>
#include <stack>
#include <vector>
#include <algorithm>
#include <cstdio>

using namespace std;

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 = 0;
    PrintValue(i);
    PrintValue(1);
    Forward(2);

    return 0;
}

输出结果：

Forwaid函数收到一个右值，在转发给PrintfValue时又变成了左值，在Forward中调用PrintfValue时，右值i变成了一个命名的对象，编译器会把它当作左值处理。

 

 

 

左值引用, 即&i, 是一种对象类型的引用; 右值引用, 即&&i, 是一种对象值的引用;

std::move()可以把左值引用, 转换为右值引用;

左值引用是固定的引用, 右值引用是易变的引用, 只能引用字面值(literals)或临时对象(temporary object);

右值引用主要应用在移动构造器(move constructor)和移动-赋值操作符(move-assignment operator)上面;

代码如下

/* 
 * cppprimer.cpp 
 * 
 *  Created on: 2013.11.7 
 *      Author: Caroline 
 */  
  
#include <iostream>  
#include <utility>  
  
int main (void) {  
    int i = 42;  
    int &lr = i;  
    int &&rr = i*42;  
    const int &lr1 = i*42;  
    int &&rr1 = 42;  
    int &&rr2 = std::move(lr);  
    std::cout << "i = " << i << std::endl;  
    std::cout << "lr = " << lr << std::endl;  
    std::cout << "rr = " << rr << std::endl;  
    std::cout << "lr1 = " << lr1  <<std::endl;  
    std::cout << "rr1  = " << rr1  << std::endl;  
    std::cout << "rr2  = " << rr2  << std::endl;  
}  

 

1.