目录

1、不完美转发

2、完美转发

2.1、引用折叠

2.2、std::forward

所谓完美转发，是指在函数模板中，完全按照模板的参数的类型，将参数传递给函数模板中调用的另一个函数。比如：

template 
void IamForwording(T t)
{
    IrunCodeActually(t);
}

上面的例子中，IamForwarding是一个转发函数模板。而函数IrunCodeActually则是真正执行代码的目标函数。对于目标函数IrunCodeActually而言，它总是希望转发函数将参数按照传入Iamforwarding时的类型传递（即传入ImaForwarding的是左值对象，IrunCodeActually就能获得左值对象，传入ImaForwarding的是右值对象，IrunCodeActually就能获得右值对象），而不产生额外的开销，就好像转发者不存在一样。

在ImaForwarding的参数中使用了最基本类型进行转发，该方法会导致参数在传给IrunCodeActually之前就产生了一次临时对象拷贝。因此这样的转发只能说是正确的转发，谈不上完美。

2、完美转发

C++11 标准中规定，通常情况下右值引用形式的参数只能接收右值，不能接收左值。但对于函数模板中使用右值引用语法定义的参数来说，它不再遵守这一规定，既可以接收右值，也可以接收左值（此时的右值引用又被称为“万能引用”）。

2.1、引用折叠

& + & -> &
& + && -> &
&& + & -> &
&& + && -> &&

一旦定义中出现了左值引用，引用折叠总是优先将其折叠为左值引用。

模板对类型的推导规则就比较简单了，当转发函数的实参是类型X的一个左值引用时，那么模板参数被推导为X&，而转发函数的实参是类型X的一个右值引用的话，那么模板的参数被推导为X&&类型。

结合以上的引用折叠规则，就能确定参数的实际类型，进一步，我们可以把转发函数写成如下形式：

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

当调用转发函数时传入了一个X类型的左值引用，转发函数被实例化为如下形式：

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

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

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

这样一来，左值传递没有任何问题。但是就有人问了，你写static_cast是不是脑子有点问题啊，先别骂，接着往下看。

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

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

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

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

此处的static_cast起到的作用就是std::move的作用，因为std::move通常就是一个static_cast。不过在c++11中，用于完美转发的不是static_cast，也不是std::move，而是std::forward。

2.2、std::forward

std::forward和std::move在实际实现上差别不大，不过标准库这么设计，也许是为了让每个名字对应于不同的用途，以应对未来的扩展。

template 
void IamForwording(T&& t)
{
    IrunCodeActually(std::forward(t));
}

// forward example
#include   // std::forward
#include  // std::cout

// function with lvalue and rvalue reference overloads:
void overloaded(const int &x) { std::cout << "[lvalue]"; }
void overloaded(int &&x) { std::cout << "[rvalue]"; }

// function template taking rvalue reference to deduced type:
template 
void fn(T &&x)
{
    overloaded(x);                  // always an lvalue
    overloaded(std::forward(x)); // rvalue if argument is rvalue
}

int main()
{
    int a;

    std::cout << "calling fn with lvalue: ";
    fn(a);
    std::cout << 'n';

    std::cout << "calling fn with rvalue: ";
    fn(std::move(a));
    std::cout << 'n';

    return 0;
}

运行结果：

#include 

using namespace std;

void RunCode(int &&m) { cout << "rvalue ref" << endl; }
void RunCode(int &m) { cout << "lvalue ref" << endl; }
void RunCode(const int &&m) { cout << "const rvalue ref" << endl; }
void RunCode(const int &m) { cout << "const lvalue ref" << endl; }

template 
void PerfectForward(T &&t)
{
    RunCode(forward(t));
}

int main()
{
    int a;
    int b;
    const int c = 1;
    const int d = 0;

    PerfectForward(a);
    PerfectForward(move(b));
    PerfectForward(c);
    PerfectForward(move(d));
    return 0;
}

运行结果：

 

#include 

using namespace std;

template 
void PerfectForward(T &&t, U &&func)
{
    cout << t << "tforwarded...";
    func(forward(t));
}

void RunCode(double &&m) { cout << "tRunCode" << endl; }
void RunHome(double &&h) { cout << "tRunHome" << endl; }
void RunComp(double &&c) { cout << "tRunComp" << endl; }

int main()
{
    PerfectForward(1.5, RunComp);
    PerfectForward(8, RunCode);
    PerfectForward(1.5, RunHome);
    return 0;
}

 运行结果：

希望我们都有重新开始的勇气！