透彻理解C++11 移动语义:右值、右值引用、std::move、std::forward

0
11

目录

  • 浅拷贝、深拷贝
  • 左值、右值
  • 右值引用类型
  • 强转右值 std::move
  • 重新审视右值、右值引用
    • 右值引用类型和右值的关系
    • 左值、右值、纯右值、将亡值
    • 函数参数传递
    • 函数返还值传递
  • 万能引用
  • 引用折叠
  • 完美转发 std::forward
  • 参考

C++11出现的右值相关语法可谓是很多C++程序员难以理解的新特性,不少人知其然而不知其所以然,面试被问到时大概就只知道可以减少开销,但是为什么减少开销、减少了多少开销、什么时候用…这些问题也不一定知道,于是我写下了这篇夹带自己理解的博文,希望它对你有所帮助。

浅拷贝、深拷贝


在介绍右值引用等概念之前,可以先来认识下浅拷贝(shallow copy)和深拷贝(deep copy)。

这里举个例子:

class Vector{
    int num;
    int* a;
public:
    void ShallowCopy(Vector& v);
    void DeepCopy(Vector& v);
};
  • 浅拷贝:按位拷贝对象,创建的新对象有着原始对象属性值的一份精确拷贝(但不包括指针指向的内存)。
//浅拷贝
void Vector::ShallowCopy(Vector& v){
    this.num = v.num;
    this.a = v.a;
}
  • 深拷贝:拷贝所有的属性(包括属性指向的动态分配的内存)。换句话说,当对象和它所引用的对象一起拷贝时即发生深拷贝。
//深拷贝
void Vector::DeepCopy(Vector& v){
    this.num = v.num;
    this.a = new int[num];
    for(int i=0;i<num;++i){a[i]=v.a[i]}
}

可以看到,深拷贝的开销往往比浅拷贝大(除非没有指向动态分配内存的属性),所以我们就倾向尽可能使用浅拷贝。

但是浅拷贝的有一个问题:当有指向动态分配内存的属性时,会造成多个对象共用这块动态分配内存,从而可能导致冲突。一个可行的办法是:每次做浅拷贝后,必须保证原始对象不再访问这块内存(即转移所有权给新对象),这样就保证这块内存永远只被一个对象使用。

那有什么对象在被拷贝后可以保证不再访问这块内存呢?相信大家心里都有答案:临时对象。

左值、右值


C++在C++98时便遵循C模型,引入了左值、右值的概念。

  • 左值(lvalue) :表达式结束后依然存在的持久对象。
  • 右值(rvalue) :表达式结束后就不再存在的临时对象。

之所以取名左值右值,是因为在等式左边的值往往是持久存在的左值类型,在等式右边的表达式值往往是临时对象。

a = 152;
a = ++b;
a = b+c*2;
a = func();

字面量(字符字面量除外)、临时的表达式值、临时的函数返还值这些短暂存在的值都是右值。更直观的理解是:有变量名的对象都是左值,没有变量名的都是右值。(因为有无变量名意味着这个对象是否在下一行代码时依然存在)

值得注意的是,字符字面量是唯一不可算入右值的字面量,因为它实际存储在静态内存区,是持久存在的。

右值引用类型


有了左值、右值的概念,我们就很清楚认识到右值都是些短暂存在的临时对象。

于是,C++11 为了匹配这些左右值,引入了右值引用类型 && 。
右值引用类型负责匹配右值,左值引用则负责匹配左值。

因此刚刚的浅拷贝、深拷贝例子,我们可以无需显式调用浅拷贝或深拷贝函数,而是调用重载函数:

//左值引用形参=>匹配左值
void Vector::Copy(Vector& v){
    this.num = v.num;
    this.a = new int[num];
    for(int i=0;i<num;++i){a[i]=v.a[i]}
}

//右值引用形参=>匹配右值
void Vector::Copy(Vector&& temp){
    this.num = temp.num;
    this.a = temp.a;
}

当然,最标准还是编写成各种构造函数(拷贝构造、移动构造、赋值构造、移动赋值构造):

移动的意思是转移所有权。由于右值都是临时的值(右值其实也不一定是临时值,后文会说到),临时值释放后也就不再持有属性的所有权,因此这相当于转移资源所有权的行为。

//拷贝构造函数:这意味着深拷贝
Vector::Vector(Vector& v){
    this.num = v.num;
    this.a = new int[num];
    for(int i=0;i<num;++i){a[i]=v.a[i]}
}
//移动构造函数:这意味着浅拷贝
Vector::Vector(Vector&& temp){
    this.num = temp.num;
    this.a = temp.a;
    temp.a = nullptr;    //实际上Vector一般都会在析构函数来释放指向的内存,所以需赋值空地址避免释放
}

虽然从优雅的实现深、浅拷贝这个目的开始出发,C++11的移动语义可以不止用于浅拷贝。得益于转移所有权的特性,我们还可以做其它事情,例如在右值所占有的空间临时存放一些东西。

强转右值 std::move


除了上面说的临时值,有些左值其实也很适合转移所有权:

