第14课 移动语义(std::move)

 template<typename T>
 decltype(auto) move(T&& param)  //注意，形参是个引用（万能引用）
{
        using ReturnType = typename remove_reference<T>::type&&; //去除T自身可能携带的引用
        return static_cast<ReturnType>(param); //强制转换为右值引用类型
}

①Object(T&);       //复制构造，仅接受左值
②Object(const T&); //复制构造，即可以接受左值又可接收右值
③Object(T&&) noexcept; //移动构造，仅接受右值
④T& operator=(const T&);//复制赋值函数，即可以接受左值又可接收右值
⑤T& operator=(T&&); //移动赋值函数，仅接受右值

#include <iostream>
#include <vector>

using namespace std;

//1. 移动语义
class HugeMem
{
public:
    int* buff;
    int size;

    HugeMem(int size) : size(size > 0 ? size : 1)
    {
        buff = new int[size];
    }

    //移动构造函数
    HugeMem(HugeMem&& hm) noexcept : size(hm.size), buff(hm.buff)
    {
        hm.buff = nullptr;
    }

    ~HugeMem() { 
        delete[] buff;
    }
};

class Moveable
{
public:
    HugeMem h;
    int* i;
public:
    Moveable() : i(new int(3)), h(1024){}

    //移动构造函数（强制转为右值，以调用h的移动构造函数。注意m虽然是右值
    //引用，但形参是具名变量，m是个左值。因此m.h也是左值，需转为右值。
    Moveable(Moveable&& m) noexcept: i(m.i), h(std::move(m).h)
    {
        m.i = nullptr;
    }

    ~Moveable() { delete i; }
};

Moveable GetTemp()
{
    Moveable tmp = Moveable();

    cout << hex << "Huge mem from " << __func__
        << " @" << tmp.h.buff << endl;

    return tmp;
}

//2. 对常量对象实施移动将变成复制操作
class Annotation
{
    std::string value;
public:

    //注意：对常量的text对象实施移动操作时，由于std::move(text)返回的结果是个
    //const std::string对象，由于带const，不能匹配string(&& rhs)移动构造函数，
    //但匹配string(const string& rhs)复制构造函数，因此当执行value(std::move(text))
    //时，实际上是将text复制给value。对于非string类型的情况也一样，因此对常量对象的
    //移动操作实际上会变成复制操作！
    explicit Annotation(const std::string text) : value(std::move(text))
    {
    }
};

//3. 利用移动语义实现高性能的swap函数
template<typename T>
void Swap(T& a, T& b) noexcept  //声明为noexcept以便在交换失败时，终止程序
{
    //如果a、b是可移动的，则直接转移资源的所有权
    //如果是不可移动的，则通过复制来交换两个对象。
    T tmp(std::move(a)); //先把a的资源转交给tmp
    a = std::move(b);
    b = std::move(tmp);
}

int main()
{
    //1. 移动语义
    Moveable a(GetTemp()); //移动构造

    cout << hex << "Huge mem from " << __func__
        << " @" << a.h.buff << endl;

    return 0;
}
/*输出结果
Huge mem from GetTemp @02C66248 （从中可以看出Huge mem从临时对象移动了a对象）
Huge mem from main @02C66248
*/

#include <iostream>
#include <chrono>
#include <vector>
#include <array>
#include <thread>

using namespace std;

//1. 移动不存在时，实行的是复制操作
class Foo
{
public:
    Foo(){}
    Foo(const Foo&)
    {
        cout <<"Foo(const Foo&)" << endl;
    }
};

//2. 移动速度未必比复制快
//2.1 辅助类（元素类）
class Widget
{
public:
    Widget() = default;
    Widget(const Widget&) {
        //模拟复制操作，假设需要1毫秒
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
    Widget(Widget&&) {
        //模拟移动操作，假设需要2毫秒
        std::this_thread::sleep_for(std::chrono::milliseconds(2));
    }

    Widget& operator=(const Widget&) {
        //模拟复制赋值操作，假设需要1毫秒
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
        return *this;
    }
    Widget& operator=(Widget&&) {
        //模拟移动赋值操作，假设需要2毫秒
        std::this_thread::sleep_for(std::chrono::milliseconds(2));
        return *this;
    }
};

//2.2. 计算任意函数的执行时间：auto&&用于lambda表达式形参（C++14）
auto funcTimer = [](auto&& func, auto&& ... params)
{
    //计时器启动
    std::chrono::system_clock::time_point t1 = std::chrono::system_clock::now();

    //调用func(param...)函数
    std::forward<decltype(func)>(func)(           //根据func的左右值特性来调用相应的重载&或&&版本的成员函数
        std::forward<decltype(params)>(params)... //保持参数的左/右值特性
        );

    std::chrono::system_clock::time_point t2 = std::chrono::system_clock::now();
    long long elapsed = std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count();
    cout << elapsed << " microseconds" << endl;
};
//2.3 复制和移动操作
auto lamMove = [](auto&& src) {
    auto dest = std::move(src);
    return;
};

auto lamCopy = [](auto&& src) {
    auto dest = src;
    return;
};

//2.4 测试vector类
void testVector()
{
    std::vector<Widget> vw1{ 10,Widget() };

    cout <<"copy vector: " ;
    funcTimer(lamCopy, vw1);

    //测试移动操作用时
    cout << "move vector: ";
    funcTimer(lamMove, vw1);
}

//2.5 测试array类
void testArray()
{
    std::array<Widget, 10> aw1;

    cout << "copy array: ";
    funcTimer(lamCopy, aw1);

    //测试移动操作用时
    cout << "move array: ";
    funcTimer(lamMove, aw1);
}

//3. move_if_noexcept的用法
struct Maythrow
{
    Maythrow() {}

    Maythrow(const Maythrow&) {
        cout <<"Maythrow copy construct." << endl;
    }

    Maythrow(Maythrow&&) {
        cout << "Maythrow move construct." << endl;
    }
};

struct Nothrow
{
    Nothrow() {}

    Nothrow(const Nothrow&) {
        cout << "Nothrow copy construct." << endl;
    }

    Nothrow(Nothrow&&) noexcept {  //注意，这里声明为noexcept!
        cout << "Nothrow move construct." << endl;
    }
};
int main()
{
    //1. 移动操作不存在时
    Foo f1;
    Foo f2 = std::move(f1); //调用复制构造函数

    //2. 移动速度未必比复制快
    testVector();
    testArray();

    //3. 移动未声明为noexcept时，调用复制构造
    Maythrow m;
    Nothrow  n;

    Maythrow mt = move_if_noexcept(m); //move_if_noexcept返回左值引用，调用复制构造函数
    Nothrow  nt = move_if_noexcept(n); //move_if_noexcept返回右值引用，调用移动构造函数

    return 0;
}
/*输出结果
Foo(const Foo&)
copy vector: 19825 microseconds
move vector: 5 microseconds     //常量时间
copy array: 19109 microseconds
move array: 29589 microseconds  //移动的速度未必比复制快！取决于Widget的移动和复制速度的比较！
Maythrow copy construct. //调用复制构造函数
Nothrow move construct.  //调用移动构造函数
*/