三者的关系
我的理解是这样的：
- 因为【引用折叠】特性，才有了万能引用。
- 【完美转发】的特性是借助【万能引用】以及【forward模板函数】来实现。
引用折叠
在 前面文章 介绍过，什么是引用折叠。总结下来就是C++中的两条规则：
- 规则一: 当我们将一个左值传给模板函数的右值引用参数（T&&)时, 编译器推断模板类型参数T为的左值引用类型，例如对于int类型时，推断T为int&.
- 例外规则二：如果我们间接创建了一个引用的引用，则这些引用形成了引用折叠。正常情况下，不能直接创建引用的引用，但是可以间接创建。大部分情况下，引用的引用会折叠为普通的左值引用（T& &、T& &&、 T&& &），右值引用的右值引用，则折叠成右值引用。
举例如下：代码中的函数模板在进行实参推志过程中，T被推导为 int& 类型， int& && 发生引用折叠，最终还是int& 类型。
template<typename T>
void Print(T&& t) {
}
int main()
{
int a = 10;
Print(a);
return 0;
}
代码中，编译器实例化的结果为：
template<>
void Print<int &>(int & t)
{
}
万能引用
一句话说，就是：即可以绑定到左值引用也可以绑定到右值引用， 并且还会保持左右值的const属性的函数模板参数。形如这样的参数 T&& 就是万能引用。
看下面代码的例子，一眼了然：
template <typename T>
void MyFunc(T&& value) {
}
void main() {
int a = 10;
const int b = 100;
MyFunc(a); // T 为int& 发生引用折叠：int& && ----> int&
MyFunc(b); // T 为const int& 发生引用折叠：constt int& && -----> const int&
MyFunc(100); // T 为int,不发生引用折叠
MyFunc(static_cast<const int&&>(100); // T 为 const int,不发生引用折叠
}
实际上，代码中四次函数模板调用实例化的模板函数分别如下所示：
template<>
void MyFunc<int &>(int & value) {
}
template<>
void MyFunc<const int &>(const int & value) {
}
template<>
void MyFunc<int>(int && value) {
}
template<>
void MyFunc<const int>(const int && value) {
}
完美转发
为什么需要完美转发
本质原因是：右值引用的变量在直接用于作表达式时，被认为是左值变量。 (见此处示意代码中有说明)
举个最简单的例子，下面的代码直接编译报错：
void Func(int&& a) {
}
int main() {
int&& a = 10;
Func(a);
return 0;
}
报错如下：
yin@yin:~$ g++ 1.cpp
1.cpp: In function ‘int main()’:
1.cpp:6:10: error: cannot bind rvalue reference of type ‘int&&’ to lvalue of type ‘int’
Func(a);
^
1.cpp:1:6: note: initializing argument 1 of ‘void Func(int&&)’
void Func(int&& a) {
这会一来会导致什么问题呢，那就是函数模板里调用另一个函数模板时，最外层的的函数模板的参数通常都是万能引用（右值引用，T&&)， 传递给最外层的函数模板明明一个右值，然而外层函数模板把参数传递给内层的函数模板时，参数却变成了一个左值， 原参数的属性直接丢失了。看下面的举个例子：
#include <type_traits>
#include <iostream>
using namespace std;
template <typename T>
void Func2(T&& j) {
cout << is_rvalue_reference<T&&>::value << endl;
}
template <typename T>
void Func1(T&& i) {
cout << is_rvalue_reference<T&&>::value << endl;
Func2(i);
}
int main() {
Func1(10);
return 0;
}
输出为如下所示：
yin@yin:~$ ./a.out
1
0
如何解决
借助引用折叠与万能引用的特性，c++11 标准中提供了一个std::forward<T>()的函数，实现了完美转发。 看看如何使用，以及使用效果：
#include <type_traits>
#include <iostream>
using namespace std;
template <typename T>
void Func2(T&& j) {
cout << is_rvalue_reference<T&&>::value << endl;
}
template <typename T>
void Func1(T&& i) {
cout << is_rvalue_reference<T&&>::value << endl;
Func2(std::forward<T>(i)); // 注意，此处使用了std::foward<T>();
}
int main() {
Func1(10);
return 0;
}
输出如下， 符合预期，实现完美转发。
yin@yin:~$ ./a.out
1
1
内部实现
想在弄明白原理， 需要结合外层的函数调用（万能引用参数T&&)，以及std::forward
不太多解释，自己看应该明白。 说几点：
- std::remove_reference
, 是一个类模板，用于移除类型的引用。具体原型，见后面。 - 这里的std::forward的实现使用了两个重载的函数模板。
std::forward的实现如下(gcc的libstdc++的实现，位于/usr/include/c++/8/bits/move.h文件内)：
/**
* @brief Forward an lvalue.
* @return The parameter cast to the specified type.
*
* This function is used to implement "perfect forwarding".
*/
template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type& __t) noexcept
{ return static_cast<_Tp&&>(__t); }
/**
* @brief Forward an rvalue.
* @return The parameter cast to the specified type.
*
* This function is used to implement "perfect forwarding".
*/
template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
{
static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
" substituting _Tp is an lvalue reference type");
return static_cast<_Tp&&>(__t);
}
其它常用到的模板实现
std::move
位于/usr/include/c++/8/bits/move.h文件内。
/**
* @brief Convert a value to an rvalue.
* @param __t A thing of arbitrary type.
* @return The parameter cast to an rvalue-reference to allow moving it.
*/
template<typename _Tp>
constexpr typename std::remove_reference<_Tp>::type&&
move(_Tp&& __t) noexcept
{ return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
remove_reference
位于/usr/include/c++/8/type_traits文件内。
/// remove_reference
template<typename _Tp>
struct remove_reference
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&&>
{ typedef _Tp type; };