【重学C++】05 | 说透右值引用、移动语义、完美转发（下）

文章首发

引言

大家好，我是只讲技术干货的会玩code，今天是【重学C++】的第五讲，在第四讲《【重学C++】04 | 说透右值引用、移动语义、完美转发（上）》中，我们解释了右值和右值引用的相关概念，并介绍了C++的移动语义以及如何通过右值引用实现移动语义。今天，我们聊聊右值引用的另一大作用 -- 完美转发。

什么是完美转发

假设我们要写一个工厂函数，该工厂函数负责创建一个对象，并返回该对象的智能指针。

template<typename T, typename Arg> 
std::shared_ptr<T> factory_v1(Arg arg)
{
	return std::shared_ptr<T>(new T(arg));
}
class X1 {
public:
	int* i_p;
	X(int a) {
	i_p = new int(a);
	}
}

对于类X的调用方来说，auto x1_ptr = factory_v1<X1>(5); 应该与auto x1_ptr = std::shared_ptr<X>(new X1(5))是完全一样的。

也就是说，工厂函数factory_v1对调用者是透明的。要达到这个目的有两个前提：

传给factory_v1的入参arg能够完完整整(包括引用属性、const属性等)得传给T的构造函数。
工厂函数factory_v1没有额外的副作用。

这个就是C++的完美转发。

单看factory_v1应用到X1貌似很"完美"，但既然是工厂函数，就不能只满足于一种类对象的应用。假设我们有类X2。定义如下

class X2 {
public:
	X2(){}
	X2(X2& rhs) {
	std::cout << "copy constructor call" << std::endl;
	}
}

现在大家再思考下面代码：

X2 x2 = X2();
auto x2_ptr1 = factory_v1<X2>(x2);
// output:
// copy constructor call
// copy constructor call
auto x2_ptr2 = std::shared_ptr<X2>(x2)
// output:
// copy constructor call

可以发现，auto x2_ptr1 = factory_v1<X2>(x2); 比 auto x2_ptr2 = std::shared_ptr<X2>(x2)多了一次拷贝构造函数的调用。

为什么呢？很简单，因为factory_v1的入参是值传递，所以x2在传入factory_v1时，会调用一次拷贝构造函数，创建arg。很直接的办法，把factory_v1的入参改成引用传递就好了，得到factory_v2。

template<typename T, typename Arg> 
std::shared_ptr<T> factory_v2(Arg& arg)
{
	return std::shared_ptr<T>(new T(arg));
}

改成引用传递后，auto x1_ptr = factory_v2<X1>(5);又会报错了。因为factory_v2需要传入一个左值，但字面量5是一个右值。

方法总比困难多，我们知道，C++的const X& 类型参数，既能接收左值，又能接收右值，所以，稍加改造，得到factory_v3。

template<typename T, typename Arg> 
std::shared_ptr<T> factory_v3(const Arg& arg)
{
	return std::shared_ptr<T>(new T(arg));
}

factory_v3还是不够"完美"，再看看另外一个类X3。

class X3 {
public:
	X3(){}
	X3(X3& rhs) {
	std::cout << "copy constructor call" << std::endl;
	}
	X3(X3&& rhs) {
	std::cout << "move constructor call" << std::endl;
	}
}

再看看以下使用例子

auto x3_ptr1 = factory_v3<X3>(X3());
// output
// copy constructor call
auto x3_ptr2 = std::shared_ptr<X3>(new X3(X3()));
// output
// move constructor call

通过上一节我们知道，有名字的都是左值，所以factory_v3永远无法调用到T的移动构造函数。所以，factory_v3还是不满足完美转发。

特殊的类型推导 - 万能引用

给出完美转发的解决方案前，我们先来了解下C++中一种比较特殊的模版类型推导规则 - 万能引用。

// 模版函数签名
template <typename T>
void foo(ParamType param);
// 应用
foo(expr);

模版类型推导是指根据调用时传入的expr，推导出模版函数foo中ParamType和param的类型。

类型推导的规则有很多，大家感兴趣可以去看看《Effective C++》[1]，这里，我们只介绍一种比较特殊的万能引用。万能引用的模版函数格式如下：

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

万能引用的ParamType是T&&，既不能是const T&&，也不能是std::vector<T>&&

万能引用的规则有三条：

如果expr是左值，T和param都会被推导成左值引用。
如果expr是右值，T会被推导成对应的原始类型，param会被推导成右值引用（注意，虽然被推导成右值引用，但由于param有名字，所以本身还是个左值）。
在推导过程中，expr的const属性会被保留下来。

看下面示例

template<typename T>
void foo(T&& param);
// x是一个左值
int x=27;
// cx是带有const的左值
const int cx = x;
// rx是一个左值引用
const int& rx = cx;
// x是左值，所以T是int&，param类型也是int&
foo(x);
// cx是左值，所以T是const int&，param类型也是const int&
foo(cx);
// rx是左值，所以T是const int&，param类型也是const int&
foo(rx);
// 27是右值，所以T是int，param类型就是int&&
foo(27);

std::forward实现完美转发

到此，完美转发的前置知识就已经讲完了，我们看看C++是如何利用std::forward实现完美转发的。

template<typename T, typename Arg> 
std::shared_ptr<T> factory_v4(Arg&& arg)
{ 
 return std::shared_ptr<T>(new T(std::forward<Arg>(arg)));
}

std::forward的定义如下

template<class S>
S&& forward(typename remove_reference<S>::type& a) noexcept
{
 return static_cast<S&&>(a);
}

传入左值

X x;
auto a = factory_v4<A>(x);

根据万能引用的推导规则，factory_v4中的Arg会被推导成X&。这个时候factory_v4和std::forwrd等价于：

shared_ptr<A> factory_v4(X& arg)
{ 
 return shared_ptr<A>(new A(std::forward<X&>(arg)));
}
X& std::forward(X& a) 
{
 return static_cast<X&>(a);
}

这个时候传给A的参数类型是X&，即调用的是拷贝构造函数A(X&)。符合预期。

传入右值

X createX();
auto a = factory_v4<A>(createX());

根据万能引用推导规则，factory_v4中的Arg会被推导成X。这个时候factory_v4和std::forwrd等价于：

shared_ptr<A> factory_v4(X&& arg)
{ 
 return shared_ptr<A>(new A(std::forward<X>(arg)));
}
X&& forward(X& a) noexcept
{
 return static_cast<X&&>(a);
}

此时，std::forward作用与std::move一样，隐藏掉了arg的名字，返回对应的右值引用。这个时候传给A的参数类型是X&&，即调用的是移动构造函数A(X&&)，符合预期。