[c++基础]拷贝构造函数和重载运算符

1.如果你的类包含需要深拷贝的资源（如动态分配的内存、文件句柄、网络连接等），你就可能需要自定义赋值运算符来管理资源，以避免浅拷贝带来的问题（比如多次释放同一块内存）。

然而，如果你的类包含需要深拷贝的资源（如动态分配的内存、文件句柄、网络连接等），你就可能需要自定义赋值运算符来管理资源，以避免浅拷贝带来的问题（比如多次释放同一块内存）。

假设我们有一个类管理动态分配的数组：

动态分配的数组是在程序运行时根据需要动态分配内存空间的数组。在 C++ 中，动态分配数组通常使用 new 和 delete 运算符来实现。

• 静态分配的数组：在编译时就确定了数组的大小，例如

  int staticArray[10]; // 定义了一个包含 10 个整数的静态数组

• 动态分配的数组：在运行时根据需要分配数组的大小，例如：

  int* dynamicArray = new int[10]; 

class MyArray {
private:
    int* data;
    size_t size;

public:
    MyArray(size_t s) : size(s), data(new int[s]) {}
    
    // 复制构造函数
    MyArray(const MyArray& other) : size(other.size), data(new int[other.size]) {
        std::copy(other.data, other.data + other.size, data);
    }
    
    // 自定义赋值运算符
    MyArray& operator=(const MyArray& other) {
        if (this == &other) {
            return *this; // 防止自我赋值
        }

        delete[] data; // 释放旧的内存

        size = other.size;
        data = new int[other.size];
        std::copy(other.data, other.data + other.size, data);

        return *this;
    }

    ~MyArray() {
        delete[] data;
    }
};

 

用例，怎么用运算符和拷贝构造函数的区别。

#include <iostream>
#include <algorithm> // for std::copy

class MyArray {
private:
    int* data;
    size_t size;

public:
    // 构造函数
    MyArray(size_t s) : size(s), data(new int[s]) {
        std::cout << "Constructing MyArray of size " << size << std::endl;
    }
    
    // 复制构造函数
    MyArray(const MyArray& other) : size(other.size), data(new int[other.size]) {
        std::copy(other.data, other.data + other.size, data);
        std::cout << "Copy constructing MyArray of size " << size << std::endl;
    }
    
    // 自定义赋值运算符
    MyArray& operator=(const MyArray& other) {
        if (this == &other) {
            return *this; // 防止自我赋值
        }

        delete[] data; // 释放旧的内存

        size = other.size;
        data = new int[other.size];
        std::copy(other.data, other.data + other.size, data);

        std::cout << "Assigning MyArray of size " << size << std::endl;

        return *this;
    }

    // 析构函数
    ~MyArray() {
        delete[] data;
        std::cout << "Destructing MyArray of size " << size << std::endl;
    }

    // 获取大小
    size_t getSize() const {
        return size;
    }

    // 访问数组元素
    int& operator[](size_t index) {
        return data[index];
    }

    const int& operator[](size_t index) const {
        return data[index];
    }
};

int main() {
    // 创建一个大小为5的MyArray对象
    MyArray array1(5);
    for (size_t i = 0; i < array1.getSize(); ++i) {
        array1[i] = static_cast<int>(i) * 10; // 设置值
    }

    // 使用复制构造函数创建array2
    MyArray array2 = array1;

    // 打印array2的内容
    for (size_t i = 0; i < array2.getSize(); ++i) {
        std::cout << "array2[" << i << "] = " << array2[i] << std::endl;
    }

    // 创建另一个大小为3的MyArray对象
    MyArray array3(3);

    // 使用赋值运算符将array1的内容赋给array3
    array3 = array1;

    // 打印array3的内容
    for (size_t i = 0; i < array3.getSize(); ++i) {
        std::cout << "array3[" << i << "] = " << array3[i] << std::endl;
    }

    return 0;
}