C++11 完美转发

【1】为什么引入完美转发？

在函数模板编程中，常有一种场景是把模板参数转发给另一个调用函数，这时候如果只提供值传递版本会显得效率太低。看以下代码：

template<class TYPE, class ARG>
TYPE* getInstance(ARG arg)
{
    TYPE* pRet = nullptr;
    pRet = new TYPE(arg);
    return pRet;
}

代码很简单，就是用ARG参数去初始化一个TYPE类型的对象，然后返回该对象指针。

考虑一下，如果ARG类型是一个自定义类型，那么这样的值传递会是比较大的性能开销。

有没有办法改进一下？再看以下代码：

template<class TYPE, class ARG>
TYPE* getInstance(const ARG& arg)
{
    TYPE* pRet = nullptr;
    pRet = new TYPE(arg);
    return pRet;
}

这段代码将传入参数类型改为了“万能”的常量左值引用，可以接受任何类型，可以解决性能开销的问题。

但是，但是，还不够灵活，假如我们想TYPE接受一个右值去初始化呢？

那么有没有可以把参数连同类型一起转发的方案呢？当然有，没有C++办不到的。

C++11就提供了这样能力既完美转发。代码如下：

template<class TYPE, class ARG>
TYPE* getInstance(ARG&& arg)
{
    TYPE* pRet = nullptr;
    pRet = new TYPE(std::forward<ARG>(arg));
    return pRet;
}

嗯哼？难道把形参类型改为右值引用就可以了？懵圈....表示颠覆认知！看不懂无所谓，再往下看。

【2】引用折叠 与 模板推导

C++11是通过引入一条所谓“引用折叠”（reference collapsing）的新语言规则，并结合新的模板推导规则来实现的完美转发。

先了解一下引用折叠。如下语句：

typedef const int T;
typedef T& TR;
TR& v = 10; // 该声明在C++98中会导致编译错误 

在C++11之前，其中TR& v = 10;这样的表达式会被编译器认为是不合法的表达式。

而在C++11中，一旦出现了这样的表达式，就会发生引用折叠，即将复杂的未知表达式折叠为已知的简单表达式，

具体规则，如下图所示：

个人觉得，这个规则还是得深刻理解，记住一个原则：一旦定义中出现了左值引用，引用折叠总是优先将其折叠为左值引用。

如下验证程序：

#include <iostream>
using namespace std;

typedef const int T;
typedef T& TR;
typedef T&& TRR;

void JudgeType()
{
    cout << "lvalue_ref_type?: " << is_lvalue_reference<TR>::value << endl;  // 1
    cout << "rvalue_ref_type?: " << is_rvalue_reference<TR>::value << endl;  // 0

    cout << "lvalue_ref_type?: " << is_lvalue_reference<TR&>::value << endl; // 1
    cout << "rvalue_ref_type?: " << is_rvalue_reference<TR&>::value << endl; // 0

    cout << "lvalue_ref_type?: " << is_lvalue_reference<TR&&>::value << endl; // 1
    cout << "rvalue_ref_type?: " << is_rvalue_reference<TR&&>::value << endl; // 0

    cout << "lvalue_ref_type?: " << is_lvalue_reference<TRR>::value << endl;  // 0
    cout << "rvalue_ref_type?: " << is_rvalue_reference<TRR>::value << endl;  // 1

    cout << "lvalue_ref_type?: " << is_lvalue_reference<TRR&>::value << endl; // 1
    cout << "rvalue_ref_type?: " << is_rvalue_reference<TRR&>::value << endl; // 0

    cout << "lvalue_ref_type?: " << is_lvalue_reference<TRR&&>::value << endl; // 0
    cout << "rvalue_ref_type?: " << is_rvalue_reference<TRR&&>::value << endl; // 1
}

int main()
{
    JudgeType();
    system("pause");
}

模板推导。为了便于说明问题，下面我们把函数模板写为如下形式：

template <typename T>
void IamForwording(T&& t)
{ 
    IrunCodeActually(static_cast<T&&>(t));
}

说明：IamForwording为转发函数；IrunCodeActually为目标函数（即真正执行函数过程的目标）

