一、什么时候会自动调用它

只要"用一个对象去造另一个对象"，它就会跑：

关键区分：Point b = a;（初始化）会调复制构造；而 b = a;（已经存在的 b 被赋值）不会——那调的是赋值运算符（后面章节的内容）。看"b 是不是新造的" 就能区分。

二、编译器免费送的那个：浅拷贝

你不写复制构造函数时，编译器生成的版本干这件事：

把每个成员，逐个复制过去。

class Point {
private:
    int x, y;
    // 编译器偷偷塞进来一个：
    // Point(const Point &other) : x(other.x), y(other.y) { }
};

对"纯值成员"，这完全够用：

Point a(3, 4);
Point b(a);            // b.x = 3, b.y = 4
b.set(9, 9);           // 改 b
a.show();              // a 还是 (3, 4) —— 各是各的，互不干扰 ✅

因为 x、y 是 int，复制的是"值本身"，不是"地址"。

但成员是指针时，事情就变了：

class Holder {
private:
    int *data;          // ← 指针成员
public:
    Holder(int v) { data = new int(v); }        // 在堆上申请
    // 编译器送的复制构造：data = other.data;  ← 只复制了"地址"！
};

看图理解：

于是：

• *b.data = 99; → *a.data 也变成 99（改一个动另一个）
• 两个对象结束时都要释放这块内存 → 同一块内存被释放两次 → 程序崩溃

记住这句话：成员里有"自己申请的资源"（指针）时，编译器送的浅拷贝就是个雷。 这时候必须自己写复制构造函数。**（怎么安全地"复制内容"——也就是"深拷贝"——要用动态内存，会在后面章节展开；本篇先讲清"为什么要写"和"怎么写一个对浅拷贝的安全版本"。）

三、参数为什么必须是引用

复制构造函数的"标准长相"是这样的：

类名(const 类名 &other) { ... }

这里的 & 是必须的，不是可选的。原因：

// 假如写成传值：
Point(Point other) { ... }         // ❌

这个参数 other 自己就是一个 Point 对象——而"造 other 需要调用复制构造函数"……于是无限递归：要造副本，先得造副本，再得造副本……编译器直接禁止这种写法，会报：

error: copy constructor must pass its first argument by reference

至于 const（不是语法强制，但是强烈建议）：

四、怎么"自己写一个"：给指针成员做真复制

本篇给出的安全做法：自己申请一块新内存，把内容复制过去（而不是复制地址）。

class Holder {
private:
    int *data;

public:
    Holder(int v) {
        data = new int(v);                              // 自己申请一块
    }

    // ★ 复制构造函数：内容另存一份，而不是"再指一遍"
    Holder(const Holder &other) {
        data = new int(*other.data);                    // 新开一块，把值拷进去
        cout << "复制构造函数被调用" << endl;
    }

    ~Holder() {                                          // 10.3 会讲：对象消亡时跑
        delete data;                                     // 谁申请的谁释放
        cout << "析构：释放了 " << data << endl;
    }

    void set(int v) { *data = v; }
    int  get()      { return *data; }
    int* addr()     { return data; }                     // 只为观察地址
};

对比一下两种写法：

一句话记住："没写复制构造函数 + 有指针成员"＝埋了一颗雷。 判据就一条：我的类里有没有"指向自己申请资源的指针"？ 有，就必须自己管复制。

五、实例02：使用复制构造函数

目标：写一个带指针成员的类，让它自己写复制构造函数，并验证复制出来的对象是真正独立的。

#include <iostream>
using namespace std;

class Holder {
private:
    int *data;
    int  tag;                       // 一个普通成员，用来区分是谁

public:
    // ① 带参构造函数
    Holder(int v, int t) : data(new int(v)), tag(t) {
        cout << "构造 #" << tag << "：data 地址 " << data << "，值 " << *data << endl;
    }

    // ② ★ 复制构造函数（实例02 的核心）
    Holder(const Holder &other) : data(new int(*other.data)), tag(other.tag + 100) {
        cout << "复制构造（源 #" << other.tag << " → 新 #" << tag << "）："
             << "新地址 " << data << "，值 " << *data << endl;
    }

    // ③ 析构函数（10.3 专讲，这里先让它帮忙观察）
    ~Holder() {
        cout << "析构 #" << tag << "：释放 " << data << endl;
        delete data;
    }

    void set(int v) { *data = v; }
    int  get() const { return *data; }
    int  address() const { return (int)data; }   // 转成整数方便打印比较
};

