C++ 拷贝构造函数与赋值运算符：深拷贝与浅拷贝辨析

运行结果会显示多次'拷贝构造函数被调用'，这印证了上述的触发条件。

二、浅拷贝与深拷贝的核心区别

理解了拷贝构造函数，接下来要解决一个更棘手的问题：当类中包含指针成员时，默认拷贝会发生什么？

1. 浅拷贝的隐患

默认的拷贝构造函数实现的是浅拷贝。它只是把成员变量的值原封不动地复制过去。如果成员变量是指针，那么两个对象的指针就会指向同一块堆内存。

问题演示

#include <iostream>
#include <cstring>
using namespace std;

class String {
private:
    char* str; // 指针成员

public:
    // 普通构造函数：分配堆内存
    String(const char* s = "") {
        str = new char[strlen(s) + 1];
        strcpy(str, s);
        cout << "普通构造函数：分配内存" << endl;
    }

    // 析构函数：释放堆内存
    ~String() {
        delete[] str;
        cout << "析构函数：释放内存" << endl;
    }

    void show() {
        cout << str << endl;
    }
};

int main() {
    String s1("Hello C++");
    // 浅拷贝：s2.str 与 s1.str 指向同一块内存
    String s2 = s1;
    
    s1.show();
    s2.show();
    return 0;
}

这段代码运行起来似乎没问题，但一旦程序结束，析构函数会被调用两次。由于 s1 和 s2 指向同一块内存，第二次 delete 会导致重复释放内存，引发程序崩溃。此外，修改其中一个对象的内容，另一个也会跟着变，破坏了对象的独立性。

2. 深拷贝的实现

深拷贝的核心思想是：为指针成员重新分配内存，并将原数据拷贝到新内存中。这样每个对象都有自己独立的内存空间。

重写拷贝构造函数

#include <iostream>
#include <cstring>
using namespace std;

class String {
private:
    char* str;

public:
    String(const char* s = "") {
        str = new char[strlen(s) + 1];
        strcpy(str, s);
        cout << "普通构造函数：分配内存" << endl;
    }

    // 手动实现深拷贝构造函数
    String(const String& other) {
        // 为新对象分配独立内存
        this->str = new char[strlen(other.str) + 1];
        // 拷贝数据
        strcpy(this->str, other.str);
        cout << "深拷贝构造函数：分配独立内存" << endl;
    }

    ~String() {
        delete[] str;
        cout << "析构函数：释放内存" << endl;
    }

    void show() {
        cout << str << endl;
    }

    // 提供修改字符串的方法，验证独立性
    void setStr(const char* s) {
        delete[] str;
        str = new char[strlen(s) + 1];
        strcpy(str, s);
    }
};

int main() {
    String s1("Hello C++");
    String s2 = s1; // 调用深拷贝构造函数

    cout << "修改前：" << endl;
    s1.show();
    s2.show();

    // 修改 s1 的内容
    s1.setStr("Hello Deep Copy");
    cout << "修改后：" << endl;
    s1.show();
    s2.show();

    return 0;
}

现在，修改 s1 不会影响 s2，且析构时各自释放各自的内存，安全得多。

三、赋值运算符重载与深拷贝

除了拷贝构造函数，赋值运算符（=）的默认行为也是浅拷贝。如果类中有指针成员，必须手动重载赋值运算符来实现深拷贝。

1. 核心原则

实现赋值运算符重载时，有三点必须注意：

1. 处理自赋值：防止 a = a 导致内存提前释放。
2. 释放原有内存：避免内存泄漏。
3. 返回对象引用：支持链式赋值（如 a = b = c）。

2. 代码实现

#include <iostream>
#include <cstring>
using namespace std;

class String {
private:
    char* str;

public:
    String(const char* s = "") {
        str = new char[strlen(s) + 1];
        strcpy(str, s);
        cout << "普通构造函数：分配内存" << endl;
    }

    // 深拷贝构造函数
    String(const String& other) {
        this->str = new char[strlen(other.str) + 1];
        strcpy(this->str, other.str);
        cout << "深拷贝构造函数：分配独立内存" << endl;
    }

    // 重载赋值运算符，实现深拷贝
    String& operator=(const String& other) {
        // 1. 处理自赋值
        if (this == &other) {
            return *this;
        }
        // 2. 释放当前对象的原有内存
        delete[] this->str;
        // 3. 分配新内存并拷贝数据
        this->str = new char[strlen(other.str) + 1];
        strcpy(this->str, other.str);
        cout << "赋值运算符重载：深拷贝" << endl;
        // 4. 返回当前对象引用
        return *this;
    }

    ~String() {
        delete[] str;
        cout << "析构函数：释放内存" << endl;
    }

    void show() {
        cout << str << endl;
    }
};

