目录
1--完美转发
为什么需要完美转发？
C++ Primer 关于转发 (P612) 有这么一段话：某些函数需要将其一个或多个实参连同类型不变地转发给其他函数，在此情况下，我们需要保持被转发实参的所有性质；
用大白话来讲，就是希望转发某些参数时，我们不希望这个参数在转发过程中被改变了（例如由右值改变为了左值），而完美转发就可以实现上面的愿景；
1-1--实例代码分析
结合以下代码讲解实现完美转发的实例：代码参考
#include <iostream>
template<typename T>
void print(T & t){ // 只接受左值
std::cout << "Lvalue ref" << std::endl;
}
template<typename T>
void print(T && t){ // 万能引用，可以接受左值和右值
std::cout << "Rvalue ref" << std::endl;
}
template<typename T>
void testForward(T && v){
print(v);
print(std::forward<T>(v));
print(std::move(v));
std::cout << "======================" << std::endl;
}
int main(int argc, char * argv[]){
int x = 1;
testForward(x); // 传递左值
testForward(1); // 传递右值
}代码运行结果如下：
Lvalue ref
Lvalue ref
Rvalue ref
======================
Lvalue ref
Rvalue ref
Rvalue ref
======================代码分析：
对于第一个 testForward(x) 的执行：
① x 本身是一个左值，当传递给函数 testForward(T && v) 时，T 会被推断为 int &（推断分析参考笔记：万能引用和引用折叠）；函数模板等价于 testForward(int & v);（发生了引用折叠 T && → int & && → int &）；执行第一个 print(v) 时，v是一个左值，因此优先调用第一个 print() 函数；
② 执行第二个 print(std::forward<T>(v)) 时，v 是一个左值，经过 std::forward<T>(v) 返回的值仍然是一个左值（后面会结合源码分析 std::forward 的使用），因此优先调用第一个 print() 函数；
③ 执行第三个 print(std::move(v)) 时，v 是一个左值，经过 std::move(v) 返回的值是一个右值（后面会结合源码分析 std::move 的使用），因此只能调用第二个 print() 函数；
对于第二个 testForward(1) 的执行：
① 字面值 1 本身是一个右值，当传递给函数 testForward(T && v) 时，T 会被推断为 int；函数模板等价于 testForward(int v); 执行第一个 print(v) 时，由于 v 这时用一个变量（拥有地址）来存储了数值 1，因此 v 是一个左值，会优先调用第一个 print() 函数；
② 执行第二个 print(std::forward<T>(v)) 时，v 是一个左值，由于 T 被推断为 int，则经过 std::forward<T>(v) 返回的值是一个右值（会结合源码分析），因此只能调用第二个 print() 函数；
③ 执行第三个 print(std::move(v)) 时，v 是一个左值，经过 std::move(v) 返回的值是一个右值（会结合源码分析），因此只能调用第二个 print() 函数；
上面实例是为了说明 std::forward<T>() 函数能够根据 T 的不同，返回值的同时，能够很好地维持本来该有的类型属性；以下会结合源码分析 std::forward 和 std::move 的作用；
2--std::forward的使用
2-1--std::forward的源码
/**
* @brief Forward an lvalue.
* @return The parameter cast to the specified type.
*
* This function is used to implement "perfect forwarding".
*/
template<typename _Tp>
_GLIBCXX_NODISCARD
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>
_GLIBCXX_NODISCARD
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
{
static_assert(!std::is_lvalue_reference<_Tp>::value,
"std::forward must not be used to convert an rvalue to an lvalue");
return static_cast<_Tp&&>(__t);
}简单结合第一个模板的源码来分析上面的代码实例：
① 对于 std::forward<T>(v)，当 v 是一个左值，且 T 已经被推断为 int & 时的情况，std::forward<T>(v) 等价于 std::forward<int&>(v)；即对于以下的源码，传入的 _Tp 是 int&；
template<typename _Tp> _GLIBCXX_NODISCARD constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type& __t) noexcept { return static_cast<_Tp&&>(__t); }对于上面的源码，首先需知道 std::remove_reference<int&>::type 的结果是 int（具体可见C++ Primer Page 605），_Tp&&发生引用折叠：_Tp&& → int& && → int&，则源码等价于 constexpr int& forward(int& __t)，返回的类型是 int&，即返回的类型对应左值引用，则返回的值是一个左值；
② 对于 std::forward<T>(v)，当 v 是一个左值，且 T 已经被推断为 int 时的情况，
std::forward<T>(v) 等价于 std::forward<int>(v)；即对于上面的源码，传入的 _Tp 是 int；std::remove_reference<int>::type 的结果仍然是 int，则源码等价于 constexpr int&& forward(int& __t)，返回的类型是 int&&，即返回的类型对应右值引用，则返回的值是一个右值；
（这里可能会有疑惑？明明返回的类型是右值引用，右值引用虽然只能绑定右值，但其本质上是一个左值呀，为什么返回的是右值呀？）（回答：首先返回类型和返回的值是不同的，std::forward这里返回的是值，这个值并没有用一个变量去存储，而是直接返回了，因此这个返回的值是右值，不能调用上面实例的第一个print()函数，尽管这个返回的值的类型是右值引用int &&）
// 对于下面的代码, auto是被推断为 int&& 的，可以调用上面实例中的第一个print函数
// 因为这时用一个变量a来接收返回的右值，a就变成了左值，左值可以调用print()函数
auto a = std::forward<int>(v);#include <iostream>
template<typename T>
void print(T & t){ // 只接受左值
std::cout << "Lvalue ref" << std::endl;
}
int main(int argc, char * argv[]){
int v = 1;
auto a = std::forward<int>(v); // int &&a = 1;
// a 变成了左值
print(a);
}2-2--std::forward大白话总结
当传入一个实参到 std::forward 中，其显式类型是T，则返回的值与实参的值相同，且返回类型是T&&；
3--std::move的使用
3-1--std::move的源码
/**
* @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>
_GLIBCXX_NODISCARD
constexpr typename std::remove_reference<_Tp>::type&&
move(_Tp&& __t) noexcept
{ return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }简单结合模板的源码来分析上面的代码实例：
① 对于std::move(v) 时，v 是一个左值，v 的类型是 int &，当传入 std::move(v) 函数时，_Tp推断为int &，源码等价于 int&& move(int& _t); 接收一个左值，返回类型是 int&&，即右值引用类型，返回的值是一个右值，因此只能调用上面代码实例中的第二个 print() 函数；
② 对于std::move(v) 时，v 是一个左值，v 的类型是 int，当传入 std::move(v) 函数时，_Tp推断为int，源码等价于 int&& move(int&& _t); 接收一个右值，返回类型是 int&&，即右值引用类型，返回的值是一个右值，因此也只能调用上面代码实例中的第二个 print() 函数；
3-2--std::move大白话总结
std::move()无论传入的是一个左值还是一个右值，返回的都是一个右值，其类型是右值引用类型；