🎯 前言：快速复习策略

基于老师最后一课讲义整理 · 覆盖所有考题类型

🧠 需要理解（会变数字/变形式，靠理解机制拿分）

📝 需要背诵（死答案，不会变）

🧬 第 1 章 — 继承与多态

对应考题：第2题、第6题、第34题、第40题 | ⭐⭐⭐⭐⭐ 必考

1.1 先搞懂三个核心概念

Animal* p = new Dog();    // p 声明为 Animal*，但实际指向 Dog 对象
p->speak();               // speak 是 virtual → 运行时发现实际是 Dog → 调 Dog::speak()
// ↑ 这就是多态：同一个 p->speak() 调用，实际行为取决于 p 指向什么对象

1.2 构造/析构的黄金法则

规则：创建派生类对象时，父类部分必须先构造好，子类才能在其基础上构造。销毁时反过来，子类先清理自己的东西，父类再清理。

Animal* p = new Dog();
delete p;  // 如果 ~Animal() 不是 virtual → 只调 ~Animal()，Dog 部分泄漏！
           // 如果 ~Animal() 是 virtual → 先调 ~Dog()，再调 ~Animal() ✅

1.3 对象切片 —— 考试最爱考的坑

对象切片（Object Slicing）：把派生类对象按值赋给父类对象时，派生类多出来的成员被切掉，只保留父类部分。就像把一个圆（子类）塞进方的模具（父类）。

Dog d;              // d 是完整的 Dog 对象，包含 Animal 部分 + Dog 独有部分
Animal a = d;       // ⚠️ 对象切片！a 是从 d 拷贝构造而来
                    // a 只拷贝了 Animal 那部分，Dog 独有部分被"切掉"了
                    // a.speak() 调的是 Animal::speak，不是 Dog::speak

记忆：想多态 → 用指针或引用；值拷贝 → 切片，多态消失。

1.4 虚函数 vs 非虚函数 —— 一张表记清楚

class Animal {
public:
    virtual void speak(int n = 5) const { ... }   // 父类默认值 n=5
};
class Dog : public Animal {
public:
    void speak(int n = 9) const override { ... }  // 子类默认值 n=9（但有坑！）
};

Animal* p = new Dog();     // p 声明为 Animal*
p->speak();                // 不传参数 → 用谁的默认值？
// 函数体用 Dog 的（动态绑定）✅ → 输出 "D::speak"
// 默认值用 Animal 的（静态绑定）⚠️ → n=5 而不是 n=9
// 最终输出：D::speak 5（不是 9！）

📝 第2题 — 执行流程表

从上到下按执行顺序阅读，"正在执行"列对应下方源码中的步骤标记

class ClassA {
public:
    // 构造函数（Constructor）：创建对象时自动调用
    ClassA() { cout << "ClassA" << endl; }        // 默认构造：无参数
    ClassA(int i) { cout << "ClassA" << i << endl; } // 有参构造：输出 ClassA + 数字
    ClassA(const ClassA& src) { cout << "ClassA copy" << endl; } // 拷贝构造
    ClassA& operator=(const ClassA& rhs) {          // 赋值运算符（本题没用到）
        cout << "call ClassA" << endl;
    }
    virtual ~ClassA() { cout << "Delete ClassA" << endl; } // 虚析构
    void invoke(int i = 7) const {                 // invoke 是非虚函数！注意：没有 virtual！
        cout << "invoke ClassA" << i << endl;     // 输出 invoke ClassA + 参数值
    }
};

class ClassB: public ClassA {      // ClassB 继承自 ClassA
public:
    ClassB() : ClassA(1) {         // 构造时先调 ClassA(1)，再执行自己的构造体
        cout << "ClassB" << endl;
    }
    virtual ~ClassB() { cout << "Delete ClassB" << endl; } // 虚析构
    void invoke(int i = 9) const { // 同名函数，隐藏了 ClassA::invoke（非虚，所以是隐藏不是覆盖）
        cout << "invoke ClassB" << i << endl;
    }
};

void find(const ClassA& inKlep) {  // 形参 inKlep 是 ClassA 的引用
    ClassA theClassA;              // ← 第4步在此执行：创建局部对象
    inKlep.invoke(2);              // ← 第5步在此执行：invoke 不是虚函数！
}                                  // ← 第6步：theClassA 离开作用域，自动销毁

