C++之完美转发、移动语义（forward、move函数）

完美转发

1. 在函数模板中，可以将 自己的参数“完美”地转发给其它函数。所谓完美，即 不仅能准确地转发参数的值，还能保证被转发参数的左、右值属性不变。
2. C++11标准引入了右值引用和移动语义，所以，能否实现完美转发，决定了该参数在传递过程使用的是拷贝语义(调用拷贝构造函数)还是移动语义 (调用移动构造函数)。

1. 如果模板中 (包括类模板和函数模板)函数的参数书写成为T&& 参数名 那么，函数既可以接受左值引用，又可以接受右值引用。
2. 提供了模板函数std::forward<T>(参数)，用于转发参数如果参数是一个右值，转发之后仍是右值引用;如果 参数是一个左值，转发之后仍是左值引用

move

在我的另一篇文章《C++之右值引用、移动构造函数》提到，左值不能初始化右值引用。

那么我们能不能用左值初始化一个右值引用呢？？这里C++给我们了一个函数move();

move()函数

将左值转换为右值，实现对象资源的转移。

下面看个例子

void test2()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
        v.push_back(i);
    vector<int>vv = v;  //拷贝
    cout << "v  =";
    for (auto x : v)
        cout << x << " ";
    cout << "，  v.addr=" << &v << endl;
    cout << "vv =";
    for (auto x : vv)
        cout << x << " ";
    cout << "， vv.addr=" << &vv << endl;
    cout << "after move v to vvv" << endl;
    vector<int>vvv = move(v);
    cout << "vvv=";
    for (auto x : vvv)
        cout << x << " ";
    cout << "，vvv.addr=" << &vvv << endl;
    cout << "v  =";
    for (auto x : v)
        cout << x << " ";
    cout << "，  v.addr=" << &v << endl;
}

forward

右值引用类型是独立于值的，一个 右值引用作为函数参数的形参时，在函数内部转发该参数给内部其他函数时，它就变成一个左值（因为没有实名的右值被编译器视为左值），并不是原来的类型了。 如果需要按照参数原来的类型转发到另一个函数，可以使用 C++11 提供的 std::forward () 函数，该函数实现的功能称之为 完美转发。

#include<iostream>
using namespace std;
template<typename T>
void PrintT(T& t)
{
    cout << "lvalue" << endl;
}
template<typename T>
void PrintT(T&& t)
{
    cout << "rvalue" << endl;
}
template<typename T>
void TestForward(T&& v)
{
    PrintT(v);
    PrintT(move(v));
    PrintT(forward<T>(v));
    cout << endl;
}
int main()
{
    TestForward(1);
    int x = 1;
    TestForward(x);
    TestForward(forward<int>(x));
    TestForward(forward<int&>(x));
    TestForward(forward<int&&>(x));
    return 0;
}

分析一下
TestForward(1);实参为右值,T&&->右值引用
1. PrintT(v);已经实名的右值编译器当成左值处理,实参->左值
2. PrintT(move(v));move将左值转换为右值,实参->右值
3. PrintT(forward<T>(v));模板参数为右值引用,最终得到一个右值,实参->右值
TestForward(x);实参为左值,T&&->左值引用
1. PrintT(v);实参->左值
2. PrintT(move(v));move将左值转换为右值,实参->右值
3. PrintT(forward<T>(v));模板参数为左值引用,最终得到一个左值,实参->左值
TestForward(forward<int>(x));模板参数类型为int->右值,最终得到右值,T&&->右值引用
1. PrintT(v);已经实名的右值编译器当成左值处理,实参->左值
2. PrintT(move(v));move将左值转换为右值,实参->右值
3. PrintT(forward<T>(v));模板参数为右值引用,最终得到一个右值,实参->右值
TestForward(forward<int&>(x));模板参数类型为左值引用,最终得到一个左值,T&&->左值引用
1. PrintT(v);实参->左值
2. PrintT(move(v));move将左值转换为右值,实参->右值
3. PrintT(forward<T>(v));模板参数类型为左值引用,最终得到一个左值,实参->左值
TestForward(forward<int&&>(x));模板参数类型为右值引用,最终得到一个右值,T&&->右值引用
1. PrintT(v);已经实名的右值编译器当成左值处理,实参->左值
2. PrintT(move(v));move将左值转换为右值,实参->右值
3. PrintT(forward<T>(v));模板参数类型为右值引用,最终得到一个右值,T&&->右值引用

移动语义

如果一个对象中有堆区资源，需要编写拷贝构造函数和赋值函数，实现深拷贝。
深拷贝把对象中的堆区资源复制了一份，如果源对象(被拷贝的对象)是临时对象，拷贝完就没什么用了，这样会造成没有意义的资源申请和释放操作。如果能够 直接使用源对象拥有的资源，可以 节省资源申请和释放的时间。C++11 新增加的移动语义就能够做到这一点。

