【C++ Primer | 16】std::move和std::forward、完美转发

右值引用应该是C++11引入的一个非常重要的技术，因为它是移动语义（Move semantics）与完美转发（Perfect forwarding）的基石：

• 移动语义：将内存的所有权从一个对象转移到另外一个对象，高效的移动用来替换效率低下的复制，对象的移动语义需要实现移动构造函数和移动赋值运算符。
• 完美转发：定义一个函数模板，该函数模板可以接收任意类型参数，然后将参数转发给其它目标函数，且保证目标函数接受

 

一、 引入的新规则

1. 规则1（引用折叠规则）：如果间接的创建一个引用的引用，则这些引用就会“折叠”。在所有情况下（除了一个例外），引用折叠成一个普通的左值引用类型。一种特殊情况下，引用会折叠成右值引用，即右值引用的右值引用， T&& &&。即

• X& &、X& &&、X&& &都折叠成X&
• X&& &&折叠为X&&

2. 规则2（右值引用的特殊类型推断规则）：当将一个左值传递给一个参数是右值引用的函数，且此右值引用指向模板类型参数(T&&)时，编译器推断模板参数类型为实参的左值引用，如

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

int main()
{
    int i = 42;
    f(i)   
}

上述的模板参数类型T将推断为int&类型，而非int。

• 若将规则1和规则2结合起来，则意味着可以传递一个左值int i给f，编译器将推断出T的类型为int&。再根据引用折叠规则 void f(int& &&)将推断为void f(int&)。
• 从上述两个规则可以得出结论：如果一个函数形参是一个指向模板类型的右值引用，则该参数可以被绑定到一个左值上。
• 规则3：虽然不能隐式的将一个左值转换为右值引用，但是可以通过static_cast显示地将一个左值转换为一个右值。【C++11中为static_cast新增的转换功能】。

 

std::move()解析

class Foo {
public:
    std::string member;
   
    Foo(const std::string& m): member(m) {}  // Copy member.  
    Foo(std::string&& m): member(std::move(m)) {} // Move member.
};

上述Foo(std::string&& member)中的member是rvalue reference，但是member却是一个左值lvalue，因此在初始化列表中需要使用std::move将其转换成rvalue。 

标准库中move的定义如下：

template<typename T>
typename remove_reference<T>::type&& move(T&& t)
{
    return static_cast<typename remove_reference<T>::type &&>(t);
}

move函数的参数T&&是一个指向模板类型参数的右值引用【规则2】，通过引用折叠，此参数可以和任何类型的实参匹配，因此move既可以传递一个左值，也可以传递一个右值；

std::move(string("hello"))调用解析：

• 首先，根据模板推断规则，确地T的类型为string;
• typename remove_reference<T>::type && 的结果为 string &&;
• move函数的参数类型为string&&;
• static_cast<string &&>(t)，t已经是string&&，于是类型转换什么都不做，返回string &&;

string s1("hello"); std::move(s1); 调用解析：

• 首先，根据模板推断规则，确定T的类型为string&;
• typename remove_reference<T>::type && 的结果为 string&
• move函数的参数类型为string& &&，引用折叠之后为string&;
• static_cast<string &&>(t)，t是string&，经过static_cast之后转换为string&&, 返回string &&;

从move的定义可以看出，move自身除了做一些参数的推断之外，返回右值引用本质上还是靠static_cast<T&&>完成的。

因此下面两个调用是等价的，std::move就是个语法糖。

void func(int&& a)
{
    cout << a << endl;
}

int a = 6;
func(std::move(a));

int b = 10;
func(static_cast<int&&>(b)); 

std::move执行到右值的无条件转换。就其本身而言，它没有move任何东西。

 

三、std::forward()解析 

 

class Foo
{
public:
    std::string member;

    template<typename T>
    Foo(T&& member): member{std::forward<T>(member)} {}
};

传递一个lvalue或者传递一个const lvaue

• 传递一个lvalue，模板推导之后 T = std::string&
• 传递一个const lvaue, 模板推导之后T = const std::string&
• T& &&将折叠为T&，即std::string& && 折叠为 std::string&
• 最终函数为: Foo(string& member): member{std::forward<string&>(member)} {}
• std::forward<string&>(member)将返回一个左值，最终调用拷贝构造函数

传递一个rvalue

• 传递一个rvalue，模板推导之后 T = std::string
• 最终函数为: Foo(string&& member): member{std::forward<string>(member)} {}
• std::forward<string>(member) 将返回一个右值，最终调用移动构造函数；

总结：

1. std::move和std::forward本质都是转换。std::move执行到右值的无条件转换。std::forward只有在它的参数绑定到一个右值上的时候，才转换它的参数到一个右值。

2. std::move没有move任何东西，std::forward没有转发任何东西。在运行期，它们没有做任何事情。它们没有产生需要执行的代码，一byte都没有。

测试代码：

#include <iostream>
using namespace std;

template<typename T>
void PrintT(T& t)
{
    cout << "lvaue" << endl;
}

template<typename T>
void PrintT(T&& t)
{
    cout << "rvalue" << endl;
}

template<typename T>
void TestForward(T&& v)
{
    PrintT(v);
    PrintT(std::forward<T>(v));
    PrintT(std::move(v));
    cout << "--------" << endl;
}

int main()
{
    TestForward(1);
    int x = 1;
    TestForward(x);
    TestForward(std::forward<int>(x));
}

输出结果：

 

[ 1 ]. C++11改进我们的程序之move和完美转发
[ 2 ]. C++11 std::move和std::forward

3. C++完美转发