int main() {
    ClassB deri;                   // ← 第1步：创建 ClassB 对象
    ClassA base = deri;            // ← 第2步：拷贝构造（等号左边是新对象 → 不是赋值！）
    find(deri);                    // ← 第3步：调用 find，传引用（不切片）
    cout << "Done!" << endl;      // ← 第7步：打印 Done!
    return 0;                      // ← 第8步：main 结束，局部变量按逆序析构
}

ClassA1
ClassB
ClassA copy
ClassA
invoke ClassA2
Delete ClassA
Done!
Delete ClassA
Delete ClassB
Delete ClassA

📝 第6题 — 最经典的多态综合题

这道题融合了虚函数、非虚函数、对象切片、虚析构、默认参数——全部考点。

class Animal {
public:
    Animal()    { cout << "A ctor" << endl; }       // 默认构造：输出 "A ctor"
    Animal(int n)   { cout << "A ctor " << n << endl; } // 有参构造：输出 "A ctor N"
    Animal(const Animal& src) { cout << "A copy ctor" << endl; } // 拷贝构造
    virtual ~Animal() { cout << "A dtor" << endl; }  // 虚析构（保证安全 delete）

    virtual void speak(int n = 5) const {            // 虚函数！默认值 n=5
        cout << "A::speak " << n << endl;
    }
    void breathe() const {                            // 非虚函数！
        cout << "A::breathe" << endl;
    }
};

class Dog : public Animal {        // Dog 继承 Animal
public:
    Dog() : Animal(3) {              // 初始化列表：先调 Animal(3)
        cout << "D ctor" << endl;  // 再执行自己的构造体
    }
    virtual ~Dog()  { cout << "D dtor" << endl; }   // 虚析构

    void speak(int n = 9) const override {           // 重写（override）父类虚函数
        cout << "D::speak " << n << endl;
    }
    void breathe() const {                            // 同名非虚函数，隐藏父类版本
        cout << "D::breathe" << endl;
    }
};

void bar(const Animal& a) {        // a 是 Animal 的引用（引用不切片！）
    Animal tmp;                    // ← 步骤4：创建局部 Animal 对象
    a.speak(1);                    // ← 步骤5：通过引用调虚函数
    a.breathe();                   // ← 步骤6：通过引用调非虚函数
}                                  // ← 步骤7：tmp 离开作用域

int main() {
    Dog d;                         // ← 步骤1~2：创建 Dog 对象（构造链）
    Animal a = d;                  // ← 步骤3：拷贝构造 → 对象切片！
    bar(d);                        // 调用 bar，d 以引用方式传入
    cout << "---" << endl;       // ← 步骤8：分隔线

    Animal* p = new Dog();         // ← 步骤9~10：在堆上创建 Dog 对象
    p->speak();                    // ← 步骤11：虚函数 + 默认参数
    delete p;                      // ← 步骤12~13：虚析构链

    return 0;                      // ← 步骤14~16：局部变量栈上析构
}

A ctor 3
D ctor
A copy ctor
A ctor
D::speak 1
A::breathe
A dtor
---
A ctor 3
D ctor
D::speak 5
D dtor
A dtor
A dtor
D dtor
A dtor

📝 第34题 — 纯虚函数与抽象类

纯虚函数：用 = 0 声明的虚函数，没有函数体。
抽象类：包含至少一个纯虚函数的类。不能直接创建对象，必须被继承并实现所有纯虚函数后才能用。

class Oyster {
public:
    // 构造函数：初始化 genus 成员
    Oyster(string genusString) { genus = genusString; }

    string getPhylum() const { return "Mollusca"; }      // 非虚函数：直接继承使用
    virtual string getName() const { return "Oyster class"; } // 虚函数：可被子类覆盖
    string getGenus() const { return genus; }             // 非虚函数：直接继承使用

    virtual void print() const = 0;   // ← 纯虚函数！= 0 表示没有实现，子类必须实现
                                      // Oyster 因此成为抽象类，不能 Oyster o; ❌
private:
    string genus;
};

class VirginiaOyster : public Oyster {
public:
    // 构造时通过初始化列表调用 Oyster("Crassostrea")
    VirginiaOyster() : Oyster("Crassostrea") {}

    // 覆盖父类的 getName 虚函数
    virtual string getName() const { return "VirginiaOyster class"; }

    // 实现父类的纯虚函数 print —— 必须实现，否则 VirginiaOyster 也是抽象类
    virtual void print() const {
        cout << "Phylum:" << getPhylum().c_str()   // 调用继承的 getPhylum()
             << "\tGenus: " << getGenus().c_str()    // 调用继承的 getGenus()
             << "\tName: " << getName().c_str();     // 调用自己的 getName()（虚函数，动态绑定）
    }
};