下面给出示例:

我们当时提到的深浅拷贝，深拷贝解决了浅拷贝造成的内存泄露问题，但是反复的构造和释放对象拉低了程序的效率。所以我们在想是否能直接使用原对象的资源，这样可以大大提高效率

#include<iostream>
using namespace std;
class AA
{
public:
    int* m_data = nullptr;
    AA() = default;
    void alloc()
    {
        m_data = new int;
        memset(m_data, 0, sizeof(int));    //初始化已分配的内存
    }
    AA(const AA& a)    //拷贝构造函数
    {
        cout << "调用了拷贝构造函数" << endl;
        if (m_data == nullptr)    //如果没有分配内存，就分配
            alloc();
        memcpy(m_data, a.m_data, sizeof(int));
    }
    AA(AA&& a)    //移动构造函数
    {
        cout << "调用了移动构造函数" << endl;
        if (m_data != nullptr)    //如果分配内存，释放掉
            delete m_data;
        m_data = a.m_data;
        a.m_data = nullptr;
    }
    AA& operator=(const AA& a)
    {
        cout << "调用了赋值函数" << endl;
        if (this == &a)    //避免自我复制
            return *this;
        if (m_data == nullptr)    //如果没有分配内存，就分配
            alloc();
        memcpy(m_data, a.m_data, sizeof(int));
        return *this;
    }
    AA& operator=(AA&& a)
    {
        cout << "调用了移动赋值函数" << endl;
        if (this == &a)    //避免自我复制
            return *this;
        if (m_data != nullptr)    //如果分配内存，释放掉
            delete m_data;
        m_data = a.m_data;
        a.m_data = nullptr;
        return *this;
    }
    ~AA()
    {
        if (m_data != nullptr)
            delete m_data;
        m_data = nullptr;
    }
};

测试案例1

void test1()
{
    cout << "test1-begin" << endl;
    AA a1;
    a1.alloc();
    *a1.m_data = 3;
    cout << "a1.m_data=" << *a1.m_data << endl;
    AA a2(a1);
    cout << "a2.m_data=" << *a2.m_data << endl;
    AA a3;
    a3 = a1;
    cout << "a3.m_data=" << *a3.m_data << endl;
    cout << "test1-end" << endl << endl;
}

这是一组普通的测试案例，返回结果

注意：

1. 对于一个左值，会调用拷贝构造函数，但是有些左值是局部变量，生命周期也很短，能不能也移动而不是拷贝呢?C++11为了解决这个问题，提供了std:move0方法来将左值转义为右值，从而方便使用移动语义。它其实就是告诉编译器，虽然我是一个左值，但不要对我用拷贝构造函数，用移动构造函数吧。左值对象被转移资源后，不会立刻析构，只有在离开自己的作用域的时候才会析构，如果继续使用左值中的资源，可能会发生意想不到的错误。

2. 如果没有提供移动构造/赋值函数，只提供了拷贝构造/赋值函数，编译器找不到移动构造/赋值函数就去寻找拷贝构造/赋值函数。

3. C++11中的所有容器都实现了移动语义，避免对含有资源的对象发生无谓的拷贝。

4. 移动语义对于拥有资源（如内存，文件句柄）的对象，如果是基本类型，使用移动语义没有意义。

测试案例2

void test2()
{
    cout << "test2-begin" << endl;
    AA a1;
    a1.alloc();
    *a1.m_data = 3;
    AA a6(std::move(a1));
    cout << "a6.m_data=" << *a6.m_data << endl;
    AA a7;
    a7 = std::move(a1);
    cout << "a7.m_data=" << *a7.m_data << endl;
    cout << "test2-end" << endl << endl;
}

返回结果

test2-begin
调用了移动构造函数
a6.m_data=3
调用了移动赋值函数
//程序到这里崩溃了为什么呢？
这里就是因为a1被转移资源后，下面再次对a1进行转移资源导致报错。

测试案例3

void test3()
{
    cout << "test3-begin" << endl;
    auto f = [] {AA aa; aa.alloc(); *aa.m_data = 8; return aa; };
    AA a4 = f();
    cout << "a4.m_data=" << *a4.m_data << endl;
    AA a5;
    a5 = f();
    cout << "a5.m_data=" << *a5.m_data << endl;
    cout << "test3-end" << endl << endl;
}

返回结果

test3-begin
调用了移动构造函数
a4.m_data=8
调用了移动构造函数
调用了移动赋值函数
a5.m_data=8
test3-end