谈谈 C++ 中的右值引用

最近在改 XGBoost 的代码。XGBoost 在代码中使用了很多来自 C++11 标准中的特性,让我比较好奇和困惑的,就有其中关于右值引用的部分。涉及到代码里,有比较明显的两类用法:

std::move
1
std::move(foo)
std::unique_ptr
1
std::vector<std::unique_ptr<T>>

前者是使用 std::move 返回 foo 的右值引用;后者则在容器 std::vector 中放入了不可复制只能移动的类的实例(智能指针 std::unique_ptr),当你尝试用常规方法将整个 std::vector 中的元素依次加入另一个 std::vector 的时候,编译器就会报错,提示 std::unique_ptr 的拷贝构造函数是被删除的。

因为好奇和困惑,所以想要把它们搞清楚,于是有了这篇文章。

左值和右值

左值和右值,最早是从 C 语言继承而来的。在 C 语言,或者继承版本,的解释中,

  • 左值是可以位于赋值运算符 = 左侧的表达式(当然,左值也可以位于 = 的右侧),而
  • 右值是不可以位于赋值运算符 = 左侧的表达式。

对于这个经典的解释,我们有如下示例

lvalue-and-rvalue
1
2
3
4
5
6
7
8
9
10
11
12
int foo(42);
int bar(43);

// foo, bar 都是左值
foo = bar;
bar = foo;
foo = foo * bar;

// foo * bar 是右值
int baz;
baz = foo * bar; // OK: 右值在赋值运算符右侧
foo * bar = 42; // Err: 右值在赋值运算符左侧

这个解释很经典,也容易懂。不过在 C++ 里面,左值和右值不能这样定义。根据《C++ Primer》的说法,左值和右值可以这样区分:

一个表达式是左值还是右值,取决于我们使用的是它的值还是它在内存中的位置(作为实例的身份)。也就是说一个表达式具体是左值还是右值,要根据实际在语句中的含义来确定。例如

1
2
3
4
5
6
7
int foo(42);
int bar;

// 将 foo 的值赋给 bar,保存在 bar 对应的内存中
// foo 在这里作为表达式是右值;bar 在这里作为表达式是左值
// 但是 foo 作为实例,既可以充当左值又可以充当右值
bar = foo;

因为 C++ 中的实例本身可以是一个表达式,所以这里有一个重要的原则,即

  • 在大多数情况下,需要右值的地方可以用左值来替代,但
  • 需要左值的地方,一定不能用右值来替代。

又有一个重要的特点,即

  • 左值存放在实例中,有持久的状态;而
  • 右值要么是字面常量,要么是在表达式求值过程中创建的临时实例,没有持久的状态。

左值引用和右值引用

在 C++ 中,有两种对实例的引用:左值引用和右值引用。

左值引用是常见的引用,所以一般在提到「实例的引用」的时候,指得就是左值引用。如果我们将一个实例的内存空间绑定到另一个变量上,那么这个变量就是左值引用。在建立引用的时候,我们是「将内存空间绑定」,因此我们使用的是一个实例在内存中的位置,这是一个左值。因此,我们不能将一个右值绑定到左值引用上。另一方面,由于常量左值引用保证了我们不能通过引用改变对应内存空间的值,因此我们可以将右值绑定在常量引用上。

lvalue-reference
1
2
3
4
int foo(42);
int& bar = foo; // OK: foo 在此是左值,将它的内存空间与 bar 绑定在一起
int& baz = 42; // Err: 42 是右值,不能将它绑定在左值引用上
const int& qux = 42; // OK: 42 是右值,但是编译器可以为它开辟一块内存空间,绑定在 qux 上

右值引用也是引用,但是它只能且必须绑定在右值上。

rvalue-reference
1
2
3
4
5
6
7
int foo(42);
int& bar = foo; // OK: 将 foo 绑定在左值引用上
int&& baz = foo; // Err: foo 可以是左值,所以不能将它绑定在右值引用上
int&& qux = 42; // OK: 将右值 42 绑定在右值引用上
int&& quux = foo * 1; // OK: foo * 1 的结果是一个右值,将它绑定在右值引用上
int& garply = foo++; // Err: 后置自增运算符返回的是右值,不能将它绑定在左值引用上
int&& waldo = foo--; // OK: 后置自减运算符返回的是右值,将它绑定在右值引用上