int main() {
    VirginiaOyster oyster;                 // 创建 VirginiaOyster 对象（合法，它实现了所有纯虚函数）
    Oyster *baseClassPtr;                  // 声明基类指针
    baseClassPtr = &oyster;                // 基类指针指向派生类对象（向上转型，安全）
    baseClassPtr->print();                 // print 是虚函数 → 动态绑定 → 调 VirginiaOyster::print()
    cout << endl;
    return 0;
}

✍️ 第40题 — 继承 + 虚函数编程

定义 computer 和 Macintosh 类。关键要求：通过 computer* 指针调用 print() 时，必须输出 Macintosh 的完整信息（包括 color）。

这要求 print 必须是 virtual —— 否则永远调 computer 的版本。

class computer {
protected:                     // protected：派生类可以访问，外部不能
    string name;               // 名字成员

public:
    computer(string n) : name(n) {}    // 构造函数：初始化 name

    virtual void print() const {       // ⚠️ 必须是 virtual！否则 p->print() 永远调这个
        cout << "name: " << name << endl;
    }

    virtual ~computer() {}             // ⚠️ 基类析构必须 virtual（好习惯）
};

class Macintosh : public computer {
    string color;                      // 派生类独有的成员

public:
    // 构造函数：先调 computer(n) 初始化 name，再初始化 color
    Macintosh(string n, string c) : computer(n), color(c) {}

    void print() const override {      // override 关键字：确认这是重写父类的虚函数
        cout << "name: " << name << endl;     // name 从父类继承（protected 可访问）
        cout << "color:" << color << endl;      // color 是自己的成员
    }
};

int main() {
    computer *p;                                   // 声明基类指针
    Macintosh imac("Joe's IMAC", "Blue");          // 创建 Macintosh 对象
    p = &imac;                                     // 基类指针指向派生类对象
    p->print();                                    // print 是 virtual → 动态绑定 → 调 Macintosh::print()
    return 0;
}

📋 第1章自测

class Base {
public:
    Base() { cout << "B"; }           // 构造：输出 B
    virtual ~Base() { cout << "~B"; } // 虚析构：输出 ~B
    virtual void f() { cout << "Bf"; } // 虚函数
    void g() { cout << "Bg"; }         // 非虚函数
};
class Derived : public Base {
public:
    Derived() { cout << "D"; }         // 构造：先调 Base() 输出 B，再输出 D
    ~Derived() { cout << "~D"; }       // 析构：先输出 ~D，再自动调 ~Base() 输出 ~B
    void f() override { cout << "Df"; } // 重写虚函数
};
int main() {
    Base* p = new Derived();  // 创建 Derived → B D
    p->f();                   // f() 是 virtual → 动态绑定 → Df
    p->g();                   // g() 非虚 → 静态绑定 → Bg
    delete p;                 // 虚析构 → ~D ~B
}

🏗️ 第 2 章 — 构造、析构、拷贝（三大函数）

对应考题：第12、17、18、23、28、37、42题 | ⭐⭐⭐⭐⭐

2.1 什么是"三大函数"？

每一个 C++ 类都至少需要关注三个特殊函数：构造函数（怎么创建）、析构函数（怎么销毁）、拷贝控制（怎么复制）。如果你不写，编译器会帮你自动生成——但自动生成的版本只做浅拷贝，有指针成员时会造成严重问题。

2.2 编译器悄悄帮你生成的代码

2.3 Rule of Three（三法则）

2.4 浅拷贝 vs 深拷贝 —— 可视化对比

浅拷贝 = 只拷贝指针的值（地址）→ 两个指针指向同一个地方。
深拷贝 = 分配新内存 + 拷贝内容 → 两个指针指向各自的副本。

2.5 String 类完整实现 —— 必背！

class String {
private:
    char *m_data;          // 指向堆上动态分配的字符数组（这才是真正的字符串）

public:
    // ========== ① 普通构造函数 ==========
    // 作用：根据 C 风格字符串创建 String 对象
    String(const char *str = NULL) {   // 默认参数 NULL：也充当了默认构造函数
        if (str == NULL) {             // 如果传入 NULL 或没传参
            m_data = new char[1];      // 分配 1 字节
            m_data[0] = '\0';          // 空字符串（只有结束符）
        } else {
            m_data = new char[strlen(str) + 1];   // +1 是为了 '\0' 结束符
            strcpy(m_data, str);                  // 把 str 内容拷贝到 m_data
        }
    }