void func(){
    Vector result;
    //...DoSomehing with result
    if(xxx){ans = result;}  //现在我希望把结果提取到外部的变量a上。
    return;
}

可以看到result赋值给ans后就不再被使用,我们期望它调用的是移动赋值构造函数。
但是result是一个有变量名的左值类型,因此ans = result 调用的是赋值构造函数而非移动赋值构造函数。

为了将某些左值当成右值使用,C++11 提供了 std::move 函数以用于将某些左值转成右值,以匹配右值引用类型。

void func(){
    Vector result;
    //...DoSomehing with result
    if(xxx){ans = std::move(result);}   //调用的是移动赋值构造函数
    return;
}

重新审视右值、右值引用


右值引用类型和右值的关系

有了上面的知识后,我们来重新审视一下右值引用类型。

先看看如下代码:

void test(Vector& o) {std::cout << "为左值。" << std::endl;}
void test(Vector&& temp) {std::cout << "为右值。" << std::endl;}

int main(){
    Vector a;
	Vector&& b = Vector();
    //请分别回答:a、std::move(a)、b 分别是左值还是右值?
	test(a);
	test(std::move(a));
	test(b);
}

答:a是左值,std::move(a)是右值,但b却是左值。

在这里b虽然是 Vector&& 类型,但却因为有变量名(即可持久存在),被编译器认为是左值。

结论:右值引用类型只是用于匹配右值,而并非表示一个右值。因此,尽量不要声明右值引用类型的变量,而只在函数形参使用它以匹配右值。

左值、右值、纯右值、将亡值

前面对移动语义的认识我们都是基于C++98时左值、右值概念,而C++11对左值、右值类别被重新进行了定义,因此现在我们重新认识一下新的类别。

C++11使用下面两种独立的性质来区别类别:

  1. 拥有身份:指代某个非临时对象。
  2. 可被移动:可被右值引用类型匹配。

每个C++表达式只属于三种基本值类别中的一种:左值 (lvalue)、纯右值 (prvalue)、将亡值 (xvalue)

  • 拥有身份且不可被移动的表达式被称作 左值 (lvalue) 表达式,指持久存在的对象或类型为左值引用类型的返还值。
  • 拥有身份且可被移动的表达式被称作 将亡值 (xvalue) 表达式,一般是指类型为右值引用类型的返还值。
  • 不拥有身份且可被移动的表达式被称作 纯右值 (prvalue) 表达式,也就是指纯粹的临时值(即使指代的对象是持久存在的)。
  • 不拥有身份且不可被移动的表达式无法使用。

如此分类是因为移动语义的出现,需要对类别重新规范说明。例如不能简单定义说右值就是临时值(因为也可能是std::move过的对象,该代指对象并不一定是临时值)。

Vector& func1();
Vector&& func2();
Vector func3();

int main(){
    Vector a;

    a;              //左值表达式
    func1();        //左值表达式,返还值是临时的,返还类型是左值引用,因此被认为不可移动。
    func2();        //将亡值表达式,返还值是临时的,返还类型是右值引用,因此指代的对象即使非临时也会被认为可移动。
    func3();        //纯右值表达式,返还值为临时值。
    std::move(a);  //将亡值表达式,std::move本质也是个函数,同上。
    Vector();       //纯右值表达式
}

而现在我们可以归纳为:

  • 左值(lvalue) 指持久存在(有变量名)的对象或返还值类型为左值引用的返还值,是不可移动的。
  • 右值(rvalue) 包含了 将亡值、纯右值,是可移动(可被右值引用类型匹配)的值。

实际上C++ std::move函数的实现原理就是的强转成右值引用类型并返还之,因此该返还值会被判断为将亡值,更宽泛的说是被判定为右值。

函数参数传递

void func1(Vector v) {return;}
void func2(Vector && v) {return;}

int main() {
	Vector a;
	Vector &b = a;
	Vector c;
	Vector d;

    //请回答:不开优化的版本下,调用以下函数分别有多少Copy Consturct、Move Construct的开销?
	func1(a);
	func1(b);
	func1(std::move(c));
	func2(std::move(d));
}

实际上在不开优化的版本下,如果实参为右值,调用func1的开销只比func2多了一次移动构造函数和析构函数。

实参传递给形参,即形参会根据实参来构造。其结果是调用了移动构造函数;函数结束时则释放形参。

倘若说对象的移动构造函数开销较低(例如内部仅一个指针属性),那么使用无引用类型的形参函数是更优雅的选择,而且还能接受左值引用类型或无引用的实参(尽管这两种实参都会导致一次Copy Consturct)。可以说,这种情况下,只提供非引用类型的版本,也是可以接受的。

那我们在写一般函数形参的时候,若参数有支持移动构造(或移动赋值)的类型,是否有必要每个函数都提供关于&&形参的重载版本吗?

回答:从极致的优化角度来看是有必要的,应该提供右值引用类型的重载版本,更准确说应该同时提供左值引用(匹配左值)和右值引用(匹配右值)两种重载版本。

这里纠正了以前的说法。

函数返还值传递

Vector func1() {
    Vector a;
	return a;
}

Vector func2() {
	Vector a;
	return std::move(a);
}

