c++深浅拷贝之谜

sun_chuan

在C++中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是两种不同的对象拷贝方式。

浅拷贝是指将一个对象的值复制到另一个对象，包括对象中的数据成员。这样，原始对象和副本对象将共享相同的内存地址。当一个对象被修改时，另一个对象也会受到影响。这可能导致意外的行为和错误。

深拷贝是指完全复制一个对象，包括对象中的数据成员和指向动态分配内存的指针。深拷贝会创建一个新的对象，并为其分配独立的内存空间。这意味着修改一个对象不会影响另一个对象，它们之间是相互独立的。

为了实现深拷贝，通常需要自定义拷贝构造函数和赋值运算符重载函数，来确保所有的数据成员都得到适当地复制，包括动态分配内存的指针。

注意：

浅拷贝只复制对象的值，副本和原始对象共享内存地址，修改一个对象会影响另一个对象。
深拷贝完全复制对象，包括动态分配内存的指针，副本和原始对象是相互独立的，修改一个对象不会影响另一个对象。
选择深拷贝还是浅拷贝取决于具体的需求和对象的结构。对于包含动态分配内存的指针或资源管理的对象，通常需要使用深拷贝来确保数据的独立性和正确性。

例子:

#include <iostream>

class Array {
private:
    int size;
    int* data;

public:
    Array(int s) : size(s), data(new int[size]) {
        for (int i = 0; i < size; i++) {
            data[i] = i;
        }
    }

    // 拷贝构造函数
    Array(const Array& other) : size(other.size), data(new int[other.size]) {
        for (int i = 0; i < size; i++) {
            data[i] = other.data[i];
        }
    }

    // 赋值运算符重载
    Array& operator=(const Array& other) {
        if (this == &other) {
            return *this;
        }

        delete[] data;
        size = other.size;
        data = new int[size];
        for (int i = 0; i < size; i++) {
            data[i] = other.data[i];
        }

        return *this;
    }

    ~Array() {
        delete[] data;
    }

    void print() {
        for (int i = 0; i < size; i++) {
            std::cout << data[i] << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    Array arr1(5);
    Array arr2 = arr1; // 浅拷贝
    arr1.print(); // 输出：0 1 2 3 4
    arr2.print(); // 输出：0 1 2 3 4

    arr1.print(); // 输出：0 1 2 3 4
    arr2.print(); // 输出：0 1 2 3 4

    // 修改 arr2 的第一个元素
    arr2[0] = 10;

    arr1.print(); // 输出：0 1 2 3 4
    arr2.print(); // 输出：10 1 2 3 4

    return 0;
}
在上面的例子中，我们定义了一个 Array 类来表示动态分配内存的数组。它包含一个指向动态分配内存的指针 data 和一个表示数组大小的变量 size。

在拷贝构造函数和赋值运算符重载函数中，我们实现了深拷贝。它们都会创建一个新的数组，并将原始数组的元素复制到新数组中。这样，每个对象都有自己独立的内存空间，修改其中一个对象不会影响另一个对象。

在 main 函数中，我们创建了两个数组 arr1 和 arr2，并使用 arr1 对象进行初始化 arr2，这是浅拷贝的方式。当我们修改 arr2 中的第一个元素时，arr1 中的对应元素也会被修改，这说明它们共享相同的内存地址。

为了避免这种问题，我们需要实现深拷贝，确保每个对象都有自己独立的内存空间，从而实现数据的独立性和正确性。