    // ========== ② 拷贝构造函数 ==========
    // 作用：用一个已存在的 String 对象创建新的 String（深拷贝！）
    // 参数必须是 const 引用（不能按值传递，否则会无限递归）
    String(const String &other) {
        m_data = new char[strlen(other.m_data) + 1]; // 分配新内存（不是共享！）
        strcpy(m_data, other.m_data);                 // 拷贝内容
    }

    // ========== ③ 赋值运算符 ==========
    // 作用：把一个 String 对象的内容赋给另一个已经存在的 String
    // 四步走：一看（自赋值）→ 二清（释放旧）→ 三拷（分配+拷贝）→ 四返（return *this）
    String& operator=(const String &other) {
        // 第1步：防止自赋值（s = s 这种操作）
        if (this == &other) return *this;

        // 第2步：释放自己原来持有的旧内存（否则会泄漏）
        delete[] m_data;   // 注意是 delete[] 不是 delete（因为是 char 数组）

        // 第3步：分配新内存并拷贝
        m_data = new char[strlen(other.m_data) + 1];   // 新内存
        strcpy(m_data, other.m_data);                   // 拷贝内容

        // 第4步：返回 *this（支持链式赋值 a = b = c）
        return *this;
    }

    // ========== ④ 析构函数 ==========
    // 作用：对象销毁时释放它持有的堆内存
    ~String() {
        delete[] m_data;   // new[] 必须配 delete[]！否则 undefined behavior
    }
};

// ❌ 错误写法：按值传递（pass-by-value）
String(const String other) { ... }
// 问题：为了把实参传给形参 other，编译器需要拷贝实参
// → 拷贝需要调用拷贝构造函数 → 又要传形参 → 又要拷贝 → 无限递归！

// ✅ 正确写法：按引用传递（pass-by-reference）
String(const String &other) { ... }
// 引用不触发拷贝——只是给原对象起了个别名

int* a = new int;        // 单个 int
delete a;                // ✅ 配 delete

int* b = new int[10];    // int 数组
delete[] b;              // ✅ 配 delete[]（不能漏掉 []）

char* c = new char[100]; // char 数组
delete c;                // ❌ 错误！应该用 delete[] c
// 后果：只释放了第一个元素，剩下的 99 个字节泄漏

2.6 第37题 — 浅拷贝导致的内存泄漏 + 双重释放

问题代码：Person 类有指针成员 pFirstName，但没有写拷贝构造和赋值运算符。编译器生成默认版本 → 浅拷贝。

Person Mike("Mike", 25);   // Mike.pFirstName 指向 "Mike"
Person John("John", 30);   // John.pFirstName 指向 "John"

Mike = John;               // ⚠️ 默认赋值运算符 = 浅拷贝！
// 发生了什么：
// 1. Mike.pFirstName 现在指向 "John"（和 John.pFirstName 一样）
// 2. 原来 Mike.pFirstName 指向的 "Mike" 没有被释放 → 内存泄漏！
// 3. 两个对象的 pFirstName 指向同一块内存 "John"
// 4. 析构时两次 delete[] 同一块内存 → 双重释放 → 程序崩溃！

Person& Person::operator=(const Person& rhs) {
    if (this == &rhs) return *this;          // 防止自赋值
    delete[] pFirstName;                      // 释放旧内存（解决泄漏）
    pFirstName = new char[strlen(rhs.pFirstName) + 1]; // 分配新内存
    strcpy(pFirstName, rhs.pFirstName);       // 拷贝内容（深拷贝）
    return *this;
}

📋 第2章自测

📝 第 3 章 — 选择填空题详解

对应考题：第7~33题 | 每道题含原题、选项、答案、详尽解析

👆 速查卡片 · 下拉看每道题的完整解析 👇

int* p = new int(42);    // p 是指针，指向堆上值为42的int
Dog* d = new Dog();      // d 是指针，指向堆上新构造的Dog对象

// 场景A：用对象初始化新对象
ClassA b = a;          // 拷贝构造
ClassA b(a);           // 也是拷贝构造

// 场景B：非引用传参
void func(ClassA obj) { }  // 传参时拷贝实参到形参
func(a);                    // ← 触发拷贝构造

// 场景C：返回非引用对象
ClassA getObj() {
    ClassA tmp;
    return tmp;             // ← 触发拷贝构造（可能被编译器优化RVO）
}