Vector&& func3() {
	Vector a;
	return std::move(a);
}

int main() {
    //请回答:不开优化的版本下,执行以下3行代码分别有多少Copy Consturct、Move Construct的开销?
	Vector test1 = func1();
	Vector test2 = func2();
	Vector test3 = func3();
}

同样的道理,执行这3行代码实际上都没有任何Copy Construct的开销(这其中也有NRV技术的功劳),都是只有一次Move Construct的开销。

此外一提,func3是危险的。因为局部变量释放后,函数返还值仍持有它的右值引用。

因此,这里也不建议函数返还右值引用类型,同前面传递参数类似的,移动构造开销不大的时候,直接返还非引用类型就足够了(在某些特殊场合有特别作用,准确来说一般用于表示返还成一个右值,如std::move的实现)。

结论:

1. 我们应该首先把编写右值引用类型相关的任务重点放在对象的构造、赋值函数上。从源头上出发,在编写其它代码时会自然而然享受到了移动构造、移动赋值的优化效果。

2. 形参:从优化的角度上看,若参数有支持移动构造(或移动赋值)的类型,应提供左值引用和右值引用的重载版本。移动开销很低时,只提供一个非引用类型的版本也是可以接受的。

3. 返还值:不要且没必要编写返还右值引用类型的函数,除非有特殊用途。

万能引用


接下来的内容都是属于模板的部分了:万能引用、引用折叠、完美转发。这部分更加难以理解,不编写模板代码的话可以绕道了。

万能引用(Universal Reference):

  • 发生类型推导(例如模板、auto)的时候,使用T&&类型表示为万能引用,否则表示右值引用。
  • 万能引用类型的形参既能匹配任意引用类型的左值、右值。

也就是说编写模板函数时,只提供万能引用形参一个版本就可以匹配左值、右值,不必编写多个重载版本。

template<class T>
void func(T&& t){
    return;
}

int main() {
    Vector a,b;
	func(a);                //OK
	func(std::move(b));     //OK
}

此外需要注意的是,使用万能引用参数的函数是最贪婪的函数,容易让需要隐式转换的实参匹配到不希望的转发引用函数。例如下面代码:

template<class T>
  void f(T&& value);

void f(int a);
//当调用f(long类型的参数)或者f(short类型的参数),则不会匹配int版本而是匹配到万能引用的版本

引用折叠


使用万能引用遇到的第一个问题是推导类型会出现不正确的引用类型:例如当模板参数T为Vector&或Vector&&,模板函数形参为T&&时,展开后变成Vector& &&或者Vector&& &&。

template<class T>
void func(T&& t){
    return;
}

int main(){
    func(Vector()); //模板参数T被推导为Vector&&
}

但显然C++中是不允许对引用再进行引用的,于是为了让模板参数正确传递引用性质,C++定义了一套用于推导类型的引用折叠(Reference Collapse)规则:
所有的折叠引用最终都代表一个引用,要么是左值引用,要么是右值引用。

引用折叠 & &&

&
&
&

&&
&
&&

Example1:

func(Vector());

模板函数func的T被推导为Vector&&,形参object为T&&即展开后为Vector&& &&。由于折叠规则的存在,形参object最终被折叠推导为Vector&&类型。

Example2:

func(a);

模板函数func的T在这里被推导为Vector&,形参object为T&&即展开后为Vector& &&。由于折叠规则的存在,形参object最终被推导为Vector&类型。

完美转发 std::forward<T>


当我们使用了万能引用时,即使可以同时匹配左值、右值,但需要转发参数给其他函数时,会丢失引用性质(形参是个左值,从而无法判断到底匹配的是个左值还是右值)。

//当然我们也可以写成如下重载代码,但是这已经违背了使用万能引用的初衷(仅编写一个模板函数就可以匹配左值、右值)
template<class T>
void func(T& t){
    doSomething(t);
}

template<class T>
void func(T&& t){
    doSomething(std::move(t));
}

完美转发(Perfect Forwarding):C++11提供了完美转发函数 std:forward<T> 。它可以在模板函数内给另一个函数传递参数时,将参数类型保持原本状态传入(如果形参推导出是右值引用则作为右值传入,如果是左值引用则作为左值传入)。

于是现在我们可以这样做了:

template<class T>
void func(T&& object){
    doSomething(std::forward<T>(object));
}

不借助std::forward<T>间接传入参数的话,无论object是左值引用类型,还是右值引用类型,都会被视为左值。

std::forward<T>()的实现主要就一句return static_cast<T&&>(形参),实际上也是利用了折叠规则。从而接受右值引用类型时,将右值引用类型的值返还(返还值为右值)。接受左值引用类型时,将左值引用类型的值返还(返还值为左值)。

而std::move<T>()的实现还需要先移除形参的所有引用性质得到无引用性质的类型(假设为T2),然后再return static_cast<T2&&>(形参),从而保证不会发生引用折叠,而是直接作为右值引用类型的值返还(返还值为右值)。

参考


[1] value_category | cppreference.com

[2] move_constructor | cppreference.com

<

发布回复

请输入评论!
请输入你的名字