std::move和std::forward

 

　　std::move和std::forward是C++11中新增的标准库函数，分别用于实现移动语义和完美转发。
　　下面让我们分析一下这两个函数在gcc4.6中的具体实现。

预备知识

引用折叠规则

T& + & => T&
T&& + & => T&
T& + && => T&
T&& + && => T&&

就是左值引用会传染，沾上一个左值引用就变左值引用了，只有都为纯右值引用结果才为右值引用&& && = &&。

模板参数推导规则

 

 只有调用前fpar是&&，apar是&时，调用后T的实际类型才是A&，其余3种情况下都是A。

 

1、当模板参数为T时

 

　　因为是值传递，所以expr的所有修饰特性都会被忽略，const, 引用，volatile等，都被忽略。

 

 

• 如果表达式不是指针，T和x的类型都是非引用类型，cv限定符（const、volatile）去除。比如表达式是int、int&、int&&、const int、const int&，只要不是指针，T和x最终都是int；
• 如果是指针，T和x都是对应的指针类型，cv限定符保留；注意指针常量的情况，由于指针常量本质上是一个常量，所以cv限定符去除。

#include <iostream>

template<typename T>
void f(T param) {
    T a;
    std::cout << param;
}// param 为值传递
// 因为是值传递，所以expr的所有修饰特性都会被忽略，const, 引用，volatile等，都被忽略
int main()
{
    int x = 2;
    const int cx = x;
    int& rx = x;
    const int& crx = x;
    int* p = &x;
    const int* cip = &x;
    int* const icp = &x;
    f(x);     // x: int                param : int,         T : int
    f(cx);    // cx: const int,        param : int,         T : int
    f(rx);    // rx : int&,            param : int,         T : int 
    f(crx);   // crx : const int&,     param : int,         T : int 
    f(p);     // p : int*,             param : int*,        T : int*
    f(cip);   // cip : const int*,     param : const int*,  T : const int*
    f(icp);   // icp : int* const,     param : int*,        T : int*

    return 0;
}

2、当模板参数为T&时

• 对于T&，不管表达式是什么，parma一定是左值引用类型（表达式是指针则x是指针的引用），cv限定符保留；
• 对于T*，和T&类似，parma一定是指针类型，cv限定符保留；

template<typename T>
void f(T& param)
{
    T a(0);
}

template<typename T>
void pf(T* param)
{
    T a(0);
}

template<typename T>
void cf(const T& param)
{
    T a(0);
}


int main()
{
    int x = 2;
    const int cx = x;
    int& rx = x;
    const int& crx = x;
    int* p = &x;
    const int* cip = &x;
    int* const icp = &x;
    int&& rrx = 2;

    f(x);     // x: int                param : int&,            T : int
    f(cx);    // cx: const int,        param : const int&,      T : const int
    f(rx);    // rx : int&,            param : int&,            T : int 
    f(crx);   // crx : const int&,     param : const int&,      T : const int 
    f(p);     // p : int*,             param : int* &,            T : int*
    f(cip);   // cip : const int*,     param : const int* &,    T : const int*
    f(icp);   // icp : int* const,     param : int* const &,    T : int* const
    f(rrx);   // rrx : int&&,           param : int&,            T : int




    pf(p);     // p : int*,             param : int*,        T : int
    pf(cip);   // cip : const int*,     param : const int*,  T : const int
    pf(icp);   // icp : int* const,     param : int*,        T : int



    cf(x);     // x: int                param : const int&,         T : int
    cf(cx);    // cx: const int,        param : const int&,         T : int
    cf(rx);    // rx : int&,            param : const int&,         T : int 
    cf(crx);   // crx : const int&,     param : const int&,         T : int 
    cf(p);     // p : int*,             param : int* const&,        T : int*
    cf(cip);   // cip : const int*,     param : const int* const&,  T : const int*
    cf(icp);   // icp : int* const,     param : int* const &,        T : int*
    cf(rrx);   // rrx : int&&,            param : const int&,            T : int
   

    return 0;
}

 

3、当模板参数为T&&时

• 不管表达式是什么，parma都是引用类型：
• 如果表达式是左值，则parma是左值引用，cv限定符保留，即采用和T&相同的规则，只不过因为T&&多了个&，为了转为左值引用需要引入引用折叠的概念。通过下面的例子可以发现，T一定是左值引用类型，这是T被推断为引用类型的唯一情况；
• 如果表达式是右值，则x是右值引用类型；

template<typename T>
void f(T&& x);

int i;
int& r;
int&& rr;
const int& cr;
int* p;
const int* const q;
// 都是左值，采用的规则和T&的相同
f(i); // x是int& => T&&是int&，int& + && = int& => T是int&
f(r); // x是int& => T&&是int&，int& + && = int& => T是int&
f(rr); // x是int& => T&&是int&，int& + && = int& => T是int&
f(cr); // x是const int& => T&&是const int& => T是const int&
f(p); // x是int* & => T&&是int* & => T是int* &
f(q); // x是const int* const & => T&&是const int* const & => T是const int* const &

// 表达式是右值
f(42); // x是int&& => T&&是int&& => T是int

std::remove_reference

std::remove_reference为C++11标准库中的元函数，其功能为去除类型中的引用。
std::remove_reference<U&>::type ≡ U
std::remove_reference<U&&>::type ≡ U
std::remove_reference<U>::type ≡ U

static_cast<T&&>(t)

以下语法形式将把表达式 t 转换为T类型的右值（准确的说是无名右值引用，是右值的一种）
static_cast<T&&>(t)

无名的右值引用是右值
具名的右值引用是左值。

注：本文中 ≡ 含义为“即，等价于“。

std::move

函数功能

std::move(t) 负责将表达式 t 转换为右值，使用这一转换意味着你不再关心 t 的内容，它可以通过被移动（窃取）来解决移动语意问题。

源码与测试代码

  template<typename _Tp>
    inline typename std::remove_reference<_Tp>::type&&
    move(_Tp&& __t)
    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }

#include<iostream>
using namespace std;
 
struct X {};
 
int main()
{
    X a;
    X&& b = move(a);
    X&& c = move(X());
}

std::forward

函数功能
std::forward<T>(u) 有两个参数：T 与 u。当T为左值引用类型时，u将被转换为T类型的左值，否则u将被转换为T类型右值。如此定义std::forward是为了在使用右值引用参数的函数模板中解决参数的完美转发问题。

源码与测试代码

  /// forward (as per N3143)
  template<typename _Tp>
    inline _Tp&&
    forward(typename std::remove_reference<_Tp>::type& __t) 
    { return static_cast<_Tp&&>(__t); }
 
  template<typename _Tp>
    inline _Tp&&
    forward(typename std::remove_reference<_Tp>::type&& __t) 
    {
      static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
            " substituting _Tp is an lvalue reference type");
      return static_cast<_Tp&&>(__t);
    }

#include<iostream>
using namespace std;
 
struct X {};
void inner(const X&) {cout << "inner(const X&)" << endl;}
void inner(X&&) {cout << "inner(X&&)" << endl;}
template<typename T>
void outer(T&& t) {inner(forward<T>(t));}
 
int main()
{
    X a;
    outer(a);
    outer(X());
    inner(forward<X>(X()));
}
//inner(const X&)
//inner(X&&)
//inner(X&&)

 

参考 

zwvistaC++11尝鲜：std::move和std::forward源码分析

引用叠加规则和模板参数类型推导规则