class MyClass {
    friend void show(MyClass& obj);  // 声明为友元，但定义在类外
};
// show 是普通全局函数，不是 MyClass 的成员！

class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数
};
Shape s;  // ❌ 编译错误！抽象类不能实例化

virtual void Display(void) = 0;  // ✅ 正确

// ❌ 错误写法分析：
virtual void Display(void){0};   // {0} 是函数体，这不是纯虚函数！
virtual void Display = 0;         // 缺少参数列表 ()
void Display(void) = 0;           // 缺少 virtual 关键字

class Foo {
public:
    Foo();           // ✅ 正确
    void Foo();      // ❌ 错误！构造函数不能有返回类型
};
// 如果写了 void Foo()，编译器会把它当成普通成员函数！

// ❌ 如果这样写：
String(const String other) { ... }  // 按值传递！
// 为了把实参拷贝到形参 other，又需要调用拷贝构造函数
// → 又进入拷贝构造 → 又要拷贝 → 无限递归！

template <typename T>   // ← 以 template 开头
T max(T a, T b) {
    return a > b ? a : b;
}

class Base { };
class Derived : public Base { };

Base b;  Derived d;

Base* pb = &b;     // A✅ 同类指针
Derived* pd = &b;   // B❌ 编译错误！基类对象不是派生类
Base* pb2 = &d;     // C✅ 向上转型，合法（派生类是基类）
Derived* pd2 = &d;   // D✅ 同类指针

class A {
public:
    ~A();   // 声明
};
A::~A() {   // ✅ 定义：无返回类型，无参数
    // 清理代码
}

try {
    // 可能抛异常的代码  ← try 块
} catch (ExceptionType& e) {
    // 捕获后执行的代码  ← catch 块（本题答案）
}

try {
    int* p = new int[999999999999];  // 内存不够
} catch (bad_alloc& e) {               // ← 捕获 bad_alloc
    cout << "内存分配失败！";
}

class MyClass {
public:
    static int count;  // A✅ 声明时加 static
};
int MyClass::count = 0;  // C✅ 类外引用：类名::成员

// B❌ 为什么不能在类体内初始化？
// 静态成员属于类，不属于对象，必须在类外定义。
// 例外：const static 整型可以在类内初始化（C++11+）
class Foo {
    const static int x = 10;  // 特例，可以
};

// D❌ 静态成员是所有对象共享的！这是它的核心特性。

void Set(A &a) {
    // a 是引用，操作 a 就是操作实参本身
    // 不需要 *，不像指针
}

int x = 10;
int& r = x;      // 引用：r 就是 x 的别名
r = 20;           // 等价于 x = 20，无需 *

int* p = &x;     // 指针
*p = 30;          // 需要 * 解引用
p = &y;          // 可以指向别的变量
// r = y;        // ❌ 不能改引用绑定！这会把 y 的值赋给 r(即x)

#include <iostream>
class Base{
public:
    void fun(){ cout << "Base::fun" << endl; }
};
class Derived : public Base{
    void fun(){
        ____________ //显式调用基类的函数fun()
        cout << "Derived::fun" << endl;
    }
};

class complex {
public:
    static int w;         // 静态成员：所有对象共享一份
    int i;                // 普通成员：每个对象独立
    complex() { i = ++w; }
};
int complex::w = 1;       // 类外初始化，w = 1

int main() {
    complex a, b, c;      // 连续构造 3 个对象
    cout << a.w << " " << b.i << endl;
}

int z = 15;
int& f() { return z; }   // 返回 z 的引用（别名）
int main() {
    f() = 20;             // 等价于 z = 20
    cout << z;
    return 0;
}

template <class T>
T maximum(T value1, T value2) {
    if (value1 > value2) return value1;
    else return value2;
}

💻 第 4 章 — 编程题实战

对应考题：第3、38、39、40、42、43题 | ⭐⭐⭐⭐

4.1 第3题：输入验证 + 求平方

题目：从键盘输入一个整数，求它的平方。要求做容错处理（检查输入的是否真的是数字）。

解题思路：读入字符串 → 逐字符检查是否全为数字 → 转换 → 计算。不能直接用 cin >> int，因为那不会检查输入是否正确。

#include <iostream>   // cin, cout：输入输出
#include <string>     // string 类型：存储用户输入
#include <cctype>     // isdigit()：判断字符是否为数字 '0'~'9'
using namespace std;