由于右值引用只能绑定在右值上,而右值要么是字面常量,要么是临时对象,所以:

  • 右值引用的对象,是临时的,即将被销毁;并且
  • 右值引用的对象,不会在其它地方使用。

敲黑板:这是重点!

这两个特性意味着:接受和使用右值引用的代码,可以自由地接管所引用的实例的资源,而无需担心对其他代码逻辑造成数据破坏

引用的值类型与引用叠加

值类型

我们思考一个问题:右值引用本身是左值还是右值?或者可以先思考一下它的对偶问题:左值引用本身是左值还是右值?

先看下面的代码:

lvalue-reference-value-type
1
2
3
4
int foo(42);
int& bar = foo; // bar 是对 foo 的左值引用
int& baz = bar; // baz 是对 bar 的左值引用,因而 bar 是左值
int qux = ++foo; // 前置自增运算符返回左值引用,在这里赋值给 qux,此时左值引用作为右值

观察上面代码,不难发现,左值引用本身既可以是左值,又可以是右值。它具体是左值还是右值,依然取决于它作为表达式时候的作用。更仔细地观察可以发现,如果左值引用作为一个变量被保存下来了,那么它就可以是左值(当然也可以起到右值的作用);而如果左值引用是一个临时变量(例如函数的返回值),那么它就是右值。

同理可以用在右值引用上。

rvalue-reference-value-type
1
2
3
4
5
6
7
8
9
class Type;
void foo(Type&& bar) {
// 将右值引用作为 Type 的构造函数的参数
// 此时匹配 Type::Type(const Type& orig), 即拷贝构造函数
// bar 是左值
Type baz(bar);
}
Type&& qux();
quux = qux(); // qux 的返回值是 Type 类型的右值引用,此时右值引用是右值

和左值引用一样,右值引用本身也既可以作为左值也可以作为右值。并且,同样的是:如果右值引用作为变量被保存下来了,那么应该把它当做是一个左值看待;否则应当作为右值看待。

因此,不论是左值引用还是右值引用,都有

  • 当引用作为变量被保存下来,那么它是左值;否则
  • 它是右值。

叠加

我们先来看一段代码。

reference_collapsing.cpp
1
2
3
4
5
6
7
8
9
typedef int& intR;
typedef intR& intRR;

int main() {
int foo = 42;
intR bar = foo;
intRR baz = bar;
return 0;
}

在这里,intR 实际上是 int&。因此 intRR 就变成了 int& &,注意两个 & 之间有一个空格,表示这是对 int 类型引用的引用,也就是引用的叠加。在 C++11 之前,编译这份代码是会报错的:

1
ref_test.cpp:2:15: 错误:无法声明对‘intR {aka int&}’的引用

这是因为在 C++11 之前,C++ 标准没有写明引用叠加。在 C++11 中,引用叠加有如下规则:

1
2
3
4
Type&  &  -> Type&
Type& && -> Type&
Type&& & -> Type&
Type&& && -> Type&&

这有点类似布尔代数中的与运算:左值引用是 1,右值引用是 0。因此,在 C++11 中,上述代码中的 intRR 实际就是 int& 类型。这样一来,代码就合法了。

同样的引用叠加规则,也可以应用到模板参数推导中。看这个例子

template-param
1
2
template <typename T> void func(T&& foo);
auto fp = func<int&&>;

在这里,func 是一个模板函数,fp 是函数指针。要确定 fp 的实际类型,就要先确定模板函数参数的类型。

  • 在模板中,Tint&& 替换,因此 Tint 的右值引用;
  • 在函数参数列表声明中,fooT&& 类型,因此是 int&& && 类型,根据叠加规则,实际 fooint&& 类型。

这样一来,fp 就是 void (*)(int&&) 类型的指针了。

右值引用怎么用

说了这么多右值引用的概念,应该说点实际的用途了,这样右值引用这件事情看起来才会显得自然。

move 语义

假设 class Container 有这样的定义

