Lesson 0007C · 拷贝控制

① 程序设计基础 — 指针进阶课 2

1. 赋值和初始化会“复制”对象

int a = 10;
int b = a;      // b 是 a 的副本，改 b 不影响 a

string s1 = "hello";
string s2 = s1; // s2 是副本，各自管自己的内存

struct Point { int x, y; };
Point p1 = {1, 2};
Point p2 = p1;  // 逐个成员复制：p2.x=1, p2.y=2

对于没有指针成员的类，编译器自动生成的“逐成员复制”完全够用。问题出在类里有指针的时候。

2. 浅拷贝会出事

class IntArray {
public:
    int* data;              // 指向堆上的数组
    int size;

    IntArray(int n) : size(n) { data = new int[n](); }  // 全初始化为 0
    ~IntArray() { delete[] data; }
};

int main() {
    IntArray a(5);
    a.data[0] = 100;

    IntArray b = a;         // 默认拷贝构造：只复制指针
    cout << b.data[0];     // 100 —— b.data 和 a.data 是同一块内存！
}

这就是浅拷贝：只复制了指针的值（地址），没有复制指针指向的那块数据。两个对象共用一块堆内存。

3. 拷贝构造函数：初始化时怎么复制

class IntArray {
public:
    int* data;
    int size;

    IntArray(const IntArray& other) {          // 拷贝构造
        size = other.size;
        data = new int[size];                  // 自己申请一块新内存
        for (int i = 0; i < size; i++)
            data[i] = other.data[i];           // 逐个复制内容（深拷贝）
    }
};

4. 赋值运算符：已经存在的对象怎么复制

class IntArray {
public:
    int* data;
    int size;

    IntArray& operator=(const IntArray& 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;                           // ④ 支持链式赋值 a = b = c
    }
};

5. 三法则 Rule of Three

只要类里管理了裸指针（new 出来的），下面三个函数就必须一起写：

6. 完整示例：能用会跑的 IntArray

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

public:
    IntArray(int n) : size(n) { data = new int[n](); }

    IntArray(const IntArray& other) : size(other.size) {
        data = new int[size];
        for (int i = 0; i < size; i++) data[i] = other.data[i];
    }

    IntArray& operator=(const IntArray& 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;
    }

    ~IntArray() { delete[] data; }

    int& operator[](int i) { return data[i]; }
    int getSize() const { return size; }
};

下面用它跑一遍：

int main() {
    IntArray a(3);
    a[0] = 10; a[1] = 20; a[2] = 30;

    IntArray b = a;        // 拷贝构造：深拷贝
    b[0] = 99;             // 改 b 不影响 a

    IntArray c(1);
    c = a;                 // 拷贝赋值：深拷贝
    c[1] = 77;

    cout << a[0] << " " << b[0] << " " << c[1];
    // 输出：10 99 77 —— 三个对象互不干扰
}

7. 坑点清单

• 类里有 new 的裸指针，就别用默认拷贝：默认的只复制地址，两个对象共用一块内存。
• 拷贝构造的参数必须是 const 引用：写成按值 IntArray(IntArray other) 会无限递归。
• 赋值运算符里先判断自赋值：if (this == &other) return *this;，不然后面 delete[] 会删掉自己的数据。
• 顺序是先释放旧内存、再申请新内存，别搞反；两个对象的深浅关系要一次理清。
• “有 new 就写三个”：析构、拷贝构造、拷贝赋值，缺一个就会在某个场景下退化成浅拷贝。

8. 小测

9. 动手练习

本课小结

• 浅拷贝：只复制指针（地址），两个对象共用同一块堆内存。
• 深拷贝：连指针指向的数据一起复制，各管各的内存。
• 拷贝构造：类名(const 类名&)，在用对象初始化新对象时调用。
• 拷贝赋值 operator=：先判自赋值，再释放旧内存，再深拷贝，返回 *this。
• 三法则：析构、拷贝构造、拷贝赋值，存在裸指针就必须一起实现。
• 最优解：用 vector / string 托管数据，三法则一个都不用写。