左值,右值
在C++11中所有的值必属于左值、右值两者之一,右值又可以细分为纯右值、将亡值。
在C++11中可以取地址的、有名字的就是左值,反之,不能取地址的、没有名字的就是右值(将亡值或纯右值)。
举个例子,int a = b+c, a就是左值,其有变量名为a,通过&a可以获取该变量的地址;表达式b+c、函数int func()的返回值是右值,在其被赋值给某一变量前,我们不能通过变量名找到它,&(b+c)这样的操作则不会通过编译。
右值、将亡值
在理解C++11的右值前,先看看C++98中右值的概念:C++98中右值是纯右值,纯右值指的是临时变量值、不跟对象关联的字面量值。临时变量指的是非引用返回的函数返回值、表达式等,例如函数int func()的返回值,表达式a+b;不跟对象关联的字面量值,例如true,2,”C”等。
C++11对C++98中的右值进行了扩充。在C++11中右值又分为纯右值(prvalue,Pure Rvalue)和将亡值(xvalue,eXpiring Value)。其中纯右值的概念等同于我们在C++98标准中右值的概念,指的是临时变量和不跟对象关联的字面量值;将亡值则是C++11新增的跟右值引用相关的表达式,这样表达式通常是将要被移动的对象(移为他用),比如返回右值引用T&&的函数返回值、std::move的返回值,或者转换为T&&的类型转换函数的返回值。
将亡值可以理解为通过“盗取”其他变量内存空间的方式获取到的值。在确保其他变量不再被使用、或即将被销毁时,通过“盗取”的方式可以避免内存空间的释放和分配,能够延长变量值的生命期。(通过右值引用来续命)
左值引用、右值引用
左值引用就是对一个左值进行引用的类型。右值引用就是对一个右值进行引用的类型,事实上,由于右值通常不具有名字,我们也只能通过引用的方式找到它的存在。
右值引用和左值引用都是属于引用类型。无论是声明一个左值引用还是右值引用,都必须立即进行初始化。而其原因可以理解为是引用类型本身自己并不拥有所绑定对象的内存,只是该对象的一个别名。左值引用是具名变量值的别名,而右值引用则是不具名(匿名)变量的别名。
左值引用通常也不能绑定到右值,但常量左值引用是个“万能”的引用类型。它可以接受非常量左值、常量左值、右值对其进行初始化。不过常量左值所引用的右值在它的“余生”中只能是只读的。相对地,非常量左值只能接受非常量左值对其进行初始化。
int &a = 2; # 左值引用绑定到右值,编译失败
int b = 2; # 非常量左值
const int &c = b; # 常量左值引用绑定到非常量左值,编译通过
const int d = 2; # 常量左值
const int &e = c; # 常量左值引用绑定到常量左值,编译通过
const int &b =2; # 常量左值引用绑定到右值,编译通过
右值值引用通常不能绑定到任何的左值,要想绑定一个左值到右值引用,通常需要std::move()将左值强制转换为右值,例如:
int a;
int &&r1 = a; # 编译失败
int &&r2 = std::move(a); # 编译通过
int &&r2 = 2; # 编译通过
下表列出了在C++11中各种引用类型可以引用的值的类型。值得注意的是,只要能够绑定右值的引用类型,都能够延长右值的生命期。
左值引用和右值引用实例如下:
#include <iostream>
void process_value(int& i)
{
std::cout << "LValue processed: " << i << std::endl;
}
void process_value(int&& i) //右值引用
{
std::cout << "RValue processed: " << i << std::endl;
}
int main()
{
int a = 0;
process_value(a);
process_value(1);
}
对于上述右值引用的例子:
int &&r2 = 2; # 编译通过
r2是一个右值引用,但是r2本身是不是左值呢?C++11对此做出了区分:
如果它有一个名字,那么它是一个左值。 否则,它是一个右值。
通过下面这个程序:
#include <iostream>
void process_value(int& i)
{
std::cout << "LValue processed: " << i << std::endl;
}
void process_value(int&& i)
{
std::cout << "RValue processed: " << std::endl;
}
int main()
{
int a = 0;
process_value(a);
int&& x = 3;
process_value(x);
}
返回值是:
LValue processed: 0
LValue processed: 3
x 是一个右值引用,指向一个右值3,但是由于x是有名字的,所以x在这里被视为一个左值,所以在函数重载的时候选择为第一个函数。
右值引用的意义
直观意义:为临时变量续命,也就是为右值续命,因为右值在表达式结束后就消亡了,如果想继续使用右值,那就会动用昂贵的拷贝构造函数。
右值引用是用来支持转移语义的。转移语义可以将资源 ( 堆,系统对象等 ) 从一个对象转移到另一个对象,这样能够减少不必要的临时对象的创建、拷贝以及销毁,能够大幅度提高C++应用程序的性能。临时对象的维护 ( 创建和销毁 ) 对性能有严重影响。
转移语义是和拷贝语义相对的,可以类比文件的剪切与拷贝,当我们将文件从一个目录拷贝到另一个目录时,速度比剪切慢很多。 通过转移语义,临时对象中的资源能够转移其它的对象里。
在现有的 C++ 机制中,我们可以定义拷贝构造函数和赋值函数。要实现转移语义,需要定义转移构造函数,还可以定义转移赋值操作符。对于右值的拷贝和赋值会调用转移构造函数和转移赋值操作符。如果转移构造函数和转移拷贝操作符没有定义,那么就遵循现有的机制,拷贝构造函数和赋值操作符会被调用。
普通的函数和操作符也可以利用右值引用操作符实现转移语义。
转移语义以及转移构造函数和转移复制运算符
以一个简单的 string 类为示例,实现拷贝构造函数和拷贝赋值操作符。
class MyString {
private:
char* _data;
size_t _len;
void _init_data(const char *s) {
_data = new char[_len+1];
memcpy(_data, s, _len);
_data[_len] = '\0';
}
public:
MyString() { //构造函数
_data = NULL;
_len = 0;
}
MyString(const char* p) { //构造函数
_len = strlen (p);
_init_data(p);
}
MyString(const MyString& str) { //拷贝构造函数
_len = str._len;
_init_data(str._data);
std::cout << "Copy Constructor is called! source: " << str._data << std::endl;
}
MyString& operator=(const MyString& str) { //赋值符
if (this != &str) {
_len = str._len;
_init_data(str._data);
}
std::cout << "Copy Assignment is called! source: " << str._data << std::endl;
return *this;
}
virtual ~MyString() {
if (_data) free(_data);
}
};
int main() {
MyString a;
a = MyString("Hello");
std::vector<MyString> vec;
vec.push_back(MyString("World"));
}
这个 string 类已经基本满足我们演示的需要。在 main 函数中,实现了调用拷贝构造函数的操作和拷贝赋值操作符的操作。MyString(“Hello”) 和 MyString(“World”) 都是临时对象,也就是右值。虽然它们是临时的,但程序仍然调用了拷贝构造和拷贝赋值,造成了没有意义的资源申请和释放的操作。如果能够直接使用临时对象已经申请的资源,既能节省资源,有能节省资源申请和释放的时间。这正是定义转移语义的目的。
先定义转移构造函数。
MyString(MyString&& str) {
std::cout << "Move Constructor is called! source: " << str._data << std::endl;
_len = str._len;
_data = str._data;
str._len = 0;
str._data = NULL;
}
有下面几点需要对照代码注意:
- 参数(右值)的符号必须是右值引用符号,即“&&”。
- 参数(右值)不可以是常量,因为我们需要修改右值。
- 参数(右值)的资源链接和标记必须修改。否则,右值的析构函数就会释放资源。转移到新对象的资源也就无效了。
定义转移赋值操作符。
MyString& operator=(MyString&& str) {
std::cout << "Move Assignment is called! source: " << str._data << std::endl;
if (this != &str) {
_len = str._len;
_data = str._data;
str._len = 0;
str._data = NULL;
}
return *this;
}
由此看出,编译器区分了左值和右值,对右值调用了转移构造函数和转移赋值操作符。节省了资源,提高了程序运行的效率。
有了右值引用和转移语义,我们在设计和实现类时,对于需要动态申请大量资源的类,应该设计转移构造函数和转移赋值。
move()和forward()
注意:
- std::move执行一个无条件的转化到右值。它本身并不移动任何东西;
- std::forward把其参数转换为右值,仅仅在那个参数被绑定到一个右值时;
- std::move和std::forward在运行时(runtime)都不做任何事。
std::move和std::forward仅仅是进行类型转换的函数(实际上是函数模板),std::move无条件的将其参数转换为右值,而std::forward只在必要情况下进行这个转换。
move()的用法
move()函数原型:
根据模板推导原则和折叠原则,我们很容易验证,无论是给 move 传递了一个 lvalue 还是 rvalue,最终返回的,都是一个rvalue reference。而这正是 move 的意义,得到一个 rvalue 的引用。看到这里有人也许会发现,其实就是一个 cast 嘛,确实是这样,直接用 static_cast 也是能达到同样的效果,只是 move 更具语义罢了。
template<class T>
typename remove_reference<T>::type&&
std::move(T&& a)
{
typedef typename remove_reference<T>::type&& RvalRef;
return static_cast<RvalRef>(a);
}
举个例子:
原始的swap()
函数
void swap(T& a, T& b)
{
T tmp = a;
a = b;
b = tmp;
}
如果T是用户自定义类的话,将会需要调用额外的构造函数和析构函数,是非常耗费时间的,但是如果调用了move()
函数,类中如果也实现了T &operator=(T&& )
,就可以直接将右值的值进行转移,这样就减少了构造和析构的时间,swap中就相当于仅仅交换指针,提高了效率。
void swap(T& a, T& b)
{
T tmp = move(a);
a = move(b);
b = move(tmp);
}
forward()的用法
除了move()语义之外,右值引用的提出还解决另一个问题:完美转发 (perfect forwarding),转发问题针对的是模板函数,这些函数主要处理的是这样一个问题:假设我们有这样一个模板函数,它的作用是:缓存一些 object,必要的时候创建新的。
template<class TYPE, class ARG>
TYPE* acquire_obj(ARG arg)
{
static list<TYPE*> caches;
TYPE* ret;
if (!caches.empty())
{
ret = caches.pop_back();
ret->reset(arg);
return ret;
}
ret = new TYPE(arg);
return ret;
}
这个模板函数的作用简单来说,就是转发一下参数ARG给TYPE的reset()函数和构造函数,除此它就没再干别的事情,在这个函数当中,我们用了值传递的方式来传递参数,显然是比较低效的,多了次没必要的拷贝,于是我们准备改成传递引用的方式,同时考虑到要能接受 rvalue 作为参数,最后做出艰难的决定改成如下样子:
template<class TYPE, class ARG>
TYPE* acquire_obj(const ARG& arg)
{
//...
}
但这样写很不灵活:
1) 首先,如果 reset() 或 TYPE 的构造函数不接受 const 类型的引用,那上述的函数就不能使用了,必须另外提供非 const TYPE& 的版本,参数一多的话,很麻烦。
2) 其次,如果 reset() 或 TYPE 的构造函数能够接受 rvalue 作为参数的话,这个特性在 acquire_obj() 里头也永远用不上。
其中1) 好理解,2) 是什么意思?
2) 说的是这样的问题,即使 TYPE 存在 TYPE(TYPE&& other) 这样的构造函数,它在上述 acquire_obj() 中也永远不会被调用,原因是在 acquire_obj() 中,传递给 TYPE 构造函数的,永远是 lvalue(因为 arg 有名字),哪怕外面调用 acquire_obj() 时,用户传递进来的是 rvalue,请看如下示例:
holder get_holder();
holder* h = acquire_obj<holder, holder>(get_holder());
虽然在上面的代码中,我们传递给 acquire_obj() 的是一个 rvalue,但是在 acuire_obj() 内部,我们再使用这个参数时,它却永远是 lvalue,因为它有名字 — 有名字的就是 lvalue。
acquire_obj() 这个函数它的基本功能本来只是传发一下参数,理想状况下它不应该改变我们传递的参数的类型:假如我们传给它 lvalue,它就应该传 lvalue 给 TYPE,假如我们传 rvalue 给它,它就应该传 rvalue 给 TYPE,但上面的写法却没有做到这点,而在 c++11 以前也没法做到。
forward() 函数的出现,就是为了解决这个问题。
forward() 函数的作用:它接受一个参数,然后返回该参数本来所对应的类型的引用。
两个原则
T&&为右值引用只有当 T 为一个具体的类型时才成立,而如果 T 是推导类型时(如模板参数, auto 等)这就不一定了,比如说如下代码中的 ref_int,根据定义这个变量的类型必定是一个右值引用,但模板函数 func 的参数 arg 则不定是右值引用了,因为此时 T 是一个推导类型。
int&& ref_int = get_int();
template <typename T>
void func(T&& arg){ }
具体来说,对于推导类型 T, 如果 T&& v 被一个左值初始化,那 v 就是左值引用,如果 v 被右值初始化,那它就是右值引用,很神奇!实现这是怎么做到的呢?主要来说,在参数类型推导上,c++11 加入了如下两个原则:
原则 (1):
引用折叠原则 (reference collapsing rule),注意,以下条目中的 T 为具体类型,不是推导类型。
1) T& & (引用的引用) 被转化成 T&.
2)T&& & (rvalue的引用)被传化成 T&.
3) T& && (引用作rvalue) 被转化成 T&.
4) T&& && 被转化成 T&&.
原则 (2):
对于以 rvalue reference 作为参数的模板函数,它的参数推导也有一个特殊的原则,假设函数原型为:
template<class TYPE, class ARG>
TYPE* acquire_obj(ARG&& arg);
如果我们传递 lvalue 给 acquire_obj(),则 ARG 就会被推导为 ARG&,因此如下代码的第二行,acquire_obj 被推导为: TYPE* acquire\_obj(ARG& &&);
ARG arg;
acquire_obj(arg);
然后根据前面说的折叠原则,我们得到原型如下的函数: TYPE* acquire_obj(ARG&);
如果我们如下这样传递 rvalue 给 acquire_obj(),则 ARG 就会被推导为 ARG&&。
acquire_obj(get_arg());
最后,模板函数实例化为原型如下的函数:TYPE* acquire_obj(ARG&&);
有了以上两个原则,现在我们可以给出理想的 acquire_obj() 原型,以及 forward() 原型。
template<class TYPE>
TYPE&& forward(typename remove_reference<TYPE>::type& arg)
{
return static_cast<TYPE&&>(arg);
}
template<class TYPE, class ARG>
TYPE* acquire_obj(ARG&& arg)
{
return new TYPE(forward<ARG>(arg));
}
注意上面 forward 的原型,这里只给出了参数是左值引用的原型,其实还有一个接受右值引用的重载(用来处理传入的参数是右值的情况)。另外需要额外注意的是,forward 的模板参数类型 TYPE 与该函数的参数类型并不直接等价,因此无法根据传入的参数推导模板参数,使得调用方必需显式地指定模板参数的类型,如: forward(xx),否则会有编译错误。
内容转自:C++11 左值、右值、右值引用详解