int main() {
    string input;                              // 用字符串接收输入（而不是 int）
    cout << "请输入一个整数：";
    cin >> input;                              // 用户输入存到 input

    // === 检查1：是否为空 ===
    if (input.empty()) {                       // input.empty() 检查字符串是否有内容
        cout << "错误：输入为空！" << endl;
        return -1;                             // 非0返回值表示程序异常退出
    }

    // === 检查2：处理负号 ===
    // 如果第一个字符是 '-'，说明是负数，从第二个字符开始检查
    int start = (input[0] == '-') ? 1 : 0;     // 三元运算符：有负号则 start=1
    if (start == 1 && input.length() == 1) {   // 只有一个 '-' 没有数字
        cout << "错误：请输入有效整数！" << endl;
        return -1;
    }

    // === 检查3：逐字符判断是否全为数字 ===
    for (int i = start; i < input.length(); i++) {
        if (!isdigit(input[i])) {              // isdigit() 检查字符是否为 '0'~'9'
            cout << "错误：包含非数字字符！" << endl;
            return -1;                         // 发现非数字立即退出
        }
    }

    // === 所有检查通过，安全转换 ===
    int num = stoi(input);                     // stoi: string → int 转换
    cout << num << " 的平方是：" << num * num << endl;
    return 0;                                  // 0 表示程序正常结束
}

4.2 第38题：数组最大值模板函数

题目：编写求数组最大值的模板函数。
提示：模板函数 = 把类型当作参数，写一次代码，int、char、double 都能用。

template <typename T>       // template 关键字 + 类型参数 T（就像一个占位符）
T arrMax(T arr[], int n) { // 返回类型 T、参数类型 T 都由调用者决定
    T maxVal = arr[0];     // 假设第一个元素是最大值
    for (int i = 1; i < n; i++) {   // 从第二个元素开始遍历
        if (arr[i] > maxVal) {      // 如果当前元素更大
            maxVal = arr[i];        // 更新最大值
        }
    }
    return maxVal;          // 遍历结束，返回找到的最大值
}

// ===== 调用示例 =====
int main() {
    int arr1[] = {10, 20, 15, 12};
    int n1 = sizeof(arr1) / sizeof(arr1[0]); // 计算数组长度：总字节/单元素字节

    char arr2[] = {1, 2, 3};                 // char 也能比较，因为内部转成整数比较
    int n2 = sizeof(arr2) / sizeof(arr2[0]);

    cout << arrMax<int>(arr1, n1) << endl;  // T=int，找出 int 数组中最大的 → 20
    cout << arrMax<char>(arr2, n2);          // T=char，找出 char 数组中最大的 → 3
    return 0;
}

4.3 第39题：文件读写

题目：编写程序读取 example.txt 的内容并显示。

概念：fstream 是 C++ 用来读写文件的库。有两种流：ofstream（output，写文件）和 ifstream（input，读文件）。

#include <iostream>   // cout 输出到屏幕
#include <fstream>    // ifstream, ofstream：文件读写
#include <string>     // string 类型
using namespace std;

int main() {
    // === 打开文件 ===
    ifstream infile("example.txt");            // ifstream: 输入文件流，用于读取
    if (!infile.is_open()) {                   // is_open() 检查文件是否成功打开
        cout << "无法打开文件！" << endl;       // 文件不存在或没权限
        return -1;
    }

    // === 逐行读取并输出 ===
    string line;                               // 存储每一行内容
    while (getline(infile, line)) {            // getline: 读一行到 line
        cout << line << endl;                // 输出到屏幕
    }   // 当读到文件末尾，getline 返回 false，循环自动结束

    // === 关闭文件 ===
    infile.close();                            // 释放文件资源（好习惯）
    return 0;
}

4.4 第43题：Stack 类模板（栈）

题目：实现一个泛型栈（后进先出，LIFO），支持 push、pop、peek、扩容。
栈 Stack：就像一摞盘子——最后放上去的，最先拿下来。

#include <iostream>
#include <stdexcept>        // underflow_error：栈空时抛出的异常类型
using namespace std;

template <typename T>       // 模板：T 是栈中存储的元素类型
class Stack {
private:
    T* data;                // 指向动态分配的数组，存放栈中元素
    int top;                // 栈顶索引（空栈 = -1，栈非空 = 最上面元素的位置）
    int capacity;           // 数组当前容量（满了就扩容）

