c++11之move语义

#include <iostream>
using namespace std;

class HasPtrMem
{
public:
    HasPtrMem()
        : d(new int)
    {
        cout << "HasPtrMem::Construct: " << ++n_cstr << endl;
    }
    HasPtrMem(const HasPtrMem &h)
        : d(new int(*h.d))
    {
        cout << "HasPtrMem::Copy construct: " << ++n_cptr << endl;
    }
    HasPtrMem(HasPtrMem &&h)
        : d(h.d)
    {  
        h.d = nullptr;                  
        cout << "HasPtrMem::Move construct: " << ++n_mvtr << endl;
    }
    ~HasPtrMem()
    {
        delete d;
        cout << "HasPtrMem::Destruct: " << ++n_dstr << endl;
    }
    int *d;
    static int n_cstr;
    static int n_dstr;
    static int n_cptr;
    static int n_mvtr;
};

int HasPtrMem::n_cstr = 0;

int HasPtrMem::n_dstr = 0;

int HasPtrMem::n_cptr = 0;

int HasPtrMem::n_mvtr = 0;

HasPtrMem GetTemp()
{
    HasPtrMem h;
    return h;
}

int main(int argc, char **argv)
{
    HasPtrMem a = GetTemp();
    return 0;
}

执行编译 g++ movecopy.cpp -o movecopy -fno-elide-constructors -std=c++11

一定要加-fno-elide-constructors这个参数关闭编译器进行rvo优化点击打开链接，否则看不到效果。

    我们可以看到在没有rvo优化的前提下一个操作进行了三次构造，其中有两次copy构造，一次是在GetHasPtrMem函数返回时，还有一次是在main函数中给temp赋值时，相对应析构函数被调用了三次，在这里我们的指针只是一个int型的指针，其占用的堆内存很小，但是当我们的指针指向的内存很大时，拷贝构造的过程会是一个相当耗费cpu的一个操作，最重要的是copy构造过程中产生的临时变量堆编程者来说并不可见，所说不是什么错误，但是会影响程序的整体性能。

    那么我们可不可以不构造呢，避免不必要的申请和释放堆内存呢，既然临时变量的内存在copy构造后会被释放掉，为什么我们不利用这块内存去构造对象呢。这就是我们要说的move构造。我们把代码中的注释打开，用g++ movecopy.cpp -o movecopy -fno-elide-constructors -std=c++11编译指令编译后运行。

    

    这次我们可以看到，copy构造换成了move构造，接着我们看我们在move构造函数中做了什么，我们知识把构造函数参数的指针付给了我们要构造的对象，然后把参数的指针置为null，这样我们就把参数的内存偷过来变成了自己的内存，这样就避免了大量无谓的内存申请和释放。

    最后说到std::move函数的作用，它的作用是把一个左值强制转换成一个右值引用（关于左值引用和右值引用：点击打开链接），以便用来move语义，此时被转换成右值引用的左值生命周期并没有因此而改变，为了说明问题看下面的例子。

#include<iostream>
using namespace std;
class HasPtrMem
{
public:
    HasPtrMem(int _size)
        : size(_size), m_ptInt(new int[_size])
    {}
    HasPtrMem(const HasPtrMem &temp)
        : m_ptInt(new int[*(temp.m_ptInt)])
    { std::cout << "HasPtrMem Copy " << std::endl; }
    HasPtrMem(HasPtrMem &&temp)
        : m_ptInt(temp.m_ptInt), size(temp.size)
    {
        std::cout << "HasPtrMem Move " << std::endl;
        temp.m_ptInt = nullptr;
    }
    ~HasPtrMem()
    {
        delete[] m_ptInt;
    }
public:
    int *m_ptInt;
    int size;
};

class Movebale
{
public:
    Movebale()
        : i(new int), a(1024)
    {}
    ~Movebale()
    { delete i; }
    Movebale(Movebale &&m)
        : i(m.i), a(move(m.a)) //注释1:i (m.i),a(m.a)
    {
        m.i = nullptr;
    }
    int *i;
    HasPtrMem a;
};

Movebale GetTemp()
{
    Movebale temp;
    std::cout << hex << "HasPtrMem Mem from " << __func__ << ":" << temp.a.m_ptInt << std::endl;
    return std::move(temp);
}
int main()
{
    Movebale a = GetTemp();
    std::cout << hex << "HasPtrMem Mem from " << __func__ << ":" << a.a.m_ptInt << std::endl;
    // Movebale c(move(a));
    // auto d = *(a.i);
    return 0;
}

执行编译 g++ movecopy.cpp -o movecopy -fno-elide-constructors -std=c++11

注意注释1处的代码，下面我们看有move(左)和无move(右,注释掉HasPtrMem的move构造函数重新编译运行)的运行结果

                   

    这里我们可以看到move的作用，他把左值转换为右值引用，从而调用move构造函数，避免了copy构造函数的调用。最后要注意main函数中的注释代码会崩溃，因为在move构造函数中我们把指针变量置为null，因此我们一定要确保变量不再使用再调用move函数转换。所以我们在写move构造函数是尽量对自定义的类型使用move进行转换，如果该类型也支持move构造函数调用该类型的move构造函数提高性能，即使没有也会调用相应的copy构造函数。

    说到rvo优化，如果我们允许编译器进行rvo优化，那么我们上面的代码,我们将看不到任何的copy构造和移动构造，只会进行一次构造函数，因为编译器的优化这些过程被优化掉了。但是虽然在这里即使我们不适用move构造函数也会避免的额外的copy消耗，但是编译器的优化不是在任何地方都会有效，move语义可以弥补编译器优化的不足之处，我们可以用来优化编译器优化不到的地方。      ｀

  不过我们调用move函数的时候并不是一定会调用move构造函数，如果我们给move函数传入一个左值引用类型还是会调用其copy构造函数，这是由于引用折叠造成的， 引用折叠规则：
 X& + & => X&
 X&& + & => X&
 X& + && => X&
 X&& + && => X&&

标准库move内部原理：

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

  这里的_Tp&& __t 如果我们_Tp是一个左值引用引用折叠的结果导致__t最终变成了左值引用，最终调用了copy构造函数。