Container-demo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Resource;
class Container {
public:
Container() : p_resrc(nullptr) {}
~Container() {
delete p_resrc;
}
Container(const Container& orig) : p_resrc(nullptr) {
p_resrc = new Resource(*(orig.p_resrc));
}
Container& operator=(const Container& rhs) {
p_resrc = new Resource(*(orig.p_resrc));
}
public:
Resource* p_resrc;
};

于是当你执行类似这样的代码的时候,你会很郁闷地发现,效率很低:

demo-return-Container
1
2
3
Container foo();
Container bar;
bar = foo(); // *

在执行 bar = foo() 的时候,会进行这样的操作:

  • 调用 bar.~Container() 销毁 bar
  • 调用 bar.operator=(foo)foo 的返回值的内容拷贝到 bar 里,同时伴随着对 Resource 的拷贝和构造;
  • foo 的返回值这一临时实例,调用析构函数进行销毁。

仔细想想,你就会发现,从临时实例构建新的实例,而后再销毁临时实例,这些步骤完全是多余的。我们最好能直接抛弃 bar 而后直接接管 foo 返回的临时实例。这样一来,就意味着我们需要重载 Container 类的赋值操作符,它应该有这样的函数声明:

1
Container& Container::operator=(const <mystery type> rhs)

我们希望,当 Container::operator= 的右操作数是右值引用时,调用这个版本的赋值运算符,那么毫无疑问,<mystery type> 应该是 Container&& 了。这就是 move 语义了。于是我们定义它(称为移动赋值运算符,以及同时定义移动构造函数):

move-demo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Resource;
class Container {
public:
Container() : p_resrc(nullptr) {}
~Container() {
delete p_resrc;
}
Container(const Container& orig) : p_resrc(nullptr) {
p_resrc = new Resource(*(orig.p_resrc));
}
Container& operator=(const Container& rhs) {
p_resrc = new Resource(*(orig.p_resrc));
}
Container(const Container&& orig) : p_resrc(nullptr) {
p_resrc ^= orig.p_resrc;
orig.p_resrc ^= p_resrc;
p_resrc ^= orig.p_resrc;
}
Container& operator=(const Container&& rhs) {
p_resrc ^= orig.p_resrc;
orig.p_resrc ^= p_resrc;
p_resrc ^= orig.p_resrc;
}
public:
Resource* p_resrc;
};

亦即,我们只需要交换两个指针的值就可以了。这样一来,在执行 bar = foo(); 的时候将会:

  • 调用 Container::operator=(const Container&&),交换 barfoo 返回的临时实例中资源指针的值;而后
  • 调用 Container::~Containor() 销毁 foo 返回的临时实例。

完美转发(perfect forwarding)

首先我们来看一个工厂函数

factory
1
2
3
4
template<typename T, typename ArgT>
std::shared_ptr<T> factory(const ArgT& arg) {
return shapred_ptr<T>(new T(arg));
}

factory 函数有两个模板参数 TArgT,并假定类型 T 有一个构造函数,可以接受 const ArgT& 类型的参数,进行 T 类型实例的构造,然后返回一个 T 类型的智能指针,指向构造出来的实例。

毫无疑问,在这个例子里,factory 函数的 arg 变量既可以接受左值,也可以接受右值(允许将右值绑定在常量左值引用上)。但这里还有一个问题,按照之前的分析,不论 arg 接受的是什么类型,到了 factory 函数内部,arg 本身都将是一个左值。这样一来,假设类型 T 的构造函数支持对 ArgT 类型的右值引用,也将永远不会被调用。也就是说,factory 函数无法实现 move 语义,也就无法不能算是完美转发。

这里我们引入一个函数,它是标准库的一部分:

forward
1
2
3
4
5
template<class S>
S&& forward(typename std::remove_reference<S>::type& a) noexcept
{

return static_cast<S&&>(a);
}

a 的类型是 S& 的时候,函数将返回 S&;当 a 的类型是 S&& 的时候,函数将返回 S&&。因此,在这种情况下,我们只需要稍微改动工厂函数的定义就可以了:

factory-final
1
2
3
4
template<typename T, typename ArgT>
std::shared_ptr<T> factory(ArgT&& arg) {
return std::shapred_ptr<T>(new T(std::forward<ArgT>(arg)));
}

于是:

  • arg 是接受的参数是 Type& 时,ArgTType&arg 的类型是 Type&T::T(Type&) 被调用;
  • arg 是接受的参数是 Type&& 时,ArgTType&&arg 的类型是 Type&&T::T(Type&&) 被调用。

这样一来,就保留了 move 语义,实现了完美转发。

std::move

标准库还定义了 std::move 函数,它的作用就是将传入的参数以右值引用的方式返回。

std::move
1
2
3
4
5
6
7
template<class T>
typename std::remove_reference<T>::type&&
std::move(T&& a) noexcept
{
typedef typename std::remove_reference<T>::type&& RvalRef;
return static_cast<RvalRef>(a);
}

首先,出现了两次 std::remove_reference<T>::type&&,它确保不论 T 传入的是什么,都将返回一个真实类型的右值引用。static_cast<RvalRef>(a) 则将 a 强制转换成右值引用并返回。有了 std::move,我们就可以调用 std::unique_ptr 的移动赋值运算符了(当然,单独这样调用可能没有什么意义):

1
2
3
std::unique_ptr<Type> new_ptr = std::move(old_ptr);
// old_ptr 应当立即被销毁,或者赋予别的值
// 不应对 old_ptr 当前的状态做任何假设

在这里,因为使用了 std::move 窃取了 old_ptr 中的资源,然后将他们移动到了 new_ptr 中去。这就隐含了一层意思:接下来我们不会在用 old_ptr 做任何事情,除非我们显式地对 old_ptr 赋予新值。事实上,我们不应对 old_ptr 当前的状态做任何假设,它就和已定义但未初始化的状态一样。因为,old_ptr 当前的状态,完全取决于 std::unique_ptr<Type>::operator=(unique_ptr<Type>&&) 的行为。

移动迭代器(move_iterator)

现在假设有这样一个容器 std::vector<std::unique_ptr<RegTree>>,即在向量中保存了若干指向 RegTreeunique_ptr 智能指针;又有一个函数 BoostNewTrees(std::vector<std::unique_ptr<RegTree>>& ret),将会首先清洗 ret 中的数据,然后再将新的数据放入 ret 中。

现在,我需要循环多次执行 BoostNewTrees 函数,并将他们生成的数据依次放入一个容器里。那么,下面的代码会产生编译错误:

1
2
3
4
5
6
std::vector<std::unique_ptr<RegTree>> ret;
for (size_t i(0); i != limit; ++i) {
std::vector<std::unique_ptr<RegTree>> tmp;
BoostNewTrees(tmp);
ret.insert(ret.end(), tmp.begin(), tmp.end()); // compile error!
}

这是因为,在调用 ret.insert() 函数时,传入的迭代器 tmp.begin() 在解引用时,会返回 std::unique_ptr<RegTree>&,进而尝试调用拷贝构造函数 unique_ptr<RegTree>(const unique_ptr<RegTree>&),复制内容。然而,该函数被声明为「删除的」,不允许用户调用,于是报错。

为此,我们需要调用 std::make_move_iterator 函数(定义在 iterator 头文件里),将普通的迭代器转换为移动迭代器。相比普通迭代器,移动迭代器仅仅在解引用时的行为有不同:它将返回元素类型的右值引用(而不是普通迭代器返回的左值引用)。这相当于对普通迭代器每次解引用之后,都调用一次 std::move 获取右值引用。于是,在进行 insert 的时候,调用的就是移动构造函数 unique_ptr<RegTree>(unique_ptr<RegTree>&&) 了,而这是允许的。

1
2
3
4
5
6
7
8
9
std::vector<std::unique_ptr<RegTree>> ret;
for (size_t i(0); i != limit; ++i) {
std::vector<std::unique_ptr<RegTree>> tmp;
BoostNewTrees(tmp);
ret.insert(ret.end(),
std::make_move_iterator(tmp.begin()),
std::make_move_iterator(tmp.end()));
}
// now we get `ret`.

参考

热评文章