C++ 拷贝构造函数，拷贝赋值运算符，移动构造函数，移动赋值运算符示例分析

作为C++新人，常常不明白上述四种C++函数/运算符的意义及分别在什么情况下会执行对应的函数/运算符。

拷贝构造函数(Copy constructor)：由已有的类拷贝创建一个新类，调用该构造函数。

        函数参数为：class-name&  (左值引用)，其中 class-name 是为其定义构造函数的类的名称。

class Window
{
    public:
    Window(const Window& a){
    }
    // ...
};

拷贝赋值运算符(Copy assignment operator)：将已创建的类赋值给一个新类，调用该构造函数。

        该运算符的参数为：class-name&  (左值引用)，其中 class-name 是为其定义构造函数的类的名称。注意这里的参数是引用，我想了下，如果不是引用的话，应该会引发无限循环问题。

class Window{
    public:    
    void operator=(const Window& a) {
    }
    //...
}

移动构造函数(Move constructor)：用std::move（右值引用）的方式创建一个新类，调用该构造函数。

        该函数的参数为：class-name&&  (右值引用) ，其中 class-name 是为其定义构造函数的类的名称。

class Window
{
    public:
    Window(const Window&& a) {
    }
    // ...
};

移动赋值运算符(Move assignment operator)：用std::move（右值引用）的方式将已创建的类赋值给一个新类，调用该构造函数。

        该运算符的参数为：class-name&&  (右值引用) ，其中 class-name 是为其定义构造函数的类的名称。

class Window
{
    public:
    void operator=(const Window&& a) {
    }
    // ...
};

上述函数及运算符尽可能创建该类型的参数为 const类型，这可防止复制构造函数意外更改从中复制它的对象。 

示例代码：

#include <iostream>
#include <memory>
#include <vector>
#include <string>
using namespace std;
 
class RValue {
    public:
    //简单初始化的构造函数
    RValue():sources("hello!!!"){
            cout<<"constructor---> " << "init string"<<endl;    
    }
 
    //拷贝构造函数
    RValue(const RValue& a) {
        sources = a.sources;
        cout<< "Copy constructor---> "<< "& RValue"<<endl;
    }
        
    //拷贝赋值运算符
    void operator=(const RValue& a) {
        sources = a.sources;
        cout<< "Copy assignment operator---> " <<"& =="<<endl;
    }
        
    //移动构造函数    
    RValue(RValue&& a) {
        sources = std::move(a.sources);
        cout<< "Move constructor---> " <<"&& RValue"<<endl;
    }
 
    //移动赋值运算符
    void operator=(const RValue&& a) {
        sources = std::move(a.sources);
        cout<< "Move assignment operator---> " << "&& =="<<endl;
    }
 
    string sources;;
};
 
RValue get() {
        RValue a;
    return a;
}
 
void put(RValue){}
 
int main() {
    //constructor
    RValue a, b;    
    cout<<"a.sources:"<<a.sources<<endl;
    cout<<"b.sources:"<<a.sources<<endl;
    
    //Copy constructor
    RValue b1(b);            // method 1
    cout<<"b.sources:"<<b.sources<<endl;
    cout<<"b1.sources:"<<b1.sources<<endl;
    RValue c = b1;        // method 2
    cout<<"c.sources:"<<c.sources<<endl;
    cout<<"b1.sources:"<<b1.sources<<endl;    
    
    //Copy assignment operator
    RValue d;    
    d = c;
    cout<<"d.sources:"<<d.sources<<endl;    
        
    //Move constructor        
    RValue a1 = std::move(a);     // method 1
    cout<<"a.sources:"<<a.sources<<endl;
    cout<<"a1.sources:"<<a1.sources<<endl;     
    RValue a2(std::move(b))    ;        // method 2
    cout<<"a.sources:"<<b.sources<<endl;
    cout<<"a2.sources:"<<a2.sources<<endl;
 
    //Move assignment operator
    RValue e;    
    e = std::move(d);
    cout<<"d.sources:"<<d.sources<<endl;    
    cout<<"e.sources:"<<e.sources<<endl;    
    return 0;
}

执行结果如下：

constructor---> init string
constructor---> init string
a.sources:hello!!!
b.sources:hello!!!
Copy constructor---> & RValue
b.sources:hello!!!
b1.sources:hello!!!
Copy constructor---> & RValue
c.sources:hello!!!
b1.sources:hello!!!
constructor---> init string
Copy assignment operator---> & ==
d.sources:hello!!!
Move constructor---> && RValue
a.sources:
a1.sources:hello!!!
Move constructor---> && RValue
a.sources:
a2.sources:hello!!!
constructor---> init string
Move assignment operator---> && ==
d.sources:hello!!!
e.sources:hello!!!