c++中如何实现拷贝构造函数_深拷贝与浅拷贝构造函数实践

class ShallowCopy {
private:
    int* data;
public:
    ShallowCopy(int value) {
        data = new int(value);
    }

    // 编译器生成的默认拷贝构造函数是浅拷贝
    // ShallowCopy(const ShallowCopy& other) {
    //     data = other.data;  // 指针复制，共享同一内存
    // }

    ~ShallowCopy() {
        delete data;
    }
};

// 使用：
ShallowCopy obj1(100);
ShallowCopy obj2 = obj1;  // 浅拷贝 → obj1 和 obj2 的 data 指向同一地址
// 析构时 delete 同一块内存两次 → 错误！

class DeepCopy {
private:
    int* data;
public:
    DeepCopy(int value) {
        data = new int(value);
    }

    // 自定义拷贝构造函数（深拷贝）
    DeepCopy(const DeepCopy& other) {
        data = new int(*other.data);  // 分配新内存并复制值
    }

    ~DeepCopy() {
        delete data;
    }

    int getValue() const {
        return *data;
    }
};

// 使用：
DeepCopy obj1(100);
DeepCopy obj2 = obj1;  // 调用深拷贝构造函数
// obj1 和 obj2 各自有独立的 data 内存空间

class SafeString {
private:
    char* str;
    size_t len;

public:
    // 构造函数
    SafeString(const char* s = "") {
        len = strlen(s);
        str = new char[len + 1];
        strcpy(str, s);
    }

    // 拷贝构造函数（深拷贝）
    SafeString(const SafeString& other) {
        len = other.len;
        str = new char[len + 1];      // 分配独立内存
        strcpy(str, other.str);       // 复制内容
    }

    // 赋值操作符（也需深拷贝）
    SafeString& operator=(const SafeString& other) {
        if (this != &other) {         // 防止自赋值
            delete[] str;             // 释放原内存
            len = other.len;
            str = new char[len + 1];
            strcpy(str, other.str);
        }
        return *this;
    }

    // 析构函数
    ~SafeString() {
        delete[] str;
    }

    const char* c_str() const {
        return str;
    }
};