    // --- 扩容函数（private，只有 push 内部调用）---
    void resize() {
        capacity *= 2;                         // 容量翻倍（*2 是高效策略）
        T* newData = new T[capacity];          // 分配更大的新数组
        for (int i = 0; i <= top; i++) {       // 把旧数据拷贝到新数组
            newData[i] = data[i];
        }
        delete[] data;                         // 释放旧数组内存（配 new[] 用 delete[]）
        data = newData;                        // data 指向新数组
    }

public:
    // --- 构造函数：初始化空栈 ---
    Stack(int cap = 8)                         // 默认容量 8
        : top(-1), capacity(cap) {             // 初始化列表：top 从 -1 开始（空栈）
        data = new T[capacity];                // 在堆上分配数组内存
    }

    // --- 析构函数：释放分配的内存 ---
    ~Stack() {
        delete[] data;                         // new[] 必须配 delete[]
    }

    // --- 入栈 push：把一个元素放到栈顶 ---
    void push(T value) {
        if (top + 1 >= capacity) {             // 栈满了吗？（top+1 = 当前元素个数）
            resize();                          // 满了就扩容
        }
        data[++top] = value;                   // 先 ++top（向上移），再把 value 放进去
    }

    // --- 出栈 pop：移除并返回栈顶元素 ---
    T pop() {
        if (top < 0) {                         // 栈空 = top == -1
            throw underflow_error("Stack is empty"); // 抛异常通知调用者
        }
        return data[top--];                    // 返回 data[top]，然后 top--（下移）
    }

    // --- 查看栈顶 peek：只看不删 ---
    T peek() const {                           // const：承诺不修改栈内容
        if (top < 0) {                         // 同样是空栈检查
            throw underflow_error("Stack is empty");
        }
        return data[top];                      // 直接返回，不修改 top
    }

    // --- 获取当前元素个数 ---
    int getSize() const { return top + 1; }    // top 是索引，个数 = top + 1

    // --- 输出运算符重载：从栈顶到栈底打印 ---
    // friend 友元函数：不是成员函数但可以访问私有成员 data、top
    friend ostream& operator<<(ostream& os, const Stack<T>& s) {
        for (int i = s.top; i >= 0; i--) {     // 从栈顶向下遍历
            os << s.data[i];                   // 输出当前元素
            if (i > 0) os << " ";              // 元素之间用空格分隔（最后一个不加空格）
        }
        return os;                             // 返回 ostream 引用，支持链式调用
    }
};

⚠️ 第 5 章 — 常见陷阱与易错题

对应考题：第31、32、35、36、37、41题 | ⭐⭐⭐

5.1 野指针（第36题）—— free 后指针不会自动变 NULL

野指针（Dangling Pointer）：指针指向的内存已经被释放了，但指针还保存着那个地址。 这时再通过这个指针读写 = 未定义行为，后果不可预测（可能崩溃、可能篡改其他数据）。

#include <cstdlib>   // malloc, free：C 语言风格的内存分配/释放
#include <cstring>   // strcpy：字符串拷贝
#include <cstdio>    // printf：打印输出

int main() {
    char *str = (char *)malloc(100);           // 在堆上申请 100 字节内存
    strcpy(str, "hello");                      // 把 "hello" 拷贝到 str 指向的内存中
    free(str);                                 // 释放 str 指向的内存（还给操作系统）

    // ⚠️ 下面是大坑！free 之后 str 仍然指向原来的地址！
    // free() 只释放内存，不修改指针变量的值
    if (str != NULL) {                         // str 不是 NULL！它还是原来的地址值 0x...
        strcpy(str, "world");                  // 💥 往已释放的内存写数据！非常危险！
        printf(str);                           // 读取已释放的内存，输出什么不可预知
    }
    // 正确做法：free(str); str = NULL; ← 手动置空
    return 0;
}

free(str);
str = NULL;       // 必须手动置空！否则 str 就是野指针

delete ptr;
ptr = nullptr;    // C++ 推荐用 nullptr 代替 NULL

5.2 私有成员不能外部访问（第41题）

访问控制：C++ 用 private（私有）、protected（保护）、public（公有）控制谁能访问成员。 这叫做封装——把内部细节藏起来，只暴露必要的接口。

class Person {
private:                       // private：只有类内部的函数可以访问
    double height;             // 这个数据对外部是隐藏的

public:                        // public：任何人都可以访问
    void setHeight(double h) { // 通过这个公有函数间接修改 height
        height = h;
    }
    double getHeight() {       // 通过这个公有函数间接读取 height
        return height;
    }
};

