C++11: rvalue 右值
rvalue & lvalue（右值与左值）
左值与右值的定义是比较复杂，下边仅给出一个相对简单的定义，也是大家相对容易接受的一个定义。
左值：能在内存中取到地址的对象。
右值：不是左值的对象。
左值举例说明一下：
int i; // i 是一个左值
int* p = &i; //获取i的地址，且它的地址是唯一的
i = 2; //因为可以获取到它的地址，所以可以进行赋值操作
class Dog; //这是一个类类型
dog d1; //声明了一个左值
在C++程序中，大部分的对象都是左值。
下面是右值的一些例子：
int x = 2; // 2 是右值
int x = i+2; //(i+2) 的结果是一个临时变量，也是一个右值
int* l = &(i+2); //错误 🙅
i+2 = 4; //错误 🙅
2 = i; //错误 🙅
dog d1;
d1 = Dog(); //Dog()会产生一个临时变量，所以它也是一个右值
int sum (int x, int y)
{
return x+y;
}
int i = sum(3, 4); //sum(3,4) 是一个右值
接下来我们来看一下左值引用和右值引用
先来看一下左值引用：
int i;
int& r = i; // r 是对左值 i 的引用，这是对左值的引用
int& r = 5; //错误 🙅，无法对一个右值进行左值引用操作，但是有一种意外情况
const int& r = 5; //常量左值引用可以引用右值
int square(int& x)
{
return x * x;
}
square(i); //正确 🙆
square(40); //错误 🙅
//如果希望square(40)正确调用的话，可以使用上文的例外
int square(const int& x)
{
return x * x;
}
square(40) //正确 🙆
接下来是右值引用，这里只是一个简单的语法上的例子，下面有更详细的例子
int a = 2;
int&& b = a + 2; //b 扩展了临时变量 a + 2 的生命周期
int&& c = 5;
左值可以用来构建右值
int i = 1;
int x = i + 2; //i 是左值， i+2是右值
右值可以用来构建左值
int v[3]; //3 是右值，v是左值
*(ptr+2) = 4; //4与2 是右值，ptr是左值
三个常见的误解：
- 误解一：函数和操作符的返回值为右值。
之所以这么认为是因为，函数和操作符经常会返回一些临时变量，而临时变量是右值
int x = i + 3; //i+3 返回了一个右值，然后这个右值被赋值给了一个左值
int y = sum(3,4); //sum(3,4) 也返回了一个右值
int myglobal;
int& foo()
{
return myglobal; //该函数返回了一个左值引用
}
foo() = 50;
array[3] = 50; //[]操作符可以用来给元素赋值，其返回值也是左值引用
- 误解二：左值是可以被修改的。
一个反例就是在左值前面加上const修饰
const int c = 1;
c = 2;
- 误解三：右值是不能被修改的。
i+3 = 6; //右值无法被修改
sum(3,4) = 7; //右值无法被修改
class Dog
{
public:
Dog(){ state = 0;}
void sleep(){state = 2;}
private:
int state;
};
int main()
{
Dog().sleep(); //Dog() 是一个右值，但是sleep会改变它的成员变量的值
return 0;
}
每一个C++表达式，或者是一个左值，或者是一个右值。如果一个对象有明确的可分辨的地址的话，那它就是一个左值，反之是一个右值。
移动语义
首先我们来看一下四个相互重载的函数，也就是，函数为左值引用或者右值引用是可以重载的。
// 1
void printInt(int& i) {std::cout<<"lvalue reference : "<<i<<endl;}
// 2
void printInt(int&& i) {std::cout<<"rvalue reference : "<<i<<endl;}
// 3
void printInt(const int& i) {std::cout<<"lvalue reference : "<<i<<endl;}
// 4
void printInt(int i) {std::cout<<"lvalue reference : "<<i<<endl;}
int main()
{
int a = 5;
printInt(a); //调用 1
printInt(6); //发生冲突，理论上2、3、4都可以
return 0;
}
class boVector
{
private:
int size;
double* arr_; //会是一个特别大的数组
public:
boVector(const boVector& rhs) //深拷贝
{
size = rhs.size;
arr_ = new double[size];
for(int i = 0; i<size; i++){ arr_[i] = rhs.arr_[i];}
}
boVector(const boVector&& rhs) //浅拷贝
{
size = rhs.size;
arr_ =rhs.arr_];
rhs.arr_=nullptr;
}
~boVector(){delete arr_;}
};
void foo(boVector v);
boVector createBoVector();
int main()
{
boVector reuseable = createBoVector();
//这里会调用拷贝构造函数，会构造这个比较大的数组数据成员，
//这将会是一个比较话费时间的操作
foo(resuable);
//createBoVector() 会返回一个临时变量作为参数传递给foo，
//这里会调用移动拷贝构造函数，不会重新创建比较大的数组
foo(createBoVector());
//如果resuable不再使用，我们也可以这么调用
foo(std::move(reusable));
//此时 reusable.arr_ = nullptr
return 0;
}
Note:
(1) 右值引用最有用的地方是给类添加移动拷贝构造函数和移动赋值操作符函数。
(2) C++11的STL容易都已经实现了移动语义，理论上，只要你在编译代码的时候添加-std=c++11选项，就能获得性能上的提升。
完美转发 prefect forwarding
template<typename T>
void relay(T arg)
{
foo(T);
}
int main()
{
boVector reusable = createBoVector();
relay(reusable);
relay(createBoVector());
}
这就做参数转发
理想的情况下，relay的参数怎么转发给foo函数呢，应该要满足两个条件：
- 没有花费较大或者不必要的拷贝构造函数的调用
- 左值需要被转发为左值，右值需要被转发为右值
满足上述两点称之为完美转发
标准库已经帮我们提供了一个函数std::forward来进行完美转发，该函数位于<utility>中。利用该函数将relay改为
template<typename T>
void relay(T&& arg)
{
foo(std::forward<T>(arg));
}
下面，我们在补充一下完美转发的一些细节。
首先来讲一个概念，引用坍缩（reference collapse），我觉得中文的翻译怪怪的，还是英文比较好理解，其实就是有多个&的时候我们怎么处理。
typedef int& lref;
typedef int&& rref;
int n;
lref& r1 = n; // r1 的类型是 int&
lref&& r2 = n; // r2 的类型是 int&
rref& r3 = n; // r3 的类型是 int&
rref&& r4 = 1; // r4 的类型是 int&&
根据引用坍缩，我们可以得到
//T&& 被一个右值初始化
relay(9); => T = int&& => T&& int&& && = int&&
//T&& 被一个左值初始化
relay(x); => int& => T&& = int& && = int&
这里的T&&不再是右值引用，而是universal reference
T&&是Universial Reference的条件:
- T 是一个模板类型。
- 类型推倒是施加于T的，T是一个函数模板参数，而不是类模板参数。
然后标注库还提供了一个类型工具remove_reference
template<class T>
struct remove_reference;
remove_reference<int&>::type i; // int i
remove_reference<int>::type i; // int i
template < typename T >
void relay(T&& arg)
{
foo(std::forward<T>(arg));
}
template < class T >
T&& forward(typename remove_reference<T>::type& arg)
{
return static_cast<T&&>(arg);
}