模板对类型的推导规则就比较简单：

当转发函数的实参是类型X的一个左值引用，那么模板参数被推导为X&类型；

当转发函数的实参是类型X的一个右值引用，那么模板的参数被推导为X&&类型。

再结合以上的引用折叠规则，就能确定出参数的实际类型。

尤其注意，我们不仅在参数部分使用了T&&这样的标识，在目标函数传参的强制类型转换中也使用了这样的形式。

这个标识不是右值引用，它有专用的名字为转发引用（forwarding reference）。

比如，我们调用转发函数时传入了一个X类型的左值引用，可以想象，转发函数将被实例化为如下形式：

void IamForwording(X& && t) 
{ 
    IrunCodeActually(static_cast<X& &&>(t)); 
}

应用上引用折叠规则，就是：

void IamForwording(X& t)
{
    IrunCodeActually(static_cast<X&>(t));
}

如此一来，左值传递就毫无问题了。

实际使用的时候，IrunCodeActually如果接受左值引用的话，就可以直接调用转发函数。

不过你可能会发现，这里调用前的static_cast没有什么作用。

事实上，这里的static_cast是留给传递右值用的。如下分析。

如果我们调用转发函数时传入了一个X类型的右值引用的话，我们的转发函数将被实例化为：

void IamForwording(X&& && t)
{
    IrunCodeActually(static_cast<X&& &&>(t));
}

应用上引用折叠规则，就是：

void IamForwording(X&& t)
{
    IrunCodeActually(static_cast<X&&>(t));
}

这里我们就看到了static_cast的重要性。

事实上，对于一个右值而言，当它使用右值引用表达式引用的时候，该右值引用却是个不折不扣的左值。

那么我们想在函数调用中继续传递右值，就需要使用std::move来进行左值向右值的转换。

而std::move通常就是一个static_cast。不过在C++11中，用于完美转发的函数却不再叫作move，而是另外一个名字：forward。

 move和forward在实际实现上差别并不大。

不过标准库这么设计，也许是为了让每个名字对应于不同的用途，以应对未来可能的扩展。

推荐在实现完美转发时使用forward。

【3】完美转发的应用

完美转发的应用示例：

#include <iostream>
using namespace std;

void fun(int& x) { cout << "call lvalue ref" << endl; }
void fun(int&& x) { cout << "call rvalue ref" << endl; }
void fun(const int& x) { cout << "call const lvalue ref" << endl; }
void fun(const int&& x) { cout << "call const rvalue ref" << endl; }

template<typename T>
void PerfectForward(T&& t)
{
    std::cout << "T is a ref type?: " << std::is_reference<T>::value << std::endl;
    std::cout << "T is a lvalue ref type?: " << std::is_lvalue_reference<T>::value << std::endl;
    std::cout << "T is a rvalue ref type?: " << std::is_rvalue_reference<T>::value << std::endl;

    fun(forward<T>(t));
}

int main()
{
    PerfectForward(10);           // call rvalue ref

    int a = 5;
    PerfectForward(a);            // call lvalue ref
    PerfectForward(move(a));      // call rvalue ref

    const int b = 8;
    PerfectForward(b);           // call const lvalue ref
    PerfectForward(move(b));     // call const rvalue ref

    system("pause");
    return 0;
}

/*
T is a ref type?: 0
T is a lvalue ref type?: 0
T is a rvalue ref type?: 0
call rvalue ref
T is a ref type?: 1
T is a lvalue ref type?: 1
T is a rvalue ref type?: 0
call lvalue ref
T is a ref type?: 0
T is a lvalue ref type?: 0
T is a rvalue ref type?: 0
call rvalue ref
T is a ref type?: 1
T is a lvalue ref type?: 1
T is a rvalue ref type?: 0
call const lvalue ref
T is a ref type?: 0
T is a lvalue ref type?: 0
T is a rvalue ref type?: 0
call const rvalue ref
*/

所有4种类型的值对完美转发进行测试，可以看到，所有的转发都被正确地送到了目的地。

注意分析，加深理解。

good good study, day day up.

顺序 选择 循环 总结