C++ std::move和std::forward
首先奉上大神的链接，再次膜拜。此篇文章有些例子参考的大神的文章，在此说明。
背景
这篇文章是继续上一篇左值右值的文章，上一篇文章主要说明了左值右值使用可以带来的的算力优化。
这一篇，重点则是，如何将左值右值在实际项目中使用起来。
C++ 传值的方式默认是拷贝，而且临时变量拷贝的算力开销很大，在此背景下，诞生了左值和右值的概念，就是为了避免临时变量的拷贝开销。
举个例子：
function("some temporary value"); // 直接传入string，可能有string的复制产生
v.push_back(F()); // 初始化了一个临时变量F，并将其复制给了v
a = b + c; // 临时变量b+c，然后复制给了a
i++; // 如此操作也有临时变量的产生
上述的临时变量都称为右值，从其中选一个好理解的例子来说，a=b+c，电脑在处理这一句话的时候，会先将b+c计算出来，形成一个临时变量放在一个寄存器中，然后在将寄存器中的数值拷贝给a。
这样就产生了一个问题，上述的copy操作是不是有必要的呢？可以省略这一步吗？
再看下面的代码：
class A{
public:
void set(const string& v1, const string& v2) {
v_a1 = v1; // copy
v_a2 = v2; // copy
}
private:
string v_a1;
string v_a2;
}
上述是一个类，将外部初始的string传递给类内部的string，如果按照下面的方法使用类A，
A a;
string value1("tmp value1");
string value2("tmp value2");
a.set(value1,value2); // copy
这种方式是没有办法避免copy的，因为无论如何都必须要将外部的string 传递给set函数，然后再将其复制给类的私有成员变量。
再看看下面一种方式，
A a;
a.set("tmp value1","tmp value2");
上面这种方式，在汇编层面的操作有可能是这样的：
- 内存上划出一块内存，用以存储两个string，作为临时变量
- 临时变量的内容先被复制一遍(这里我的理解是，拷贝到CPU中的相关寄存器中)
- 然后将复制的内容覆盖到变量a的内存空间
- 临时变量的任务完成后，相应的资源被回收
如果，临时变量内容和成员变量内容能够互换以下，是不是就可以优化复制所需的这部分资源。如下：
- 成员变量内部指针指向临时变量"tmp value1","tmp value2"所在的内存
- 临时变量内部指针指向成员变量以前所指向的内存
- 最后临时变量所指向的内存再被释放
这种操作避免了一次copy，这就是move的含义。
在C++ 11 之前，临时变量的这个坑是必须踩的，为了解决这个问题，所以提出了左值和右值的概念，右值就是上述的临时变量，避免copy的操作方式就是std::move。
由于有了左值和右值的概念，之前的例子，在没法避免copy的时候，就可以用const T& 将变量传进set函数里面(T&就是左值引用)，例子如下：
class A{
public:
void set(const string& v1, const string& v2) {
v_a1 = v1; // copy
v_a2 = v2; // copy
}
private:
string v_a1;
string v_a2;
}
A a;
string value1("tmp value1");
string value2("tmp value2");
a.set(value1,value2); // copy
传递临时变量的时候，就可以使用右值引用 T&& ，这样就可以接收rvalue(临时变量)，之后再调用std::move就可以避免copy了。
class A{
public:
void set(string&& v1, string&& v2) {
v_a1 = std::move(v1); // copy
v_a2 = std::move(v2); // copy
}
private:
string v_a1;
string v_a2;
}
A a;
a.set("tmp value1","tmp value2"); // no copy
这样又有了新的问题，处理临时变量用右值引用 string &&，处理普通变量就用const string&，那同一个功能每次都需要写两遍，总不能刚填了一个坑，就整来另外一个坑吧，so，perfect forward诞生了。。。。。
看如下代码：
template<typename T1, typename T2>
void set(T1 && var1, T2 && var2){
m_var1 = std::forward<T1>(var1);
m_var2 = std::forward<T2>(var2);
}
右值引用参数的引用折叠
当var1为右值时，std::forward(var1)相当于static_cast<[const] T1 &&>(var1)；
当var1为左值时，std::forward(var1)相当于static_cast<[const] T1 &>(var1)。
模板实参推断和引用
从左值引用函数推断类型，还是先看代码，
template <typename T>
void f1(T& param)
{ }
int i = 10;
const int ci = 3;
f1(i); // i 是一个int，模板参数T是int
f1(ci); // ci 是一个const int，但模板参数T是const int
f1(5); // 错误，传递给一个&参数的实参必须是一个左值
如果这里函数参数的类型是const T&，正常的绑定规则告诉我们可以给它传递任何类型的实参：
- 一个对象（const或非const）；
- 一个字面值。
从右值引用函数推断类型，
template <typename T>
void f2(T&& param)
{
}
f2(5);
f2(std::move(i));
f2(std::move(ci));
当一个函数参数是一个右值引用(即形如T&&)时，正常绑定规则告诉我们可以传递给它一个右值。然而假设我们用
f2(i)
这样看起来不合法的行为，我们不能将一个右值引用绑定在左值上，但是实际上确实可行的，因为C++提供了一条这样的规则：
当我们将一个左值传递给一个传递给函数的右值引用参数，且此右值引用指向模板类型参数时(T&&)时，编译器会推断模板类型 类型参数为实参的左值引用类型(T&）。
所以，此时模板会自动推断T为int&。
右值引用折叠规则如下：
- X& &， X& && 和 X&& & 都折叠成类型X&；
- 类型X&& && 折叠成X&&。
这样就意味着，我们可以将任意类型的实参传递给T&& 类型的函数参数。
template <typename T>
void f3(T&& param)
{ }
f3(3); // T 是int
f3(i); // T 是int&
f3(ci); // T 是const int&
std::move
template <typename T>
typename remove_reference<T>::type&& move(T&& t)
{
return static_cast<remove_reference<T>::type&&>(t);
}
static_cast 可以显示的将一个左值转换为一个右值引用。
首先，move的函数参数是T&&，通过引用折叠，此参数可与任何类型的实参匹配。
std::string s1("hi");
s2 = std::move(std::string("bye"));
s2 = std::move(s1);
以 std::move(std::string(“bye”))为例，具体实现过程如下：
- 推断出 T 的类型为string
- remove_reference的type成员是 string
- static_cast
以 std::move(s1)为例：
- 推断出 T 的类型为string &（引用折叠）
- remove_reference
- static_cast
std::forward
某些函数需要将一个或多个实参连同类型不变地转发给其他函数。在此情况下，我们需要保持被转发实参的所有性质：
- 包括实参类型是否是const
- 实参是左值还是右值
template <typename F, typename T1, typename T2>
void flip1(F f, T1 t1, T2 t2) {
f(t1, t2);
}
void f(int t1, int& t2) {
cout << t1 << " " << ++t2 << endl; // v2是引用，这里需要改变v2的值
}
int j = 20;
flip1(f, 42, j); // 42 21
cout << j << endl; // 20
这个flip1(f, 42, j)调用推断为：T1 为 int，T2 为int，F为void (*fcn)(int t1, int& t2)，在这一步中j的值被拷贝到t2中，f中的引用参数被绑定到t2，而非j，从而其改变不会影响j。
所以我们能想到的是：我们需要重写函数，使其参数能够保持给定实参的"左值性"，进一步，也希望能保持参数的const属性。
template <typename F, typename T1, typename T2>
void flip2(F f, T1 &&t1, T2 &&t2) {
f(t1, t2);
}
void f(int t1, int &t2) {
cout << t1 << " " << ++t2 << endl; // t2是引用，这里会改变t2的值
}
int j = 20;
flip1(f, 42, j);
cout << j << endl; // 21
这里flip2(f, 42, j)的调用推断为：T1为int，t1类型为int&&，T2为int&，t2 的类型会折叠为int&，F为void (*fcn)(int t1, int& t2)。
可以看出来，这个版本的 flip2 解决了一些问题，但现在：
template <typename F, typename T1, typename T2>
void flip2(F g, T1 &&t1, T2 &&t2) {
g(t1, t2);
}
void g(int &&i, int &j) {
cout << i << " " << j << endl;
}
int i = 20;
flip2(g, 42, i); // 错误
这里flip2(g, 42, i)的调用推断为：T1为int，t1的类型为int&&，T2为int&，t2 类型折叠后为int&，F为void (*fcn)(int &&i, int &j)。但是函数参数与任何变量一样，都是左值，所以这里要报错。
这时，我们可以用std::forward来传递参数，它能保持原始实参的类型。
template <typename F, typename T1, typename T2>
void flip2(F g, T1 &&t1, T2 &&t2)
{
g(std::forward<T1>(t1), std::forward<T2>t2);
}
forward 实现原理
template <typename T>
T&& forward(typename std::remove_reference<T>::type& param)
{
return static_cast<T&&>(param);
}
template <typename T>
T&& forward(typename std::remove_reference<T>::type&& param)
{
return static_cast<T&&>(param);
}
理解std::move之后就差不多能理解std::forward。
对比
template <typename T>
void print(T &t)
{
std::cout << "左值" << std::endl;
}
template <typename T>
void print(T &&t)
{
std::cout << "右值" << std::endl;
}
template <typename T>
void testForward(T &&v)
{
print(v);
print(std::forward<T>(v));
print(std::move(v));
}
int main()
{
testForward(1);
std::cout << "======================" << std::endl;
int x = 1;
testForward(x);
}
变量是左值，所以第一个prin(v)会调用第一个函数
std::move 会始终调用第二个函数。
对于1，推断T为int，v为int&&，保持原属性，右值。
对于x，推断T为int&，引用折叠v为int&，保持原属性，左值。