C++移动构造

写个Demo测试一下C++移动构造的效果（对于节省空间、提高效果很有用），使用了std::move和std::forward。

 

#include <iostream>
#include <string.h>

class myString
{
public:
    //单参构造函数
    myString(const char* data = NULL);
    //析构函数
    ~myString();
    //拷贝构造
    myString(const myString& other);
    //赋值操作符
    myString& operator=(const myString& other);
    //移动构造
    myString(myString&& other);

private:
    char* m_data;
};

myString::myString(const char* data)
{
    if (NULL == data)
    {
        m_data = new char[1];
        m_data[0] = '\0';
    }
    else
    {
        int len = strlen(data);
        m_data = new char[len + 1];
        strcpy(m_data, data);
        m_data[len] = '\0';
    }
    std::cout << "myString construct " << m_data << std::endl;
}

myString::~myString()
{
    
    if (m_data)
    {
        std::cout << "myString destruct " << m_data << std::endl;
        delete[]m_data;
        m_data = NULL;
    }
    else
    {
        std::cout << "myString move destruct " << std::endl;
    }
    
}
myString::myString(const myString& other)
{
    int len = strlen(other.m_data);
    m_data = new char[len + 1];
    strcpy(m_data, other.m_data);
    m_data[len] = '\0';
    std::cout << "myString copy construct " << m_data << std::endl;
}

myString& myString::operator=(const myString& other)
{
    if (this != &other)
    {
        if (m_data)
        {
            delete[]m_data;
            m_data = NULL;
        }
        int len = strlen(other.m_data);
        m_data = new char[len + 1];
        strcpy(m_data, other.m_data);
        m_data[len] = '\0';
    }
    std::cout << "myString operator= " << m_data<< std::endl;
    return *this;
}

myString::myString(myString&& other)
{
    m_data = other.m_data;
    other.m_data = NULL;
    std::cout << "myString move construct" << m_data<< std::endl;
}

void myStringTest()
{
    //单参构造
    myString s1("s1");
    //拷贝构造
    myString s2(s1);
    //单参构造（默认参数为NULL）
    myString s3;
    //赋值操作
    s3 = s1;
    //移动构造，std::move强制转换为右值
    myString s4(std::move(s2));
}

class StringWrap
{
public:
    //右值
    StringWrap(myString&& str);
    //左值
    StringWrap(myString& str);

    myString m_myString;
};

StringWrap::StringWrap(myString&& str)
//完美转移std::forward
    :m_myString(std::forward<myString>(str))
{

}

StringWrap::StringWrap(myString& str)
    : m_myString(str)
{

}

void StringWrapTest()
{
    //测试StringWrap(myString&& str)
    myString s1("string wrap test1");
    StringWrap wrap1(std::move(s1));

    //测试StringWrap(myString& str)
    myString s2("string wrap test2");
    StringWrap wrap2(s2);
}

int main()
{
    myStringTest();
    std::cout << std::endl << std::endl << std::endl;
    StringWrapTest();

    getchar();
    return 0;
}