C++ 移动构造和拷贝构造示例

默认构造：调用默认构造函数，老老实实构建实例
拷贝构造：在默认构造基础上，复制其他类的数据
移动语义：特定环节可省略一些步骤，如内存申请，直接将其他类数据拿来就用，并初始化其他类

#include <algorithm>
#include <iostream>

class X
{
private:
  int* data = nullptr;

public:
  X():
    data(new int[1000000])
  {

    std::cout << "new!" << data << std::endl;
}

  ~X()
  {
    std::cout << "delete!" << data << std::endl;
    delete [] data;
  }

  X(const X& other):  // 1 copy
   data(new int[1000000])
  {
    std::cout << "new->copy!" << data << std::endl;
    std::copy(other.data,other.data+1000000,data);
  }

  X(X&& other):  // 2 move
    data(other.data)
  {
    std::cout << "move!" << data << std::endl;
    other.data=nullptr;
  }
};

int main(){
    X x1; // new

    X x2(x1);  // new->copy
    X x3 = std::move(x1); // move

    X x4 = static_cast<X&&>(x2); // move
}

output:

[root@jn cpp]# ./a.out
new!0x7fb78f00f010
new->copy!0x7fb78ec3e010
move!0x7fb78f00f010
move!0x7fb78ec3e010
delete!0x7fb78ec3e010
delete!0x7fb78f00f010
delete!0
delete!0
[root@jn cpp]#

通常实现任意一个，其他两个都要实现：拷贝构造函数、拷贝赋值操作符和析构函数。

class ResourceHolder {
private:
    char* data;
public:
    ResourceHolder(const char* pData) {
        data = new char[strlen(pData) + 1];
        strcpy(data, pData);
    }

    ~ResourceHolder() {
        delete[] data;
    }

    ResourceHolder(const ResourceHolder& other) {
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }

    ResourceHolder& operator=(const ResourceHolder& other) {
        if (this == &other) return *this;
        delete[] data;
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
        return *this;
    }
};

以及常说的三个构造，两个赋值，一个析构示例

#include <iostream>

class MyClass {
public:
    // 默认构造函数
    MyClass() {
        std::cout << "Default Constructor" << std::endl;
    }

    // 参数化构造函数
    MyClass(int value) {
        std::cout << "Parameterized Constructor with value " << value << std::endl;
    }

    // 拷贝构造函数
    MyClass(const MyClass& other) {
        std::cout << "Copy Constructor" << std::endl;
    }

    // 拷贝赋值运算符重载
    MyClass& operator=(const MyClass& other) {
        std::cout << "Copy Assignment Operator" << std::endl;
        return *this;
    }

    // 移动赋值运算符重载
    MyClass& operator=(MyClass&& other) {
        std::cout << "Move Assignment Operator" << std::endl;
        return *this;
    }

    // 析构函数
    ~MyClass() {
        std::cout << "Destructor" << std::endl;
    }
};

int main() {
    MyClass obj1; // 默认构造函数
    MyClass obj2(42); // 参数化构造函数
    MyClass obj3 = obj1; // 拷贝构造函数
    MyClass obj4;
    obj4 = obj1; // 拷贝赋值运算符重载
    MyClass obj5;
    obj5 = std::move(obj1); // 移动赋值运算符重载

    return 0;
}