一、本章知识地图

二、必须记住的八个结论

1. class 和 struct 几乎是一回事，只差默认访问权限（class 是 private、struct 是 public）。选哪个是表达意图：struct 表"一堆数据"、class 表"一个有规矩的对象"（10.1）。
2. 封装的本质是"约定入口"，不是"把数据锁起来"。判据：外界能不能在不直接碰数据的情况下把事情办完（10.1.1、9.2.3）。
3. 构造函数让对象"一出生就是合法的"。它自动执行、想忘也忘不了——这就是它比"手动调 init()"强的地方（10.2）。
4. 成员初始化按"声明顺序"，不按"初始化列表的顺序"。别让一个成员的初值依赖另一个成员（10.2.1）。
5. 复制构造函数＝浅拷贝。成员是值类型时够用；成员有"指向自己申请内存的指针"时，浅拷贝会造成"改一个动另一个"和"重复释放"——必须自己写（10.2.2）。
6. "三法则"：需要写析构函数（说明拥有资源）时，通常也要管好复制构造函数。三个函数要一起想（10.3）。
7. this 是"当前对象的地址"，是成员函数里那个隐形的第一个参数。p.show() 等价于 show(&p)；静态成员函数没有 this，所以碰不到普通成员（10.4.4）。
8. 友元是"发卡"不是"拆墙"——它只对点名的对象开放，单向且不传递。能精确（只放行一个函数）就别图省事（放行整个类）（10.5 组）。

三、动手 Demo：两关自测

第一关（写代码）：一个完整可用的"银行账户"

要求：用本章学的东西，写一个 Account 类。

规格：

参考实现（自己先写，写不出来再看）：

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

class Account {
private:
    char   id[20];
    double balance;
    static int count;                        // 静态成员（10.4.3）

public:
    // ① 无参构造：必须自己补，否则 Account a; 编译不过
    Account() : balance(0) {
        id[0] = '\0';
        count++;
    }

    // ② 带参构造：初始化列表 + 函数体校验
    Account(const char *pid, double b) : balance(b >= 0 ? b : 0) {
        strcpy(id, pid);
        count++;
    }

    // ③ 析构函数：没有申请资源，但可以打印留痕（10.3）
    ~Account() {
        count--;
    }

    // ④ 存钱：校验放这里
    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            cout << "存入 " << amount << "，余额 " << balance << endl;
        } else {
            cout << "存入金额必须大于 0" << endl;
        }
    }

    // ⑤ 取钱：不能超额
    bool withdraw(double amount) {
        if (amount <= 0) {
            cout << "取款金额必须大于 0" << endl;
            return false;
        }
        if (amount > balance) {
            cout << "余额不足（当前 " << balance << "）" << endl;
            return false;
        }
        balance -= amount;
        cout << "取出 " << amount << "，余额 " << balance << endl;
        return true;
    }

    // ⑥ const 成员函数：只读（10.4.1）
    double getBalance() const { return balance; }

    void show() const {
        cout << "账号 " << id << "，余额 " << balance << endl;
    }

    static int getCount() { return count; }
};

int Account::count = 0;                      // ★ 静态成员类外定义

// 一个用 const 引用接账款的函数（验证 const 成员函数的作用）
void audit(const Account &a) {
    a.show();                                // 能调，因为 show() 是 const 的
    cout << "审计读到余额：" << a.getBalance() << endl;
}

int main() {
    Account a("A1001", 500);
    Account b("A1002", -50);                 // 非法初始余额，被兜成 0

    a.show();
    b.show();

    a.deposit(200);
    a.deposit(-5);                           // 被拦
    a.withdraw(1000);                        // 余额不足
    a.withdraw(300);

    audit(a);                                // 传 const 引用

    cout << "当前账户数 = " << Account::getCount() << endl;   // 2（用类名调）
    return 0;
}

看到什么算成功：

