C++(11)：forward与模板的完美转发-CFANZ编程社区

C++11中通过左值调用函数与通过右值调用函数，实参与形参的类型必须匹配

#include <iostream>
using namespace std;

void p1(int &d)    //通过左值引用调用函数
{
	cout<<"l_ref d="<<d<<endl;
}
void p2(int &&d)   //通过右值引用调用函数
{
	cout<<"r_ref d="<<d<<endl;
}

int main(){
	int a = 1;
	p1(a);        //a是左值，与函数p1的左值引用参数匹配
	p2(2);        //2是右值，于函数p2的右值引用参数匹配
	p2(a);        //a是左值，与函数p1的左值引用参数不匹配，无法编译
	return 0;
}


运行函数输出：
l_ref d=1
r_ref d=2

可以看的出来，左值实参与左值引用形参匹配，右值实参与右值引用参数匹配。

C++11对模板的推导做了引用折叠的特殊处理：

#include <iostream>
using namespace std;

template<class T>
void pd(T&& d)
{
	cout<<"d="<<d<<endl;
}

int main(){
	int a = 1;
	pd(a);        //通过左值调用模板函数，模板参数类型T被推导为左值引用int&类型
	pd(2);        //通过右值调用模板函数，模板参数类型T被推导为右值引用int&&类型
	return 0;
}

C++11为模板引入了“引用折叠”的概念：
    T& & ,T& && 和T&& &都会折叠成类型T&
    T&& &&折叠成T&&

1.当调用函数pd(a)时：
    a是左值，与左值引用相匹配
    T被推导为左值引用，即int&
    那么d的类型为int& &&，通过引用折叠后成为int&
2.当调用函数pd(2)时：
    2是右值，与右值引用相匹配
    T被推导为右值引用，即int&&
    那么d的类型为int&& &&，通过引用折叠后成为int&&

可见通过这种方式，模板函数pd可以既接受左值作为参数，又接受右值作为参数

有了这种方式，可否通过模板函数pd把函数p1和函数p2整合起来呢？

初步的想法是，直接在模板函数里调用：

#include <iostream>
using namespace std;

void p(int &d)
{
	cout<<"l_ref d="<<d<<endl;
}
void p(int &&d)
{
	cout<<"r_ref d="<<d<<endl;
}

template<class T>
void pd(T&& d)
{
	cout<<"pd forward, ";
	p(d);
}

int main(){

	int a =1;
	pd(a);
	pd(2);
	return 0;
}

程序运行输出：
pd forward, l_ref d=1
pd forward, l_ref d=2

居然最终调用的都是左值引用函数p(int &d)
为什么pd(2)通过模板函数pd转发调用的居然是左值引用函数p(int &d)
这是因为pd(2)通过引用折叠后，参数d的类型为右值引用int&&
而右值引用变量实际上是个左值(可以取地址的实名变量)
所以语句p(d)，调用的左值引用函数p(int &d)

那么是否可以在转发的时候保持参数的原始类型，转发到正确的函数上呢？

这需要借助标准库提供的forword函数。

forward函数在标准库中被重载为左值引用版本和右值引用版本：

forword的左值引用版本：

template<typename _Tp>
constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type& __t) noexcept
{
    return static_cast<_Tp&&>(__t);
}

当通过左值调用时，比如：
int a = 1;
forward<int&>(a);

_Tp的类型为int&
函数forward的返回值_Tp&&被推导为int& &&，进而折叠为int&
typename std::remove_reference<_Tp>被实例为remove_reference<int&>，type被推导为int， 参数__t的类型为int&
static_cast<_Tp&&>被推导为static_cast<int& &&>，进而折叠为static_cast<int&>
因此函数被实例化为：
int& forward(int& __t)
{
	return static_cast<int&>(__t)
}
函数什么都不用做，参数__t的左值引用类型被保留了下来。

forward的右值引用版本为：
template<typename _Tp>
constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
{
    return static_cast<_Tp&&>(__t);
}

当通过右值调用时,比如：
forward<int>(2);

_Tp的类型为int
函数forward的返回值_Tp&&被推导为int&&
typename std::remove_reference<_Tp>被实例为remove_reference<int>，type被推导为int， 参数__t的类型为int&&
static_cast<_Tp&&>被推导为static_cast<int&&>
因此函数被实例化为：
int&& forward(int &&__t)
{
	return static_cast<int &&>(__t)
}
函数什么都不用做，参数__t的右值引用类型被保留了下来。

可见forward可以保留模板实参的类型，左值引用参数与右值引用参数都可以被完好的保留下来。

万事已具备！

#include <iostream>
using namespace std;

void p(int &d)            //通过左值引用重载函数
{
	cout<<"l_ref d="<<d<<endl;
}
void p(int &&d)           //通过右值引用重载函数
{
	cout<<"r_ref d="<<d<<endl;
}

template<class T>
void pd(T&& d)
{
	cout<<"pd forward, ";
	p(forward<T>(d));    //通过forward对参数进行完美转发
}

int main(){

	int a =1;
	pd(a);               //通过左值调用pd，完美转发到p(int &d)
	pd(2);               //通过右值调用pd，完美转发到p(int &&d) 
	return 0;
}

运行程序输出：
pd forward, l_ref d=1
pd forward, r_ref d=2

可见通过模板函数pd可以对左值实参调用与右值实参调用进行完美的转发。