int main() {
    String s1("Hello C++");
    String s2;
    // 调用赋值运算符重载
    s2 = s1;
    s1.show();
    s2.show();

    // 测试链式赋值
    String s3;
    s3 = s2 = s1;
    cout << "链式赋值后 s3：";
    s3.show();

    return 0;
}

四、拷贝构造函数与赋值运算符的区别

虽然两者都涉及对象复制，但本质不同：

五、实战案例：自定义数组类

为了巩固理解，我们设计一个支持动态扩容的 MyArray 类，完整实现深拷贝逻辑。

需求分析

1. 成员变量：int* arr（存储数组数据）、int size（数组大小）。
2. 核心功能：构造函数分配内存、深拷贝构造、赋值运算符重载、打印数组、析构函数释放内存。
3. 目标：保证多个对象的数组数据独立。

完整代码

#include <iostream>
#include <cstring>
using namespace std;

class MyArray {
private:
    int* arr; // 动态数组指针
    int size; // 数组大小

public:
    // 构造函数：创建指定大小的数组
    MyArray(int s = 0) : size(s) {
        if (size > 0) {
            arr = new int[size];
            memset(arr, 0, sizeof(int) * size);
        } else {
            arr = nullptr;
        }
        cout << "构造函数：创建大小为 " << size << " 的数组" << endl;
    }

    // 深拷贝构造函数
    MyArray(const MyArray& other) {
        this->size = other.size;
        if (this->size > 0) {
            this->arr = new int[this->size];
            for (int i = 0; i < this->size; i++) {
                this->arr[i] = other.arr[i];
            }
        } else {
            this->arr = nullptr;
        }
        cout << "深拷贝构造函数：拷贝大小为 " << size << " 的数组" << endl;
    }

    // 赋值运算符重载：深拷贝
    MyArray& operator=(const MyArray& other) {
        if (this == &other) {
            return *this;
        }
        // 释放当前对象原有内存
        if (this->arr != nullptr) {
            delete[] this->arr;
        }
        // 拷贝大小并分配新内存
        this->size = other.size;
        if (this->size > 0) {
            this->arr = new int[this->size];
            for (int i = 0; i < this->size; i++) {
                this->arr[i] = other.arr[i];
            }
        } else {
            this->arr = nullptr;
        }
        cout << "赋值运算符重载：深拷贝数组" << endl;
        return *this;
    }

    void setValue(int index, int value) {
        if (index >= 0 && index < size) {
            arr[index] = value;
        } else {
            cout << "⚠️ 索引越界" << endl;
        }
    }

    void printArray() {
        if (arr == nullptr) {
            cout << "数组为空" << endl;
            return;
        }
        cout << "数组元素：";
        for (int i = 0; i < size; i++) {
            cout << arr[i] << " ";
        }
        cout << endl;
    }

    // 析构函数：释放内存
    ~MyArray() {
        if (arr != nullptr) {
            delete[] arr;
            arr = nullptr;
        }
        cout << "析构函数：释放数组内存" << endl;
    }
};

int main() {
    // 创建数组对象
    MyArray arr1(5);
    arr1.setValue(0, 10);
    arr1.setValue(1, 20);
    arr1.setValue(2, 30);
    arr1.printArray();

    // 深拷贝构造新对象
    MyArray arr2 = arr1;
    arr2.setValue(0, 100);
    cout << "修改 arr2 后：" << endl;
    arr1.printArray();
    arr2.printArray();

    // 赋值运算符重载
    MyArray arr3(3);
    arr3 = arr1;
    arr3.setValue(1, 200);
    cout << "修改 arr3 后：" << endl;
    arr1.printArray();
    arr3.printArray();

    return 0;
}

六、开发规范与建议

1. 三法则原则

当类中包含指针成员或需要管理资源时，必须同时实现拷贝构造函数、赋值运算符重载、析构函数。这三者缺一不可，合称'三法则'（Rule of Three）。

2. 优先使用智能指针

在现代 C++（C++11 及以上）开发中，建议优先使用 unique_ptr、shared_ptr 等智能指针替代裸指针。它们能自动管理内存，从根本上避免手动实现深拷贝的繁琐和潜在错误。

3. 常见问题排查

• 忘记处理自赋值：在赋值运算符开头加 if (this == &other) 判断。
• 释放内存后未置空：析构或赋值后，将指针置为 nullptr，防止野指针。
• 内存分配失败：生产环境中应添加异常处理逻辑，增强健壮性。

七、总结

拷贝构造函数负责创建新对象，赋值运算符负责更新已存在对象。浅拷贝仅复制值，深拷贝则确保指针指向的内存独立。遵循三法则原则，合理使用深拷贝，是保障 C++ 程序内存安全的关键技能。