账号 A1001，余额 500
账号 A1002，余额 0
存入 200，余额 700
存入金额必须大于 0
余额不足（当前 700）
取出 300，余额 400
账号 A1001，余额 400
审计读到余额：400
当前账户数 = 2

如果这一关你能独立写出来：说明本章的核心（封装、构造、静态成员、const 成员函数）你已经会用了。

第二关（找错）：下面这个类有六处问题

class Wallet {
public:
    double money;                           // ① ?
    static double rate;                     // ② ?

    Wallet(double m) {                      // ③ ?
        money = m;
    }

    ~Wallet() { delete money; }             // ④ ?

    void setMoney(double money) {           // ⑤ ?
        money = money;
    }

    double getMoney() { return money; }     // ⑥ ?
};

double Wallet::rate = 0.5;

答案：

30 秒实验：把第二关的六处改对，然后在 main 里写：

Wallet w(100);
const Wallet cw(50);            // const 对象
cw.getMoney();                  // 如果 ⑥ 没改，这里会报 discards qualifiers

改一处、编一次——六个错误各自会报出什么样的错、为什么报，一次全部体验完。 这比读十遍文字有用得多。

四、常见误区（本章汇总）

1. "把数据全设成 private、给每个字段配 get/set 就叫封装"——那是"门开得跟没墙一样"。好的封装是暴露有意义的行为（deposit、withdraw），而不是暴露字段（10.1.1、9.2.3）。
2. "忘记写构造函数也没关系，编译器会给一个"——它给的那个是"空的"，什么都不做（成员还是垃圾值）。要初始化就得自己写（10.2）。
3. "复制就是复制，不会有坑"——成员里有指针时，默认的浅拷贝就是雷（10.2.2）。写完类的最后一个习惯动作是问自己："我有没有需要自己管理的资源？"
4. "析构函数会释放对象本身的内存"——对象本身的字节由系统回收（局部对象出作用域、堆对象 delete）；析构函数负责的是"对象自己申请的那些额外资源"（10.3）。
5. "友元破坏了封装，不该用"——它常常比"开一堆 get/set"更保护封装。关键不是"用不用"，而是"给多大权限"：能只放行一个函数，就别放行整个类（10.5 组）。
6. "using namespace std; 写在文件开头是标准做法"——那是教程为了排版简洁。工程规范基本禁止它，尤其禁止写在头文件里（10.6 组）。从今天起试着写成 std::cout。

五、下一章预告

本章学会了"造一个类"。下一章开始学"让一个类站在另一个类的肩膀上"——继承。

你会看到 9.2.3 说的三大特点里，第二个（继承）和第三个（多态）正式登场；本章埋下的几个伏笔也会一一兑现：

• 10.1.1 的 protected——那时说"留给继承用"，下一章它就派上用场了。
• 10.2.1 的"子类怎么调用父类的构造函数"——构造函数在继承里的新规则。
• 10.3 的虚析构函数——析构函数在继承里的新坑。
• 10.4.4 的 this——它在多态里会变得更有意思。

• ☑ 第十一章 继承与派生 —— 已完结：小结（让类站在类的肩膀上：继承语法与权限、构造顺序、隐藏同名函数、运算符重载、多重继承、virtual 与动态绑定、抽象类）

相关笔记

• C++类 —— 本章起点：终于开始造自己的类型
• 构造函数 —— 让对象一出生就合法
• 复制构造函数 —— 本章最深的一个坑
• 析构函数 —— 对象一生的另一端
• 隐藏的this指针 —— 成员函数怎么知道在操作谁
• 命名空间 —— 把 using namespace std; 讲透
• 小结 —— 上一章知识地图："为什么要换角度"
• 小结 —— 上上章：结构体＝类的雏形
• 小结 —— 下一章知识地图：让类站在类上（继承·运算符重载·多态·抽象类）
• 🔷 C++基础 · 索引 —— 全课路线图