C++拷贝构造函数：对象的“克隆术”与“分身陷阱

C++拷贝构造函数：对象的“克隆术”与“分身陷阱”

开篇小故事：快递包裹的“复制危机”

假设你有一个快递包裹，里面是一张存有珍贵照片的SD卡。如果你直接复制包裹，只拷贝外盒的标签（比如“SD卡，地址A”），而不复制里面的卡，那么：

• 两个包裹的标签指向同一张SD卡。
• 一旦其中一人修改了卡的内容，另一人也会受影响！
• 如果其中一人销毁了卡，另一人的包裹标签就指向了无效地址。

这就是C++中浅拷贝的危险！而拷贝构造函数的作用，就是教你如何正确“复制包裹”——不仅要复制标签，还要复制里面的实物！

一、拷贝构造函数是什么？

拷贝构造函数是C++类的一个特殊成员函数，用于创建一个新对象，并将其初始化为同类型现有对象的副本。它的基本形式为：

class MyClass {
public:
    // 拷贝构造函数
    MyClass(const MyClass& other) { 
        // 复制other对象的成员到当前对象
    }
};

二、默认拷贝构造函数：一把“双刃剑”

如果你不主动定义拷贝构造函数，编译器会自动生成一个默认拷贝构造函数。它的行为是：逐成员浅拷贝（Shallow Copy）。

• 基本类型（int、double等）：直接复制值。
• 指针类型：复制指针的值（即地址），而不是指针指向的数据！

示例：危险的浅拷贝

class PhotoAlbum {
private:
    int* photos;  // 动态数组，存储照片ID
    int size;
public:
    PhotoAlbum(int size) : size(size) {
        photos = new int[size]; // 动态分配内存
    }
    ~PhotoAlbum() {
        delete[] photos; // 析构函数释放内存
    }
    // 默认拷贝构造函数：浅拷贝 photos指针！
};

void test() {
    PhotoAlbum album1(10);
    PhotoAlbum album2 = album1; // 调用默认拷贝构造函数
} 
// 函数结束时，album1和album2的析构函数都会delete[] photos！
// 导致双重释放（double free）崩溃！

后果：两个对象的photos指针指向同一块内存，析构时重复释放，程序崩溃！

三、自定义拷贝构造函数：实现“深拷贝”

解决上述问题的关键是深拷贝（Deep Copy）——不仅复制指针，还复制指针指向的数据。
需要在类中自定义拷贝构造函数：

class PhotoAlbum {
    // ...其他成员同上

public:
    // 自定义拷贝构造函数（深拷贝）
    PhotoAlbum(const PhotoAlbum& other) : size(other.size) {
        photos = new int[size];          // 1. 为新对象分配内存
        for (int i = 0; i < size; i++) {
            photos[i] = other.photos[i]; // 2. 复制数据
        }
    }
};

此时，album2 = album1会执行深拷贝：

• album2.photos指向一块新内存，数据与album1相同。
• 析构时各自释放自己的内存，避免崩溃！

四、拷贝构造函数的调用场景

1. 对象初始化时赋值

PhotoAlbum album2 = album1; // 调用拷贝构造函数
PhotoAlbum album3(album1); // 另一种写法

2. 函数参数传递对象（按值传递）

void printAlbum(PhotoAlbum album) { /* ... */ }

printAlbum(album1); // 调用拷贝构造函数创建参数album

3. 函数返回对象（按值返回）

PhotoAlbum createAlbum() {
    PhotoAlbum album(10);
    return album; // 可能调用拷贝构造函数（取决于编译器优化）
}

五、拷贝构造函数的“黄金法则”

1. Rule of Three

如果类需要自定义以下三者之一，通常需要同时定义另外两个：

• 拷贝构造函数
• 拷贝赋值运算符（operator=）
• 析构函数

2. 禁用拷贝

如果不希望对象被复制，可以将拷贝构造函数声明为delete：

PhotoAlbum(const PhotoAlbum& other) = delete;

3. 使用智能指针（现代C++最佳实践）

通过std::unique_ptr或std::shared_ptr管理资源，避免手动深拷贝：

class PhotoAlbum {
private:
    std::unique_ptr<int[]> photos; // 自动管理内存
    int size;
public:
    PhotoAlbum(int size) : size(size), photos(new int[size]) {}
    // 不需要自定义拷贝构造函数！
    // unique_ptr禁止拷贝，shared_ptr自动引用计数
};

六、深拷贝 vs. 浅拷贝：总结表

七、实战：实现一个安全的字符串类

class MyString {
private:
    char* data;
    int length;
public:
    // 构造函数
    MyString(const char* str = "") {
        length = strlen(str);
        data = new char[length + 1];
        strcpy(data, str);
    }

    // 拷贝构造函数（深拷贝）
    MyString(const MyString& other) : length(other.length) {
        data = new char[length + 1];
        strcpy(data, other.data);
    }

    // 析构函数
    ~MyString() {
        delete[] data;
    }

    // 拷贝赋值运算符（后续可扩展）
    MyString& operator=(const MyString& other) {
        if (this != &other) {
            delete[] data;
            length = other.length;
            data = new char[length + 1];
            strcpy(data, other.data);
        }
        return *this;
    }
};

总结：拷贝构造函数——对象的“安全克隆术”

拷贝构造函数是C++资源管理的核心机制之一。理解深浅拷贝的区别，能帮助你避免内存泄漏、数据竞争等“致命陷阱”。

• 当类“拥有”资源（内存、文件等）时，务必实现深拷贝！
• 现代C++中，优先使用智能指针和RAII技术，减少手动管理负担。

下次当你复制对象时，不妨想象自己正在小心翼翼地“克隆”一个快递包裹——既要复制标签，也要复制里面的珍宝！

（完）

这篇博客是否清晰解释了拷贝构造函数的关键点？如果需要调整代码示例或补充细节，请随时告诉我~ 😊