int main() {
    cout << "--- 造原件 ---" << endl;
    Holder a(10, 1);

    cout << "--- 用 a 造副本 b ---" << endl;
    Holder b(a);                          // ★ 走复制构造函数

    cout << "--- 各自的值和地址 ---" << endl;
    cout << "a: 地址 " << a.address() << "，值 " << a.get() << endl;
    cout << "b: 地址 " << b.address() << "，值 " << b.get() << endl;

    cout << "--- 改 b，看 a 有没有变 ---" << endl;
    b.set(999);
    cout << "a 的值 = " << a.get() << "（应为 10，没被影响）" << endl;
    cout << "b 的值 = " << b.get() << "（应为 999）" << endl;

    cout << "--- 程序结束，看析构顺序 ---" << endl;
    return 0;
}

看到什么算成功（地址数字各机器不同，关键是两组地址不相等、且没有重复释放）：

--- 造原件 ---
构造 #1：data 地址 0x1f1a20，值 10
--- 用 a 造副本 b ---
复制构造（源 #1 → 新 #101）：新地址 0x1f1a40，值 10
--- 各自的值和地址 ---
a: 地址 6609440，值 10
b: 地址 6609472，值 10
--- 改 b，看 a 有没有变 ---
a 的值 = 10（应为 10，没被影响）
b 的值 = 999（应为 999）
--- 程序结束，看析构顺序 ---
析构 #101：释放 0x1f1a40
析构 #1：释放 0x1f1a20

读结果四句话：

1. "复制构造"那句在 Holder b(a); 处出现——证明它自动执行了（我们从没手动调过它）。
2. 两个地址不相等（0x1f1a20 vs 0x1f1a40）——b 有自己的一块内存，这才叫真复制。
3. 改 b 不影响 a（10 还在）——两个对象彻底独立。
4. 两次析构、两个不同地址——没有重复释放，程序平静结束。

把复制构造函数删掉试试（把 ② 整段注释掉），会看到什么：

构造 #1：data 地址 0x1f1a20，值 10
a: 地址 6609440，值 10
b: 地址 6609440，值 10   ← 注意：地址和 a 一模一样！
a 的值 = 999（应为 10，没被影响）   ← ❌ a 被改坏了！
b 的值 = 999
析构 #1：释放 0x1f1a20
析构 #1：释放 0x1f1a20   ← ❌ 同一块内存释放了两次

注意最后两行：同一地址被释放两次——这就是"重复释放"，真机上通常直接崩溃。这就是不写复制构造函数的代价，一次就够记住。

30 秒实验：在 main 里再加一行 Holder c = a;（注意是 =，一样调复制构造），看输出里又出现一次"复制构造"。Holder c = a; 和 Holder c(a); 效果完全相同——= 在这里只是"初始化的写法"，不是赋值。这个区别（初始化 vs 赋值）值得专门记一笔。

六、什么时候必须自己写复制构造函数

"想禁止复制"的写法（很实用）：

class Singleton {
private:
    Singleton(const Singleton &) = delete;              // C++11：明确禁止复制
    Singleton& operator=(const Singleton &) = delete;
public:
    Singleton() { }
};

再复制就会直接报错：use of deleted function 'Singleton::Singleton(const Singleton&)'。这个报错信息很友好，一眼就懂。

七、常见误区

1. "Point b = a; 是赋值"——不是。它是初始化（b 是新造的），走的是复制构造函数；b = a;（b 已存在）才是赋值，走赋值运算符。看对象是不是新造的，就能分清。
2. "编译器送的复制构造函数一定安全"——只在"没有需要自己管理的资源"时才安全。成员里有指针（且指向自己申请的内存）时，浅拷贝就是雷（第五节的两组输出，一个天一个地）。
3. "复制构造函数参数写 Point other 也行"——不行，会无限递归。参数必须是引用（标准写法带 const）。
4. "值传递的对象参数不调复制构造"——调。void f(Point p) 这种传值调用，每次调用都会造一个副本（6.2.2 讲过"值被复制"，现在你知道这份复制是谁干的了）。这也是"传大对象要用 const &"的性能理由（8.3）。
5. "写了复制构造函数，构造函数就算写全了"——不是。默认构造、带参构造、复制构造是三件独立的事，各自可能都需要（10.2 讲过：写了任何一个，编译器就不再送默认构造函数）。还有第三件：10.3 的析构函数。

• ☐ 10.3 析构函数（下一节）

相关笔记

• 构造函数概述 —— 上一节：初始化列表与初始化顺序
• 析构函数 —— 下一节：对象消亡时自动跑的那个
• 指针 —— 指针成员为什么特殊
• 使用结构体变量做函数参数 —— 同一个复制机制，在结构体上的表现
• 使用引用传递参数 —— "传大对象用 const &"的性能理由
• 🔷 C++基础 · 索引 —— 全课路线图