1--完美转发

为什么需要完美转发？

C++ Primer 关于转发 (P612 ) 有这么一段话：某些函数需要将其一个或多个实参连同类型不变 地转发给其他函数，在此情况下，我们需要保持被转发实参的所有性质；

用大白话来讲，就是希望转发某些参数时，我们不希望这个参数在转发过程中被改变了（例如由右值改变为了左值），而完美转发就可以实现上面的愿景；

1-1--实例代码分析

结合以下代码讲解实现完美转发的实例：代码参考

cpp 复制代码

#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); // 传递右值
}

代码运行结果如下：

cpp 复制代码

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的源码

cpp 复制代码

/**
   *  @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&；
cpp 复制代码
  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 &&）

cpp 复制代码

// 对于下面的代码, auto是被推断为 int&& 的，可以调用上面实例中的第一个print函数
// 因为这时用一个变量a来接收返回的右值，a就变成了左值，左值可以调用print()函数
auto a = std::forward<int>(v);

cpp 复制代码

#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的源码

cpp 复制代码

/**
   *  @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()无论传入的是一个左值还是一个右值，返回的都是一个右值 ，其类型是右值引用类型；

C++复习笔记--完美转发、std::move和std::forward的使用

1--完美转发

1-1--实例代码分析

2--std::forward的使用

2-1--std::forward的源码

2-2--std::forward大白话总结

3--std::move的使用

3-1--std::move的源码

3-2--std::move大白话总结