C++ 移动语义--std::move 实例解析

移动语义--std::move

1. 编译器只对右值引用才能调用转移构造函数和转移赋值函数，而所有命名对象都只能是左值引用，如果已知一个命名对象不再被使用而想对它调用转移构造函数和转移赋值函数，也就是把一个左值引用当做右值引用来使用，怎么做呢？标准库提供了函数 std::move，这个函数以非常简单的方式将左值引用转换为右值引用。
2. 对于右值引用而言，它本身是右值么？ 要看情况。

　　　　　　a. 字符串的定义

　　　　　　b. ArrayWrapper

String.cc

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

class String
{
public:
    String()
    {
        std::cout << “String()” << std::endl;
        pstr_ = new char[1];
        }

        String(const char *pstr)
        {
        std::cout << “String(const char *pstr)” << std::endl;
        pstr_ = new char[strlen(pstr) + 1];
        strcpy(pstr_ , pstr);
        }

        String(const String &rhs)    //复制构造函数
        {
        std::cout << “String(const String &rhs)” << std::endl;
        pstr_ = new char[strlen(rhs.pstr_) + 1];
        strcpy(pstr_, rhs.pstr_);
        }

        String(String &&rhs)   //移动构造函数，移动就意味着修改，所以不加const。当发现是右值时，会优先绑定移动构造函数。
        : pstr_(rhs.pstr_)
        {
        std::cout << “String(String &&rhs)” << std::endl;
        rhs.pstr_ = NULL;
        }

        String &operator=(String &&rhs)    //移动赋值运算符函数        
        {
        std::cout << “String &operator=(String &&rhs)” << std::endl;
        if(this != &rhs)
        {
            delete []pstr_;
            pstr_ = rhs.pstr_;
            rhs.pstr_ = NULL;
            }
            return *this;
        }

        String &operator=(const String &rhs)   //赋值运算符函数
        {
        std::cout << “String &operator=(const String &rhs)” << std::endl;
        if(this != &rhs)
        {
        delete []pstr_;
        pstr_ = new char[strlen(rhs.pstr_) + 1];
        strcpy(pstr_ , rhs.pstr_);
            }
            return *this;
        }

        String & operator += (const String &rhs)
        {
        std::cout << “String & operator+=(const String &rhs) ”  <<std::cout;
        int len = strlen(pstr_) + strlen(rhs.pstr_) + 1;
        char * ptmp = new char[len+1];
        strcpy(ptmp, pstr_);
        strcat(ptmp, rhs.pstr_);

        return *this;
        }

        ~String()
        {
        if(pstr_)
        std::cout << “~String() pstr_ = ” << std::hex << reinte << std::endl;
        else
        std::cout << “~String() pstr_ = NULL”  << std::endl;
        delete []pstr_;
         }

         friend std::ostream &operator<<(std::ostream &os, const String &rhs);
private:
    char *pstr_;
};

String operator + (const String &lhs, const String &rhs)
{
    std::cout << “String operator + (const String &lhs, const String &rhs)” <<std::endl;
    String tmp(lhs);
    tmp += rhs;

    return tmp;
}

String operator+(const String &lhs, const char *rhs)
{
    std::cout << “String operator + (const String &lhs, const char *rhs)” <<std::endl;
    String tmp(rhs);
    tmp += lhs;

    return tmp;
}

String operator+(const char *lhs, const String &rhs)
{
    std::cout << “String operator + (const char *lhs, const String &rhs)” <<std::endl;
    String tmp(lhs);
    tmp += rhs;

    return tmp;
}

std::ostream &operator<<(std::ostream &os, const String &rhs)
{
    os<<rhs.pstr_;
    return os;
}

String getStr()
{
    std::cout << “==========” <<std::endl;
        String s1 = “hello”;
        return s1;
}

int main(void)
{
    String s1 = “hello world”;    //调用有参构造函数, 还会优先调用移动构造函数
    //hello world 通过隐式转换会生成一个String的临时对象，这个临时对象就是一个右值， 右值会优先绑定到右值引用，调用 移动构造函数，而不是去调用 复制构造函数。如果没有 移动构造函数， 就会调用 复制构造函数 ，因为复制构造函数 的参数是 常量左值引用，它可以绑定到所有类型的值，包括 非常量左值、常量左值、右值。

    std::cout << “移动构造函数” << std::endl;
    getStr();
    std::cout << “-------------” << std::endl;

    String s3 = s1 + s2;  // 会调用 构造函数、赋值运算符函数、+=运算符函数 、 移动赋值运算符函数 和 析构函数， 优先调用移动赋值运算符函数的原因是：发生了右值赋值给了左值。

    return 0;
}            

Std_move.cc

#include<iostream>
#include<string>

class MetaData
{
public:
    MetaData(int size, const std::string &name)
        :size_(size), name_(name)
    {
        std::cout << “MetaData(int size, const std::string &name)” <<std::endl;
}

    MetaData(const MetaData &other)
        :name_(other.name_), size_(other.size_)
    {
        std::cout << “MetaData(const MetaData &other)” <<std::endl;
}
    
    MetaData(MetaData &&other)  //移动构造函数 , 不加const
        //: name_(other.name_)   // std::string 的复制构造函数
        : name_(std::move(other.name_)), size_(other.size_)
    {
        std::cout << “MetaData(MetaData &&other)” <<std::endl;
}

std::String getName() const
{
    return name_;
}

int getSize() const
{
    return size_;
}

private:
    std::string name_;
    int size_;
};

class ArrayWrapper
{
public:
    ArrayWrapper()
        : pVals_(new int[64]), metadata_(64, “ArrayWrapper”)
    {
        std::cout << “ArrayWrapper()” << std::endl;
        }

    ArrayWrapper(int n)
        : pVals_(new int[n]), metadata_(n, “ArrayWrapper”)
    {
        std::cout << “ArrayWrapper(int n)” << std::endl;
        }
    
    ArrayWrapper(const ArrayWrapper &other)
        : pVals_(new int[other.metadata_.getSize()]), metadata_(other.metadata_)
    {
        std::cout << “ArrayWrapper(const ArrayWrapper &other)”  << std::endl;
        for(inti dx = 0; idx != other.metadata_.size_; ++idx)
        {
            pVals_[idx] = other.pVals_[idx];
                }
        }

        ArrayWrapper (ArrayWrapper &&other)    //移动构造函数 , 不加const
         : pVals_(other.pVals_), 
//metadata_(other.metadata_)   //other.metadata_本身是一个左值，会调用Metadata类的复制构造函数，与这里的初衷有相违背的地方，外层是移动构造，内层也得是移动构造，这种语义才算正常，要不然不是真正的移动构造语义。所以要换成 移动构造。
             metadata_(std::move(other.metadata_))  //这里会调用Metadata的移动构造函数。
        {
    std::cout << “ArrayWrapper(ArrayWrapper &&other)”  << std::endl;
    other.pVals_ = NULL;
        }

         ~ ArrayWrapper()
        {
        std::cout << “~ArrayWrapper()” << std::endl;
        delete []pVals_;
        }
    
private:
    int *pVals_;
    MetaData metadata_;
};

int main(void)
{
    ArrayWrapper aw1;    
    std::cout << “移动构造函数” << std::endl;
    ArrayWrapper aw2(std::move(aw1));   //使用std::move将aw1变成一个右值应用，传给移动构造函数。

    return 0;
}