int main() {
    Person p;
    p.height = 1.85;           // ❌ 编译错误！height 是 private，外部不能直接访问
    p.setHeight(1.85);         // ✅ 通过 public 函数设置
    cout << p.getHeight();     // ✅ 通过 public 函数读取
    return 0;
}

记忆：private 是秘密（只有自己知道），protected 是家传（儿子也知道），public 是公开的（谁都知道）。

5.3 异常处理（第35题）—— try / throw / catch

异常处理：当程序遇到意外情况（如除零、内存不足）时， 不直接崩溃，而是"抛出"一个异常，让专门的代码去"捕获"和处理它。

class DivideZero {                             // 自定义异常类
public:
    DivideZero() : out("EXCEPTION: Division by zero attempted.") {}
    string display() const { return out; }     // 返回错误信息
private:
    string out;
};

double arithmetic(int n, int d) {
    if (d == 0)
        throw DivideZero();                    // 💥 分母为0，抛出异常（函数直接返回）
    return static_cast<double>(n) / d;          // 安全时正常计算
}

int main() {
    try {                                      // try：监控这段代码
        cout << arithmetic(24, 6) << endl;   // d=6 ≠0 → 正常 → 输出 4
        cout << arithmetic(1, 3) << endl;    // d=3 ≠0 → 正常 → 输出 0.333...
        cout << arithmetic(9, 0.0) << endl;  // d=0 → 抛出 DivideZero 异常！
        // ⚠️ 抛异常后，下面这行不会执行！
        cout << "这行不会输出" << endl;
    }
    catch (DivideZero &e) {                    // catch：捕获 DivideZero 类型的异常
        cout << e.display() << endl;         // 打印错误信息
    }
    // catch 执行完后，程序继续从这里往下走
    return 0;
}

// 最终输出:
//   4
//   0.333333
//   EXCEPTION: Division by zero attempted.

5.4 static 成员（第31题）—— 所有对象共享一份

static 成员：属于类本身，不属于任何一个对象。 不管创建多少个对象，static 成员在内存中只有一份，所有对象共享。

class complex {
public:
    static int w;          // static 成员：所有对象共享（类内声明）
    int i;                 // 普通成员：每个对象独立一份

    complex() {
        i = ++w;           // 构造时：w 先自增，再把新值赋给 i
    }
};

int complex::w = 1;        // static 成员必须在类外定义+初始化

int main() {
    complex a, b, c;       // 连续创建三个对象
    // a 构造: w 从 1 变成 2 → a.i = 2
    // b 构造: w 从 2 变成 3 → b.i = 3
    // c 构造: w 从 3 变成 4 → c.i = 4

    cout << a.w << " " << b.i << endl;
    // a.w 输出 4（所有对象读到同一个 w，最终值是 4）
    // b.i 输出 3（b 自己的 i 在构造时赋的值）
    return 0;
}

5.5 引用作为返回值（第32题）—— 函数调用可以出现在 = 左边

引用返回 vs 值返回：值返回是"给你一个副本"，引用返回是"给你原件本身"。 因为返回的是原件，所以可以赋值。

int z = 15;               // 全局变量

int& f() {                // 返回类型是 int&（int 的引用，即 int 的别名）
    return z;             // 返回 z 的引用，不是 z 的副本
}

int main() {
    f() = 20;             // 等价于 z = 20！因为 f() 返回的就是 z 本身
    cout << z;           // 输出 20（z 已经被改了）
    return 0;
}

🏆 终极自测

下面代码犯了 5 个错误，你能全部找出来吗？（对应第37题和第42题的考点）

class Resource {
    char* buffer;                              // 指针成员：管理堆内存
public:
    Resource(const char* str) {
        buffer = new char[strlen(str)];        // ❌ 问题1: 没有 +1，'\0' 会溢出
        strcpy(buffer, str);                   // 拷贝字符串到 buffer
    }
    ~Resource() { delete buffer; }             // ❌ 问题2: new[] 应配 delete[]
    // ❌ 问题3/4/5: 没有写拷贝构造和赋值运算符 = 违反 Rule of Three
};
int main() {
    Resource a("hello");                       // 构造 a
    Resource b = a;                            // ❌ 问题3: 默认拷贝构造 → 浅拷贝
    b = a;                                     // ❌ 问题4: 默认赋值运算 → 内存泄漏
                                               // ❌ 问题5: 以上导致析构时双重释放
}