课程：Stanford CS106L “Standard C++ Programming”（2026 春季学期） 讲师：Rachel Fernandez、Preston Seay（cs106l-spr2526-staff@lists.stanford.edu） 课程主页：https://web.stanford.edu/class/cs106l/（存档页：https://web.stanford.edu/class/archive/cs/cs106l/cs106l.1266/） 上课时间：周二、周四 15:00–16:20，Thornton 110 课程性质：1 学分（S/NC），第 8 周结束正式课程，共 7 个短作业、无考试 本笔记依据：课程主页公开日程表、全部 17 份公开讲座幻灯片（PDF）、公开的课堂代码仓库（cs106l-lecture-code）与作业仓库（cs106l-assignments）

课程概览（About CS106L）

课程目标与定位

🌽 CS106L 是一门深入探索现代 C++ 语言的 1 学分课程。 与 CS106B 等”用 C++ 讲概念”的课程不同，CS106L 关注的是代码本身：什么是好的、强大而优雅的 C++ 代码。课程覆盖现代 C++ 中最激动人心的特性，包括现代编程范式（直至 C++26），并只使用标准库（STL），不依赖任何 Stanford 私有库——让你真正理解 C++ 是如何被设计出来的，以及为什么。

• 🥦 先修要求：正在学习或已学过 CS106B/X（或同等水平），即已掌握函数、对象/类等编程基础。
• 🥕 课程形式：7 个非常简短的周作业（每个约 1–2 小时，周五发布、下周五截止，共 3 个免费晚交天数）。作业不追求难度，而是对上周课堂概念的动手练习。无考试、无论文，全部 S/NC 评分。
• 🏢 答疑（Office Hours）：对所有人开放，第 3 周开始。周四 16:30–17:20（Thornton 210）、周三 15:00–15:50（160-B37）。

为什么学 C++？

• C++ 是”一切事物的隐形地基”：游戏引擎（Valorant、CS2）、高频交易、自动驾驶、Arduino、GPU 编程、数据库（MySQL、MongoDB）、浏览器（Chrome）、VR（Quest）、底层 ML 框架（PyTorch、TensorFlow）、编译器/虚拟机（LLVM、GCC、JVM）、操作系统（Windows、macOS、Linux）……
• C++ 于 1985 年首次发布，至今仍稳居 TIOBE 指数前三（2026 年 3 月数据）；标准每三年修订一次：C++98 → C++03 → C++11 → C++14 → C++17 → C++20 → C++23 → C++26。
• C++ 帮助养成优秀的”编码卫生”：类型检查与类型安全、引用/拷贝/移动语义下的内存效率、const 正确性——这些限制正是许多其他语言所放宽的。

C++ 设计哲学（本笔记贯穿始终的准绳）

1. 直接在代码中表达想法与意图（express ideas and intent directly in code）。
2. 尽可能在编译期强制安全（enforce safety at compile time whenever possible）。
3. 不浪费时间和空间（do not waste time or space）。
4. 封装杂乱的结构（compartmentalize messy constructs）。
5. 把完全的控制、责任与选择权交给程序员（allow the programmer full control, responsibility, and choice）。

“Code should be elegant and efficient; I hate to have to choose between those.” —— Bjarne Stroustrup

学习方法建议

• 本笔记每讲严格按”概述 → 核心特性与语法详解 → 代码示例与逐步解说 → 与旧标准对比 → 关键要点 → 常见陷阱 → 关联作业提示“七段式组织；代码示例均标注所需 C++ 标准（C++11/14/17/20/23/26）且尽可能可直接编译运行。
• 建议：先通读概述与关键要点，再精读语法详解，最后动手编译运行每个代码示例，对照”特性机制解说”理解底层机制。
• 常用参考：https://en.cppreference.com（官方标准参考，课程推荐）；Godbolt Compiler Explorer（https://godbolt.org）用于观察编译产物。

课程日程表（Schedule）

作业总览（Assignments）

访问性说明：作业详细文档、练习视频、答题平台（Paperless、Ed、Canvas 内页）等需要斯坦福账号登录，未公开。本笔记主要依据课程主页公开的日程表、主题描述、公开幻灯片与公开 GitHub 代码仓库构建知识框架。

Lecture 1 (Week 1 - Tuesday): 欢迎与课程概览 (Welcome!)

概述

本讲是 CS106L（Stanford 的《Standard C++ Programming》，Spring 2026，教学语言为现代 C++，覆盖 C++26）的开篇课：讲师自我介绍、课程定位与评分方式，并用大量真实案例回答”为什么要学 C++”。核心内容包含三块：C++ 的历史与设计哲学（Readable、Safety、Efficiency、Abstraction、Programmer Choice 五大支柱）、”同一段 Hello World 在 C++ 中可以有汇编层 / C 层 / 现代 C++ 层三种写法”的语言分层观，以及整个学期的知识地图。

本讲没有新语法，但建立了一个贯穿全课程的心智模型：C++ 是编译型、静态类型的语言，既追求效率又追求代码的优雅与可读性。课程以现代标准（C++11 之后直至 C++26）为教学语言，全部作业只使用标准库（STL）——不依赖 Stanford 自制库。最后一部分是课程后勤：讲座时间与签到、8 个每周作业、S/NC 评分规则与联系方式，务必记牢。

核心特性与语法详解

本讲是概念课，这里把”核心特性”理解为支撑后续所有讲座的语言世界观与基本构件。

• C++ 设计哲学（Bjarne Stroustrup 的五大原则）
  • 定义与目的：这是理解 C++ 一切设计的钥匙——为什么 C++ 有那么多”看上去很麻烦”的规则。
  • 核心内容：
    1. Express ideas and intent directly in code（直接在代码中表达思想与意图）；
    2. Enforce safety at compile time whenever possible（尽可能在编译期强制安全）；
    3. Do not waste time or space（不浪费时间和空间——零开销原则）；
    4. Compartmentalize messy constructs（把丑陋的细节封装隔离，如内存管理）；
    5. Allow the programmer full control, responsibility, and choice（把控制权、责任与选择权交给程序员）。
  • 设计意图与最佳实践：Bjarne 的名言 “Code should be elegant and efficient; I hate to have to choose between those” 是课程灵魂——后续每讲（类型、引用、模板、移动语义……）都可以用这五条来解释”为什么语言要这样设计”。
• C++ 的三种”合法程序”（语言分层观）
  • 定义与目的：同一个任务，C++ 里可以写出汇编级、C 级、现代 C++ 级三种代码，且全部合法。这体现了 C++ 对 C 的向后兼容（backwards compatible）以及”程序员选择权”。
  • 核心语法：现代 C++ 版 auto str = std::make_unique<std::string>("Hello World!");；C 版 printf("%s", "Hello, world!\n");；汇编版 asm("..."); 内联汇编。
  • 设计意图与最佳实践：你写的是哪一层，取决于需求（性能关键区 vs 业务逻辑）。CS106L 教的是现代 C++ 层——安全、可读、高效三者的平衡点。
• 现代 C++ 的几大语言构件（本讲先”混个脸熟”）
  • 定义与目的：幻灯片用一行 Hello World 串起了本课程的核心主题。
  • 核心语法：
    • 流与运算符重载：std::cout << *str << std::endl;
    • 模板与类型推导：std::make_unique<std::string>(...)、auto
    • 智能指针：std::unique_ptr（RAII，自动管理内存）
    • 命名空间：std:: 前缀
  • 设计意图与最佳实践：这些构件将在第 3 讲（初始化与引用）、第 4 讲（流）、第 11-12 讲（智能指针）逐一展开，本讲只需认识它们的”长相”。
• C++ 标准演进史（C++98 → C++26）
  • 定义与目的：C++ 自 1979 年起步、1985 年首次发布，至今仍是 TIOBE 前三的语言；标准委员会每三年修订一次标准。
  • 核心内容：1979（前身）→ 1983（C++ 诞生）→ 1998（C++98 首次标准化）→ 2003（C++03）→ 2011（C++11，现代 C++ 起点）→ 2014 → 2017 → 2020 → 2023 → 2026（We are here!）。
  • 设计意图与最佳实践：本课程以 C++11 之后（含 C++26 新特性）的”现代 C++”为教学语言；编译时通常用 -std=c++20 或更新标准。
• C++ 与 C 的历史关系
  • 定义与目的：1972 年 Dennis Ritchie 创造 C（快、简单、跨平台），但缺少对象/类、泛型/模板能力，写大型程序繁琐；1983 年 Bjarne Stroustrup 在 C 的基础上创造了 C++，目标是快 + 简单 + 跨平台 + 高层特性。
  • 设计意图与最佳实践：理解”汇编的缺点 → C 的诞生 → C 的缺点 → C++ 的诞生”这条演进线，就知道 C++ 为什么”既要效率又要抽象”。
• 编译型语言的执行模型（预告）
  • 定义与目的：C++ 是编译型语言：编译器先把整个程序翻译成机器码打包成可执行文件，再运行；因此有”编译期（compile time）”与”运行期（run time）”两个阶段。错误尽可能在编译期被发现（详细对比见 Lecture 2）。
  • 设计意图与最佳实践：越早发现错误成本越低——这是”编译期强制安全”哲学的体现。
• 为什么 C++ 无处不在（”The invisible foundation of everything”）
  • 定义与目的：幻灯片列举了大量 C++ 的真实应用场景，回答”为什么值得学”。
  • 核心内容：游戏（Valorant、CS:GO/CS2）、高频交易、自动驾驶、Arduino 嵌入式、GPU 编程、数据库（MySQL、MongoDB）、浏览器（Chrome、Safari、Edge）、虚拟现实（Quest）、底层 ML 框架（PyTorch、TensorFlow）、编译器与虚拟机（JVM、LLVM、GCC）、操作系统（Windows、macOS、Linux）。
  • 设计意图与最佳实践：C++ 擅长处理大量数据、且处理得非常高效、同时保持代码优雅可读；学完 CS106L 后，CS111（操作系统）、CME213（并行计算）、CS143（编译器）、CS144（网络）、CS248A（图形学）、MUSIC256A 等课程都会直接用到 C++。
• 本课程的知识地图（Topics We’ll Cover）
  • 定义与目的：幻灯片给出了整个学期的路线图，帮助你建立全局观。
  • 核心内容：欢迎 → 类型与结构体 → 初始化与引用 → 流 → 容器 → 迭代器与指针 → 类 → 高级类 → 模板 → 高级模板 → 函数与 lambda → 运算符重载 → 特殊成员函数 → 移动语义 → std::optional 与类型安全 → RAII、智能指针 → C++ 项目实践。
  • 设计意图与最佳实践：每讲都有明确的前置依赖（如”移动语义”依赖”特殊成员函数”），按顺序跟进即可；本讲之后的第 2、3 讲（类型与结构体、初始化与引用）是全部内容的语法地基。
• CS106L 与 CS106B 等课程的定位差异
  • 定义与目的：CS106B 等课关注抽象、递归、指针等概念，只用 C++ 的最小集合并重度依赖 Stanford 自制库；CS106L 关注代码本身：只用标准库（STL），理解”好代码长什么样、C++ 为什么这样设计”。
  • 设计意图与最佳实践：CS106L 是 1 学分的”轻松”课程（S/NC 评分），但内容密度高；把注意力从”解决问题”转向”把解决方案写得优雅、正确、高效”。
• 课程后勤要点速览（Course Logistics）
  • 定义与目的：课堂公布的管理规则，直接影响你的学分，值得抄进笔记。
  • 核心内容：
    • 讲座：每周二、四 15:00–16:20，Thornton 110；讲座不录像；从第 2 周起每次开讲有 1-2 道签到小测，每人有 2 次免签到额度；签到二维码只出现在前 10 分钟幻灯片上；
    • 生病/特殊情况：身体不适请留在家里并通过邮件/Ed 告知，绝不要求带病上课；
    • Office Hours：第 2 周前公布（线下），欢迎来聊天提问；
    • 作业：8 个每周小作业（每个 1-2 小时），周五发布、下周五截止，每人有 3 个免费晚交日；
    • 评分：S/NC（通过/不通过）——第 2 到第 9 周 14 次讲座中出勤 12 次 + 完成全部 8 个作业，即可拿到 S；
    • 联系方式：cs106l-spr2526-staff@lists.stanford.edu（课程统一邮箱）、Ed 论坛（经 Canvas 加入）、课后或 OH 面谈。
  • 设计意图与最佳实践：出勤与作业是硬指标，建议把”每讲扫码 + 每周五查作业”设为固定日程；有问题优先走 Ed 公开提问（他人也能受益）。
• 工具链与编译（Toolchain）
  • 定义与目的：C++ 是编译型语言，写代码 → 编译 → 运行三步走；课堂上还用 godbolt.org 做了”编译器到底生成了什么汇编”的现场演示。
  • 核心语法：g++ -std=c++20 main.cpp -o main 然后 ./main。
  • 设计意图与最佳实践：A1 起所有作业都用这个流程；用 -std=c++20（本课程教学标准）而非默认的旧标准；想理解”为什么 C++ 高效”，可以去 godbolt.org 看你的代码对应的汇编。

代码示例与逐步解说（核心）

示例 1：现代 C++ Hello World（C++14，改写自课堂幻灯片）

#include <iostream>
#include <memory>
#include <string>

int main() {
    // make_unique 返回一个 std::unique_ptr<std::string>
    auto str = std::make_unique<std::string>("Hello World!");
    std::cout << *str << std::endl;   // 解引用智能指针，输出字符串
    return 0;
}
// Prints "Hello World!"

代码做什么：

• #include <memory>、<string>：引入智能指针与字符串类型；
• std::make_unique<std::string>("Hello World!")：在堆上构造一个 std::string，返回管理它的 std::unique_ptr；
• auto str = ...：让编译器从右侧表达式的类型推导出 str 的类型（std::unique_ptr<std::string>）；
• *str 解引用得到字符串，<< 运算符把它送到标准输出，std::endl 换行并刷新缓冲区；
• 函数结束、str 析构时，智能指针自动 delete 堆内存——不需要手写 delete。

特性机制解说：

• std::unique_ptr 是 RAII（Resource Acquisition Is Initialization）思想的典型代表：内存的释放绑定在对象的析构上，杜绝 new/delete 配对遗漏导致的内存泄漏；
• auto 是编译期完成的类型推导，str 的类型在编译时就固定为 std::unique_ptr<std::string>（静态类型，不是 Python 式的动态类型）；
• << 之所以能作用于自定义类型，靠的是运算符重载——标准库为 std::ostream 重载了针对各种类型的 operator<<。

示例 2：同一程序的三层写法对比（C++98 兼容 / 现代 C++）

// ① C 风格（C++ 向后兼容 C，这是合法的 C++ 程序）
#include <cstdio>
int main() {
    printf("%s\n", "Hello, world!");   // 调用的是 C 函数 printf
    return 0;
}

// ② 现代 C++ 风格
#include <iostream>
int main() {
    std::cout << "Hello, world!" << std::endl;   // 类型安全的流输出
    return 0;
}

代码做什么：两段程序输出完全相同，但实现机制迥异——printf 依赖格式字符串与可变参数（类型错误在编译期检查很弱），std::cout << 则通过重载在编译期确定与类型匹配的输出函数。

特性机制解说：这是”C++ 是 C 的超集”的直接证据：printf、C 风格头文件、甚至内联汇编在 C++ 中都合法（幻灯片展示了一个用 asm(...) 写 Hello World 的极端例子）。这给了程序员选择权（设计哲学第 5 条），但也意味着 C++ 需要更强的自律——所以本课程强调类型安全与现代写法。

示例 3：现代 C++ 的”优雅 + 高效”小示例（C++11）

#include <iostream>
#include <string>
#include <vector>

int main() {
    std::vector<std::string> names = {"Valorant", "MySQL", "LLVM"};
    // range-based for：C++11 起的新特性，遍历容器
    for (const auto& name : names) {
        std::cout << name << " is built with C++!" << std::endl;
    }
    return 0;
}

代码做什么：创建一个字符串向量，用 range-based for 遍历并逐行输出。

特性机制解说：

• std::vector 是标准库容器，自动管理动态数组内存；
• const auto& name 表示”以常量引用方式读取每个元素”——不复制字符串（高效），同时保证不修改（安全）。这正是 Lecture 3 将要详细讲解的引用与 const 的提前亮相；
• 这一行代码同时体现了五大设计哲学中的 Readable（可读）、Safety（const）、Efficiency（引用避免拷贝）。

示例 4：手动内存管理 vs RAII 智能指针（C++98 风格 vs 现代风格）

// ① C++98 风格：手动 new/delete，容易泄漏
#include <iostream>
#include <string>
int main() {
    std::string* s = new std::string("Hello");
    std::cout << *s << std::endl;
    delete s;                 // 忘记 delete 或提前 return 都会泄漏
    return 0;
}

// ② 现代风格（C++11/14）：unique_ptr 自动管理，无需手动 delete
#include <iostream>
#include <memory>
#include <string>
int main() {
    auto s = std::make_unique<std::string>("Hello");
    std::cout << *s << std::endl;   // 离开作用域时自动释放内存
    return 0;
}

代码做什么：两段代码都在堆上创建字符串并输出，区别只在内存如何释放。

特性机制解说：

• ① 中一旦中间逻辑 return 或抛出异常，delete 永远执行不到，内存泄漏；程序员必须手工保证每条路径都释放——这正是 C++98 时代最普遍的 bug 来源；
• ② 中 std::unique_ptr 在析构时自动释放所拥有的堆对象（RAII），所有权转移、异常安全都由类型系统保证，代码更短且不可能”忘记释放”；
• 这一对比就是设计哲学第 4 条”Compartmentalize messy constructs（封装丑陋细节）”的活教材——把内存管理的脏活交给库，程序员专注业务逻辑。

示例 5：基础输入输出——流的预告（C++11）

#include <iostream>
#include <string>

int main() {
    std::string name;
    std::cout << "What's your name? ";   // 输出提示
    std::cin >> name;                    // 从标准输入读取一个词
    std::cout << "Welcome to CS106L, " << name << "!" << std::endl;
    return 0;
}
// 输入：Ada  →  输出：Welcome to CS106L, Ada!

代码做什么：先打印提示，再从键盘读取字符串，最后输出欢迎语。

特性机制解说：

• std::cin 是标准输入流，>> 运算符从流中提取数据到变量——与 std::cout << 方向相反；
• >> 按空白分隔读取，只读一个词（想读整行要 std::getline，Lecture 4 详讲）；
• 流（stream）是 C++ 标准库最重要的抽象之一，第 4 讲整讲展开；A1 读 CSV 文件就靠它。这一行 std::cin >> name 就是”输入 → 程序 → 输出”最小闭环，也是你验证工具链的最佳练习。

与旧标准（如C++98）的对比

• C++98 时代没有 auto 类型推导：auto 在 C++98 中是存储类说明符（如 auto int x = 1;），毫无用处；现代 auto 的推导语义是 C++11 才引入的。
• C++98 没有智能指针：必须手动 new/delete，一旦忘记 delete 或异常路径泄漏，就产生内存泄漏；std::unique_ptr（C++11）与 std::make_unique（C++14）让”裸指针所有权”问题大幅减少。
• C++98 没有 range-based for、没有 nullptr、没有 lambda：遍历容器要写 for (size_t i = 0; i < v.size(); ++i) 或迭代器循环，代码更长、更容易出错。
• 标准演进节奏：C++98 后十年停滞（2003 只是小修补），直到 2011 年 C++11 带来”现代 C++”大爆炸；此后每三年一个版本（14/17/20/23/26）。本课程站在 C++26 的视角教学，但核心概念（引用、const、struct）从 C++98 就有，只是表达方式不断进化。
• 一个 C++98 时代的 Hello World 长这样：

// C++98 典型写法：无 auto、无智能指针、手动管理
#include <iostream>
#include <string>
int main() {
    std::string* str = new std::string("Hello World!");
    std::cout << *str << std::endl;
    delete str;                       // 记得手动释放
    return 0;
}

对比本讲示例 1 的现代写法：类型名改为 auto、堆对象交给 std::unique_ptr、无需 delete。功能等价，但现代版更短、更安全、更不易错——这就是”标准每三年进步一次”带来的实际收益。

关键要点

• C++ 的五大设计哲学：可读、安全、高效、抽象、程序员选择——这是解释一切语言特性的总纲。
• C++ 是编译型、静态类型的语言，编译期会尽可能多地发现错误，且运行效率高（”不浪费时间和空间”）。
• C++ 向后兼容 C，同一任务存在汇编/C/现代 C++ 多层写法；本课程只教现代 C++ 写法。
• C++ 标准每三年一版（C++98 → … → C++26），本课程以现代标准（覆盖 C++26）为教学语言。
• 课程产出：掌握 STL、理解”好代码长什么样”，培养类型安全、内存高效、const 正确的编码习惯——这正是 CS107/CS111 等后续课程与工业界的需要。
• C++ 应用遍布”看不见的地基”：操作系统、浏览器、数据库、游戏、自动驾驶、ML 框架、编译器——学它不是为了应试，而是为了能读懂和写出这个世界的基础设施。

常见陷阱与注意事项

• 忘记 std:: 前缀：cout、string 都是 std 命名空间里的名字，不写 std:: 且没有 using namespace std; 就无法编译；写 using namespace std; 虽省事，但会引入歧义（见 Lecture 2），是公认的坏风格。
• 忘记 #include 对应头文件：用 std::cout 要 #include <iostream>，用 std::string 要 #include <string>，用 std::unique_ptr 要 #include <memory>；头文件缺失的报错信息往往令人困惑。
• 用 C 风格习惯写现代 C++：如用 printf + 裸指针 + 手动 new/delete。不是不能编译，而是放弃了类型安全与 RAII 的保护。
• 混淆”合法”与”推荐”：内联汇编、C 风格写法在 C++ 中合法，但几乎从不是好选择；课程的评判标准是”现代、优雅、正确”。
• 以为 auto 是动态类型：auto 推导出的类型在编译期就固定，之后不能再改变（auto i = 1; i = "hello"; 是编译错误）——细节在 Lecture 2 展开。
• 误用 std::endl 的时机：std::endl 会刷新缓冲区（flush），在大量输出循环里用 '\n' 更快——”不浪费时间和空间”从这些细节开始。
• 忽略编译警告：编译器是你的朋友。养成读警告、g++ -Wall -Wextra 编译的习惯，很多运行期 bug 在编译期就有提示。

关联作业提示

None（本讲无作业）。课程有 8 个每周小作业（每次 1-2 小时），第一个作业（A1: SimpleEnroll）将在第 2 周周五发布。建议：

• 按 A1 说明完成编译器环境搭建（g++ -std=c++20 main.cpp -o main），提前用上面的 Hello World 验证工具链；
• 记住课程评分规则（S/NC：Week 2-9 期间出勤 12/14 次讲座 + 完成全部 8 个作业），每讲开头的签到二维码只在前 10 分钟有效；
• 把本讲”三层写法”的印象留着：A1 的全部代码都要求用现代 C++（struct、引用、流）完成，正是 Lecture 2、3 的内容；
• 可以现在就动手：把示例 1 的现代 Hello World 编译运行一遍，再试试示例 3 的 vector 遍历——工具链顺了，A1 上手就会非常快。

Lecture 2 (Week 1 - Thursday): 类型与结构体 (Types & Structs)

概述

本讲正式进入 C++ 语言本身，核心是回答两个问题：C++ 程序什么时候出错误（编译期 vs 运行期）与 如何组织数据（struct 与 std::pair）。课堂先用 Python 与 C++ 的对比阐明”C++ 是编译型、静态类型语言，错误尽量在编译期暴露”，然后引入 struct 把多个字段捆绑成新类型，用 std::pair 与 using/auto 让代码更简洁。最后以”求解二次方程”的课堂代码 Demo 串起全部知识：std::pair 嵌套返回多值、using 类型别名、auto 类型推导。这些是后续所有讲座的地基。

核心特性与语法详解

• 编译期（Compile Time）vs 运行期（Run Time）
  • 定义与目的：解释型语言（如 Python）逐行翻译、逐行执行，全程都在运行期；编译型语言（如 C++）先把整个源码翻译成机器码打包成可执行文件（编译期），再执行（运行期）。
  • 核心语法：g++ main.cpp（编译）→ ./a.out（运行）。
  • 设计意图与最佳实践：错误发生在哪个阶段决定了代价。Python 的 print("hello" * "world") 会先打印 Running... 再抛 TypeError（运行期才发现）；同样的 std::cout << hello * world 在 C++ 中直接编译失败（error: no match for 'operator*' (operand types are 'std::string' and 'std::string')）。编译期错误 = 免费的错误检查。
• 静态类型（Static Typing）
  • 定义与目的：C++ 中每个变量都必须声明类型，声明后类型不可变；编译器在生成机器码之前就检查类型。
  • 核心语法：int a = 3; / std::string b = "test";。
  • 设计意图与最佳实践：对比 Python（动态类型，d = 106; d = "hello" 合法），C++ 中 int d = 106; d = "hello"; 是编译错误。静态类型带来三点好处：更高效（运行期无需类型标签与检查）、更易理解与推理、错误检查更早更彻底（如 int add_3(int x) 传入字符串在编译期就被拒绝）。
• 内置类型（Built-in Types）
  • 定义与目的：类型是变量的”类别”。C++ 自带基础类型：int（106）、double（71.4）、std::string（”Welcome to CS106L!”）、bool（true/false）、size_t（12，非负，常用于索引与大小）。
  • 核心语法：double b = 3.2 * 5 - 1;（注意：3.2 是 double，所以整条表达式是 double）。
  • 设计意图与最佳实践：注意 int c = 5 / 2; 中整数除法截断，结果是 2 而不是 2.5——这是静态类型下最常见的”意外”之一。
• 函数重载（Function Overloading）
  • 定义与目的：定义同名但参数列表不同的多个函数，编译器根据实参类型选择版本。
  • 核心语法：double axolotl(int x) 与 double axolotl(double x) 可共存。
  • 设计意图与最佳实践：axolotl(2) 选 int 版本返回 5.0（(double)2 + 3）；axolotl(2.0) 选 double 版本返回 6.0（2.0 * 3）。重载解析发生在编译期，是”静态类型”的直接红利。
• struct（结构体）
  • 定义与目的：把多个命名变量捆绑成一个新类型。解决”一个函数如何返回多个值”的根本问题——例如学生 ID 需要同时返回 name、sunet、idNumber。
  • 核心语法：

    #include <string>
    
    struct StanfordID {
        std::string name;    // 字段（field）：有名字有类型
        std::string sunet;
        int idNumber;
    };
    
    int main() {
        StanfordID id;                  // 声明一个结构体变量
        id.name = "THE Stanford Tree";  // 用 '.' 访问字段
        return 0;
    }
    

  • 设计意图与最佳实践：issueNewID() 的返回类型直接写 StanfordID，函数体内构造并 return id; 即可返回”三个值”。THE BIG IDEA：struct 把命名变量捆绑成新类型。
• 列表初始化 / 统一初始化（List Initialization，C++11 起）
  • 定义与目的：用花括号 {} 一次性初始化全部字段，替代逐字段赋值。
  • 核心语法：

    #include <string>
    
    struct StanfordID {
        std::string name;
        std::string sunet;
        int idNumber;
    };
    
    int main() {
        StanfordID tree = { "THE Stanford Tree", "theTREE", 0000002 };  // '=' 可省略
        StanfordID lelandjr { "Leland Stanford Jr", "thejunior", 5430282 };
        return 0;
    }
    

  • 设计意图与最佳实践：值的顺序必须与字段声明顺序一致；= 可选。这是 Lecture 3 的重点（uniform initialization 与窄化转换），本讲先用起来。
• std::pair（标准库的”通用双字段结构体”）
  • 定义与目的：std::pair<T1, T2> 是标准库提供的模板结构体，只有两个字段 first 和 second，用于”任意两个值打包”。
  • 核心语法：

    #include <string>
    #include <utility>
    
    int main() {
        std::pair<std::string, int> dozen { "Eggs", 12 };
        std::string item = dozen.first;    // "Eggs"
        int quantity = dozen.second;       // 12
        return 0;
    }
    

  • 设计意图与最佳实践：其实现本质就是一个模板：

    template <typename T1, typename T2>
    struct pair { T1 first; T2 second; };
    

    所以课堂上的 struct Order { string item; int quantity; };、struct Name {...};、struct Point {...}; 都可以用 std::pair 表达——”Notice anything?” 它们都只是”两个字段”。模板细节（Lecture 8 深入），本讲只需会使用。

• std —— C++ 标准库与命名空间
  • 定义与目的：标准库提供内置类型、函数等；使用前必须 #include 对应头文件，并加 std:: 前缀。
  • 核心语法：#include <string> → std::string；#include <utility> → std::pair；#include <iostream> → std::cout, std::endl。
  • 设计意图与最佳实践：using namespace std; 虽可省略前缀，但会引入歧义（若自己定义了 sort，与 std::sort 冲突），是坏风格。#include 的机制是文本替换：把头文件内容原样粘贴进源文件，之后才能使用其中定义的名字。查文档认准 cppreference.com（幻灯片明确提醒避开过时且广告多的 cplusplus.com）。
• using 类型别名（Type Alias，C++11 起）
  • 定义与目的：给长类型名起短名字。
  • 核心语法：using Zeros = std::pair<double, double>;
  • 设计意图与最佳实践：using 就像”类型的变量”。把 std::pair<bool, std::pair<double, double>> solveQuadratic(...) 拆成 using Zeros = ...; using Solution = std::pair<bool, Zeros>; 后，签名变成 Solution solveQuadratic(double a, double b, double c);，可读性大增。
• auto 类型推导（C++11 起）
  • 定义与目的：让编译器从初始化表达式推断变量类型。
  • 核心语法：auto result = solveQuadratic(a, b, c);
  • 设计意图与最佳实践：result 的类型仍是 std::pair<bool, std::pair<double, double>>（编译器查 solveQuadratic 的返回类型填入），与手写完全等价。auto 仍然是静态类型：auto i = 1; i = "hello!"; 编译失败。幻灯片对比了两种写法：长类型名用 auto 更清晰（auto result = ...），短类型名手写更清晰（int i = 1;）——按需选用。

代码示例与逐步解说（核心）

示例 1：struct 打包多字段并返回（C++11，改写自课堂 StanfordID 例）

#include <iostream>
#include <string>

struct StanfordID {
    std::string name;
    std::string sunet;
    int idNumber;
};

StanfordID issueNewID() {
    // 列表初始化：顺序与字段声明一致
    StanfordID id { "THE Stanford Tree", "theTREE", 0000002 };
    return id;
}

int main() {
    StanfordID id = issueNewID();
    std::cout << id.name << " (" << id.sunet << ") #" << id.idNumber << std::endl;
    return 0;
}
// THE Stanford Tree (theTREE) #2

代码做什么：

• struct StanfordID 声明三个字段；issueNewID() 用花括号列表初始化一个 ID 并返回；
• main 中 issueNewID() 的返回值被拷贝初始化到 id，再用 . 访问三个字段并输出。

特性机制解说：

• 花括号初始化按字段顺序填入（name → sunet → idNumber），编译器在编译期检查数量与类型是否匹配；
• return id; 返回的是整个 struct 的值拷贝——struct 像内置类型一样可以整体赋值、传参、返回；
• 0000002 是十进制整数 2（前导零只是字面量写法），所以输出 #2。

示例 2：课堂代码——求解二次方程（C++11/17，cs106l_data/lecture_code/lecture02/main.cpp）

#include <cmath>
#include <iostream>
#include <utility>

using Zeros = std::pair<double, double>;
using Solution = std::pair<bool, Zeros>;

// 求解 ax^2 + bx + c = 0
// 返回：first 表示是否有解；若有，second 为两个根
Solution solveQuadratic(double a, double b, double c) {
    double discrim = b * b - 4 * a * c;
    if (discrim < 0) return { false, { 106, 106 } };   // 无解：first=false

    double root = sqrt(discrim);
    return { true, { (-b - root) / (2 * a), (-b + root) / (2 * a) } };
}

int main() {
    double a, b, c;
    std::cout << "a: "; std::cin >> a;
    std::cout << "b: "; std::cin >> b;
    std::cout << "c: "; std::cin >> c;

    auto result = solveQuadratic(a, b, c);       // auto 推导出 Solution 类型
    if (result.first) {
        auto solutions = result.second;
        std::cout << "Solutions: " << solutions.first << ", "
                  << solutions.second << std::endl;
    } else {
        std::cout << "No solutions" << std::endl;
    }
    return 0;
}

代码做什么：

• 用户输入系数 a、b、c；solveQuadratic 计算判别式 b²-4ac，无解时返回 {false, {106, 106}}（占位值），有解时用求根公式 (-b ± √Δ)/(2a) 返回两个根；
• main 中用 auto result 接收，检查 result.first 决定打印根还是 “No solutions”。

特性机制解说：

• 嵌套 pair：Solution 是 std::pair<bool, Zeros>，Zeros 又是 std::pair<double, double>——两个返回值被”缝合”成一个返回值；
• 花括号返回：return { true, { ... } }; 利用 C++11 的列表初始化按序构造 pair，比 std::make_pair 更简洁；
• using 别名：把三层嵌套的类型名抽象成 Zeros/Solution，签名一目了然；
• auto 推导：result、solutions 的类型由编译器静态推导，等价于手写完整类型名；
• sqrt 来自 <cmath>（课堂代码还演示了不加 std:: 前缀调用 C 风格数学函数——在 <cmath> 下应写 std::sqrt 更规范）。

示例 3：auto 仍是静态类型（C++11）

#include <string>

int main() {
    auto i = 1;          // i 被推导为 int
    // i = "hello!";     // ❌ 编译错误：不能把 const char* 赋给 int
    auto s = std::string("test");   // s 被推导为 std::string
    return 0;
}

代码做什么：演示 auto 的推导结果在编译期固定。

特性机制解说：auto 不引入任何动态行为——它只是”让编译器替你写字面类型”。把被注释的行取消注释即可看到编译错误，这印证了”auto 是静态类型”这一幻灯片结论。

示例 4：函数重载（C++11，来自课堂 axolotl 例）

#include <iostream>

// (1) int 版本：返回 double
double axolotl(int x) {
    return static_cast<double>(x) + 3;   // 类型转换：int → double
}

// (2) double 版本
double axolotl(double x) {
    return x * 3;
}

int main() {
    std::cout << axolotl(2) << std::endl;    // 实参是 int   → 调用 (1)，输出 5
    std::cout << axolotl(2.0) << std::endl;  // 实参是 double → 调用 (2)，输出 6
    return 0;
}
// 5
// 6

代码做什么：同名函数 axolotl 有两个版本（int / double 参数），两次调用分别命中不同版本。

特性机制解说：

• 函数重载 = 同名函数、不同参数列表（数量或类型不同即可共存）；
• 重载解析（overload resolution）在编译期依据实参的静态类型完成：2 是 int → 精确匹配 (1)，2.0 是 double → 精确匹配 (2)；
• 幻灯片用这个例子演示了 (int)x 式类型转换（截断小数）与 static_cast 的作用：(1) 中 (double)2 + 3 == 5.0；若实参 2.5 传入 int 版本则会先被截断为 2——类型不匹配时编译器按”隐式转换代价”排序选择，这正是 Lecture 3 窄化转换的伏笔。

示例 5：std::pair 与结构化绑定（C++17）

#include <iostream>
#include <string>
#include <utility>

std::pair<std::string, int> makeOrder() {
    return { "Eggs", 12 };          // 列表初始化构造 pair
}

int main() {
    auto order = makeOrder();       // order: std::pair<std::string, int>
    std::cout << order.first << " x" << order.second << std::endl;   // 传统访问

    // C++17 结构化绑定：一次性拆开 first / second
    auto [item, quantity] = makeOrder();
    std::cout << item << " x" << quantity << std::endl;
    return 0;
}
// Eggs x12
// Eggs x12

代码做什么：用 std::pair 打包”商品 + 数量”，再用两种方式取出字段。

特性机制解说：

• return { "Eggs", 12 }; 利用列表初始化按序构造 pair<std::string, int>，"Eggs" 被隐式转换为 std::string；
• auto [item, quantity] = ... 是 C++17 结构化绑定（structured bindings）：把 pair 的两个成员按声明顺序解包到两个新变量，省去 .first/.second 的样板代码；
• 结构化绑定同样适用于 struct、数组、tuple——本讲先用 pair 建立直觉，后续讲座会反复用到；它再次体现了”用 auto 交给编译器、保持代码简洁”的现代风格。

与旧标准（如C++98）的对比

• using vs typedef：C++98 用 typedef std::pair<double, double> Zeros;（类型名在中间，嵌套别名晦涩难读）；C++11 的 using Zeros = ...; 更直观、支持模板别名，是现代 C++ 的推荐写法。

#include <utility>

int main() {
    // C++98 风格：typedef（类型名夹在中间）
    typedef std::pair<double, double> Zeros98;
    typedef std::pair<bool, Zeros98>  Solution98;

    // 现代 C++ 风格：using 别名（C++11 起，= 号让阅读顺序更自然）
    using Zeros    = std::pair<double, double>;
    using Solution = std::pair<bool, Zeros>;

    Solution s { true, { 1.0, 2.0 } };   // 两种写法等价，现代风格更清晰
    return 0;
}

• auto 语义完全不同：C++98 中 auto 是存储类说明符（auto int x;，表示自动存储期，毫无用处）；C++11 起才表示类型推导。
• 初始化方式：C++98 只有 StanfordID id; id.name = ...; 逐字段赋值或对聚合类型使用 T x = { ... };；C++11 的列表初始化适用于一切类型、写法统一（T x { ... };、return { ... };），并附赠窄化检查（详见 Lecture 3）。
• std::pair 本身 C++98 就有（<utility> 中的 std::make_pair），但 C++98 没有 {} 初始化，必须写 std::make_pair("Eggs", 12) 且类型推导能力弱（"Eggs" 会被推导为 const char* 而非 std::string）。
• 结构化绑定是 C++17 才有的：C++98 解包 pair 只能写 pair.first/pair.second 或借助 std::tie（C++11）——都没有 auto [a, b] 直观。
• range-based for / 现代容器用法：C++98 遍历容器只能手写索引或迭代器循环，代码冗长（详见后续讲座）。

关键要点

• C++ 是编译型、静态类型语言：错误尽量在编译期暴露，类型声明后不可变，运行高效。
• struct 把命名变量捆绑成新类型，用 . 访问字段；列表初始化 { ... } 按字段顺序一次性填值，= 可选。
• std::pair<T1, T2> 是”通用双字段 struct”（first/second），可嵌套使用以返回多个值。
• 使用标准库 = #include 对应头文件 + std:: 前缀；避免 using namespace std;。
• using 造类型别名、auto 推导类型（C++11 起）是提升可读性的现代工具，且 auto 仍是静态类型。
• 函数重载（同名不同参）在编译期按实参类型选择版本——静态类型的又一红利。
• 记住内置类型常识：size_t 是非负整数（常用于索引/大小）；5 / 2 整数除法结果为 2。

常见陷阱与注意事项

• 整数除法截断：int c = 5 / 2; 得到 2 而不是 2.5；想得到小数至少一个操作数要写成 double。
• 忘记 #include <utility>：用 std::pair 不包含头文件会编译失败；同理 std::string 需要 <string>。
• 滥用 using namespace std;：与自己的 sort 等函数重名时产生歧义；规范写法是显式 std::。
• 列表初始化顺序错乱：花括号值必须与字段声明顺序一致，否则数据张冠李戴（编译器按序填入，不会替你”按名匹配”）。
• 误以为 auto 是动态类型：auto i = 1; i = "hello"; 编译错误；auto 只是编译期推导，不改变静态类型语义。
• 把 struct 当作”只有数据”而忽略初始化：默认声明 StanfordID id; 时，内置类型字段（如 idNumber）的值是未初始化的，读取是未定义行为——养成用 { } 初始化的习惯（Lecture 3 重点）。
• 重载时类型不匹配导致的”意外”调用：如 axolotl(2.5) 若只有 int 版本可用，会先把 2.5 截断成 2 再调用——留意隐式转换的方向，必要时显式 static_cast。

关联作业提示

None（本讲无直接对应作业）。不过 A1: SimpleEnroll 会大量用到本讲知识，可提前预热：

• A1 的 Course struct（Title、Number of Units、Quarter 三个字段）正是”struct 打包数据”的实战——用列表初始化构造每个 Course 记录；
• std::pair 与 using 别名在 A1 的工具代码（如 split 返回 std::vector<std::string>）中会反复出现；
• 建议现在就练熟：声明一个 struct → 用 {} 初始化 → 用 . 访问字段 → 用 auto 接收函数返回值，A1 拿到手就能直接上手。

Lecture 3 (Week 2 - Tuesday): 初始化与引用 (Initialization & References)

概述

本讲是”写出正确、高效 C++”的关键一课，两个主题：初始化与引用。初始化部分讲清 C++ 的四种基本初始化形式（默认、拷贝、直接、列表）以及列表初始化对窄化转换（narrowing conversion）的编译期拦截；引用部分讲清引用是”变量的别名”、绑定同一块内存、必须绑定左值且不可重绑定，并由此引出 const 引用与值传递 vs 引用传递的选择。课堂代码（initialization.cpp、references.cpp、const.cpp、Reactor.cpp）全部围绕”初始化写错会怎样”“参数怎么传才高效且安全”展开——这正是 A1: SimpleEnroll 的核心考点。

核心特性与语法详解

• 默认初始化（Default Initialization）
  • 定义与目的：T x; 不提供任何初值。对类类型（如 std::string）调用默认构造函数；对内置类型（int、double…）不初始化——值是”不确定的”（indeterminate），读取它是未定义行为。
  • 核心语法：int x; / std::string s;
  • 设计意图与最佳实践：内置类型的默认初始化不写内存（追求零开销），代价是需要程序员自律。黄金法则：内置类型永远用 {} 或显式初值初始化。
• 拷贝初始化（Copy Initialization）
  • 定义与目的：T x = value;，从已有值”拷贝”出新的对象。
  • 核心语法：int x = 5; / std::string s = "hi";
  • 设计意图与最佳实践：C 语言风格的写法，直观但语义上走的是拷贝路径；对于类类型可能调用移动/拷贝构造函数（现代编译器通常会优化掉多余的拷贝，即 copy elision）。
• 直接初始化（Direct Initialization）
  • 定义与目的：T x(args);，用圆括号参数直接构造对象，允许窄化转换。
  • 核心语法：int x(5); / std::vector<int> v(10);（构造 10 个元素）
  • 设计意图与最佳实践：圆括号会触发”最令人头痛的解析”（most vexing parse）等历史包袱，且不做窄化检查——Reactor.cpp 的 bug 正源于此（见示例 3）。
• 列表 / 统一初始化（List / Uniform Initialization，C++11 起）
  • 定义与目的：T x{ ... }; 用花括号初始化，对所有类型语法统一，且在编译期拒绝窄化转换。
  • 核心语法：int x{5}; / StanfordID id{ "Tree", "theTREE", 2 }; / T x{};（值初始化，内置类型清零）
  • 设计意图与最佳实践：C++11 引入它正是为了”统一 + 安全”。现代 C++ 首选 {}；T x{} 会把内置类型零初始化，杜绝”未初始化变量”类 bug。
• 窄化转换（Narrowing Conversion）
  • 定义与目的：隐式转换中丢失信息的一类：如 double→int（截断小数）、long→int（可能溢出）、double→float（精度可能丢失）。
  • 核心语法：int numOne{12.0}; → ❌ 编译错误 narrowing conversion of '1.2e+1' from 'double' to 'int'。
  • 设计意图与最佳实践：列表初始化把窄化从”静默的错误”变成”编译错误”；若确实需要截断，用显式类型转换（如 static_cast<int>(12.8)），让意图可见。注意例外：float f{12.0}; 是合法的——因为 12.0 能被 float 精确表示，不构成窄化（标准允许”常量表达式且目标类型可精确表示”的情况）。
• 引用（References，C++98 已有）
  • 定义与目的：T& ref = obj; 声明 ref 是 obj 的别名——两者绑定同一块内存，对 ref 的读写就是对 obj 的读写。
  • 核心语法：

    int main() {
        int x = 5;
        int& r = x;   // r 是 x 的别名（与 x 绑定同一块内存）
        r = 10;       // 通过 r 改写 x：x 也变成 10
        return 0;
    }
    

  • 设计意图与最佳实践：三条铁律：① 引用声明时必须绑定一个对象（不能”先声明后绑定”）；② 不可重新绑定（r = y; 是把 y 的值赋给 x，不是让 r 改指 y）；③ 非 const 左值引用只能绑定左值（可寻址的具名对象），不能绑定字面量/临时值（如 int& r = 5; ❌）。
• const 与 const 引用（const 正确性）
  • 定义与目的：const T 表示”只读对象”；const T& 表示”只读视图”——既享受引用”不拷贝、直接看原对象”的高效，又保证不修改。
  • 核心语法：const int x = 5; / const std::vector<int>& cr = vec; / void print(const std::string& s);
  • 设计意图与最佳实践：const 引用可以绑定任何东西：左值、右值、字面量（const int& r = 42; 合法，临时对象生命周期被延长）。对 const 对象只能调用 const 成员函数（如 vec.size()），调用非 const 成员（如 push_back）是编译错误——const 是编译器替你执行的纪律。
• 值传递 vs 引用传递
  • 定义与目的：函数形参决定”数据怎么进来”：按值（拷贝一份，函数内修改不影响调用方）vs 按引用（直接操作原对象，可修改调用方）。
  • 核心语法：

    void byValue(int n);          // 拷贝
    void byRef(int& n);           // 可修改原值
    void byConstRef(const int& n); // 只读，不拷贝
    

  • 设计意图与最佳实践：选型口诀——需要修改实参 → 传 T&；只读且类型较大（string、vector、struct）→ 传 const T&（避免昂贵拷贝）；内置小类型（int、double）只读 → 直接按值传。这就是”不浪费时间和空间”哲学在参数传递上的体现。

代码示例与逐步解说（核心）

示例 1：四种初始化形式总览（C++11）

#include <iostream>
#include <string>

struct Point {
    double x;
    double y;
};

int main() {
    // 默认初始化：内置类型未初始化（值不确定，别读它！）
    int a;                       // 不确定值
    std::string s;               // 空字符串 ""（类类型有默认构造）

    // 拷贝初始化
    int b = 42;
    std::string t = "hi";

    // 直接初始化（圆括号，允许窄化）
    int c(3.9);                  // c == 3（小数被截断，不报错！）

    // 列表初始化（统一初始化，拒绝窄化）
    int d{7};                    // OK
    Point p{1.0, 2.0};           // 按字段顺序初始化
    // int e{3.9};               // ❌ 取消注释即编译错误：narrowing conversion

    // 值初始化：内置类型清零
    int f{};                     // f == 0
    std::cout << b << " " << c << " " << d << " " << f << std::endl;
    return 0;
}

代码做什么：一行行声明不同初始化方式的变量；c 用圆括号从 3.9 截断得到 3（静默），e 用花括号直接编译失败。

特性机制解说：

• 编译器对 {} 逐项做窄化检查：double → int 属于”浮点转整型”，必然可能丢精度，属于窄化，直接报错；圆括号初始化走旧的隐式转换规则，3.9 静默截断为 3——同一个”错误”，两种初始化写法给出截然不同的命运；
• Point p{1.0, 2.0} 走聚合初始化：按成员声明顺序填入；
• int f{} 是值初始化，等价于 int f = 0;，规避了默认初始化”不确定值”的坑。

示例 2：课堂代码 initialization.cpp（C++11，验证窄化保护）

#include <iostream>

int main() {
    // 列表初始化：窄化转换被编译器拦截
    // int numOne{12.0}; // ❌ 取消注释即编译错误：double → int 是窄化
    float numTwo{12.0};  // ✅ 合法：12.0 可被 float 精确表示，不构成窄化

    std::cout << "numTwo is: " << numTwo << std::endl;
    return 0;
}

代码做什么：这是课堂真实代码（cs106l_data/lecture_code/lecture03/initialization.cpp）的改编版：原代码中 int numOne{12.0}; 编译失败，报错 error: narrowing conversion of '1.2e+1' from 'double' to 'int'（这里已注释掉并保留 float numTwo{12.0}; 展示合法情形）。

特性机制解说：

• 窄化判定的标准规则：浮点 → 整型永远是窄化（无例外），所以 int{12.0} 必错；
• double → float 是否窄化取决于”源是常量表达式且值在目标类型可表示范围（哪怕不精确）”——12.0 恰好能被 float 精确表示，故合法；若写成 float f{12.1};（12.1 无法精确表示）就会报错。这正是”编译器用规则替你把关”的体现，也是本讲反复强调”用 {}“的原因。

示例 3：课堂代码 Reactor.cpp——窄化转换的真实代价（C++11）

#include <iostream>

class Reactor {
public:
    Reactor(double temperature) : temperature(temperature) {}   // 构造函数，后续讲座详讲
    void checkCool() {
        if (temperature > 100.0) {
            std::cout << "Emergency cooling!" << std::endl;
        } else {
            std::cout << "Temperature is normal. No emergency cooling required" << std::endl;
        }
    }
private:
    double temperature;
};

int main() {
    // 直接初始化（圆括号）：允许窄化，100.8 被静默截断为 100
    int criticalTemperature(100.8);
    Reactor reactor(criticalTemperature);   // int 100 → double 100.0
    reactor.checkCool();                     // 输出 "Temperature is normal."！
    return 0;
}

代码做什么（课堂真实代码，cs106l_data/lecture_code/lecture03/Reactor.cpp）：想模拟”温度超过 100°C 触发紧急冷却”，实际运行时输出却是 “Temperature is normal. No emergency cooling required”。

特性机制解说：

• int criticalTemperature(100.8); 是直接初始化，圆括号允许窄化：100.8 静默截断为 100；
• 随后 100 被隐式转回 double（100.0），100.0 > 100.0 为假 → 冷却逻辑从未触发；
• 这是一个”看似无害实则致命”的静默 bug——工业 PLC / 反应堆控制系统正是这类代码的高发区。若把第 32 行改成 int criticalTemperature{100.8};，编译器会当场报错，从根源上避免灾难。这就是列表初始化存在的意义：把”静默的错误”变成”编译期的错误”。

示例 4：课堂代码 references.cpp——值传递 vs 引用传递（C++11）

#include <iostream>

// 引用版本：直接修改调用方的变量
void squareN(int& n) {
    n = n * n;   // 直接改写实参（课堂原版用 std::pow(n, 2)，效果相同）
}

int main() {
    int num = 5;
    std::cout << "(1) num is: " << num << std::endl;   // 5
    squareN(num);                                       // 按引用传：修改的就是 num 本身
    std::cout << "(2) num is: " << num << std::endl;   // 25
    return 0;
}

代码做什么（改编自课堂代码 references.cpp）：squareN(int& n) 把参数按引用传入，函数内 n = n * n; 直接改写了 main 中的 num，输出 5 → 25。

特性机制解说：

• 原课堂代码用 #if WITH_REF 宏在”int& n（引用）”与”int n（值）”两个版本间切换：值版本下 main 里的 num 保持不变（拷贝被平方），引用版本下 num 被真正改写；
• 原代码调用 squareN(5);（字面量）在引用版本下无法编译——报错 cannot bind non-const lvalue reference of type 'int&' to an rvalue of type 'int'：非 const 左值引用只能绑定左值（具名、可寻址的对象），5 是右值。这是引用最经典的规则，也是新手最常见的报错之一；
• 通过引用修改实参的能力，正是 A1 中 parse_csv 需要”把填好的 vector 交还给调用方”的机制。

示例 5：课堂代码 const.cpp——const 对象与 const 引用（C++11）

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec{ 1, 2, 3 };                  // 普通 vector
    const std::vector<int> const_vec{ 1, 2, 3 };      // const 对象
    std::vector<int>& ref_vec{ vec };                 // 普通引用：vec 的别名
    const std::vector<int>& const_ref{ vec };         // const 引用：只读视图

    vec.push_back(3);          // ✅ OK：vec 可变
    // const_vec.push_back(3); // ❌ 编译错误：const 对象不能调用非 const 成员函数
    ref_vec.push_back(3);      // ✅ OK：ref_vec 是 vec 的别名，vec 实际变成 {1,2,3,3}
    // const_ref.push_back(3); // ❌ 编译错误：const 引用禁止修改
    return 0;
}

代码做什么（课堂真实代码 const.cpp）：声明四种变量后尝试 push_back，其中两行被编译器拒绝。

特性机制解说：

• const_vec 是 const 对象：编译器禁止任何修改操作，push_back（非 const 成员函数）报错 passing 'const std::vector<int>' as 'this' argument discards qualifiers；
• ref_vec 是 vec 的别名：对它 push_back 等于对 vec 操作（同一块内存、同一份数据）；
• const_ref 是 const 引用：它指向 vec（不拷贝），但只读——既高效（无拷贝）又安全（不可改）；
• 本质区别：const_vec 拷贝了一份 const 数据；const_ref 没有拷贝，只是”隔着一层只读玻璃看 vec“。当 vec 后续变化时，const_ref 看到的是变化后的新值——引用是别名，不是快照。

示例 6：高效传参——const std::string&（C++11）

#include <iostream>
#include <string>

// 只读大对象：const 引用，不拷贝、不修改
void greet(const std::string& name) {
    std::cout << "Hello, " << name << "!" << std::endl;
}

int main() {
    std::string me = "CS106L";
    greet(me);            // 绑定左值：OK
    greet("Stanford");    // 绑定字面量（右值）：OK，const 引用可以绑定右值
    return 0;
}

代码做什么：greet 以 const std::string& 接收参数，两次调用都成功。

特性机制解说：

• 若形参是 std::string name（按值），每次调用都要深拷贝整个字符串（分配堆内存 + 复制字符）；const std::string& 零拷贝、零修改；
• const 引用是”万能绑定”：左值、右值、字面量通吃（const int& r = 42; 合法，临时对象生命周期被延长到引用消亡）；
• 对比：非 const 引用 std::string& 只能绑定左值，且意味着”函数可能修改实参”——所以只读参数一律写 const T&，把意图交给编译器监督。

与旧标准（如C++98）的对比

• C++98 没有列表初始化：只有 T x;、T x = v;、T x(v); 三种，窄化转换全部静默发生——Reactor.cpp 那种 int x(100.8) 截断 bug 在 C++98 里是合法且无声的，只能靠程序员肉眼发现。
• C++11 的 {} 统一了初始化语法：聚合、类、内置类型一视同仁，并内建窄化检查；C++98 的聚合初始化 T x = { ... }; 仅适用于无构造函数、无私有成员的”聚合”，且不检查窄化。
• 引用本身 C++98 就有（引用是 C++ 早期特性），但 C++98 时代惯例是”裸指针传参 + const 指针”，引用被广泛接受为现代风格是 C++11 之后的事；const T& 传参的”零拷贝 + 只读”理念在 C++98 同样成立，只是表达与工具（如 range-for）远不如现代版顺手。
• 值初始化 T{} 与 nullptr、range-for 等：均为 C++11 起的新特性，C++98 中”清零内置变量”只能手写 int x = 0;。

关键要点

• 现代 C++ 优先用列表初始化 {}：语法统一，且编译期拦截窄化转换；内置类型用 T x{} 保证清零，杜绝未初始化读取。
• 窄化转换（double→int、long→int 等）会静默丢信息：圆括号/赋值允许它，花括号拒绝它；确需截断时用 static_cast<int>(...) 显式表达。
• 引用是变量的别名，绑定同一块内存：声明时必须绑定、不可重绑定、非 const 引用只能绑定左值；通过引用修改，实参同步变化。
• const T& 是”只读高效视图”：零拷贝、禁止修改，可绑定左值/右值/字面量——只读参数的标准答案。
• 参数选型口诀：要修改实参 → T&；只读大对象 → const T&；只读小内置类型 → 按值。

常见陷阱与注意事项

• 读取未初始化的内置变量：int x; std::cout << x; 是未定义行为（值不确定）；用 int x{}; 或给初值。
• 窄化静默截断：int x = 3.9; / int x(3.9); 编译通过但 x == 3；想保留小数就别用 int，想截断就用显式转换。
• 非 const 引用绑定右值：int& r = 5; 或 void f(int&); f(5); 编译错误；要么传具名左值，要么改成 const int&。
• 悬垂引用（dangling reference）：引用指向的对象先消亡（如函数返回局部变量的引用）后继续使用——未定义行为。int& bad() { int x = 1; return x; } ❌。
• 误以为引用可重绑定：int& r = a; r = b; 是把 b 的值赋给 a，不是让 r 改指 b；想”换个对象”应使用指针。
• 忘记 & 导致悄悄拷贝：形参写成 T name 而非 const T& 时，大对象（string/vector/struct）每次调用都深拷贝，性能退化且行为上”改了也白改”。
• 对 const 对象调用非 const 成员函数：const_vec.push_back(...) 编译错误；只读访问用 size()、operator[] 读取等 const 成员。

关联作业提示

A1: SimpleEnroll（第 2 周周五发布、一周后截止）——本讲的初始化与引用正是 A1 的核心考点：

• Part 0：补全 Course struct：用列表初始化构造每个 Course 记录（Course c{ title, units, quarter };），字段顺序与 struct 声明一致；字符串字段用 {} 初始化最稳妥。
• Part 1：parse_csv：函数需要”把解析出的 Course 填进调用方的 vector”——因此形参必须是引用：void parse_csv(std::vector<Course>& courses, ...)。若漏写 &，函数内 push_back 的只是副本，调用方看到的 vector 仍为空——这是 A1 最经典的失分点。
• Part 2/3：write_courses_offered / write_courses_not_offered：只读遍历（统计、比较 Quarter 是否为 “null”）用 const 引用传参与遍历（如 const std::string&），避免字符串深拷贝；需要从 all_courses 删除已开课程时，删除操作必须发生在遍历之后（边遍历边删会失效，见 A1 提示），删除本身依赖”vector 按引用传入”才能影响调用方。
• 通用技巧：先本地编译 g++ -std=c++20 main.cpp -o main 验证，再跑内置 autograder；遇到”函数改了但外面没变”的诡异现象，第一反应检查形参是不是漏了 &。

Lecture 4 (Week 2 - Thursday): 流 (Streams)

概述

本讲介绍 C++ 的流（stream）体系：一个统一”读数据 / 写数据”的通用 I/O 抽象。你将理解流的类层次（ios_base → basic_ios → istream/ostream 及其派生类型），掌握 std::cout/std::cin、stringstream、ofstream/ifstream 的用法，弄清输出缓冲与 flush 机制，并避开 getline 与 >> 混用、cin 读取失败等经典陷阱。流是 C++ 一切输入输出的地基：A1（SimpleEnroll）的 CSV 解析与文件写出几乎完全建立在流之上，后续课程的几乎所有程序也离不开它。

核心特性与语法详解

1. 什么是流（Stream）

• 定义与目的：流是 C++ 的通用输入/输出设施——”a general input/output facility for C++”。它把”数据从外部来源（键盘、文件、字符串）进入程序”和”数据从程序流向外部目的地（终端、文件）”抽象成一条传送带（conveyor belt）：输出流把数据送出去，输入流把数据接进来。
• 核心语法：输出 std::cout << x << '\n';；输入 std::cin >> x;。
• 设计意图与最佳实践：Bjarne Stroustrup 说过：”为程序设计通用的 I/O 设施是出了名的困难。”流的答案是抽象——隐藏不必要的细节（电机、线路、缓冲、硬件），只暴露相关的接口：<<（插入运算符 insertion operator）与 >>（提取运算符 extraction operator）。就像开车不用关心引擎原理、只需踩油门和转方向盘，用流时你也不必关心数据具体怎么被搬进搬出。

2. 流的类层次（ios_base → basic_ios → istream/ostream）

• 定义与目的：所有流类型共享同一个继承体系，因此接口一致、类型可互换。

• 核心语法（层次结构）：

  ios_base
    └─ basic_ios
         ├─ istream  ──→ std::cin, std::ifstream, std::istringstream
         └─ ostream  ──→ std::cout, std::cerr, std::clog, std::ofstream, std::ostringstream
  

• 机制与职责：
  • ios_base：一切流的地基，维护两类信息。
    • 状态信息（State Information）：流的”健康指标”，例如 failbit（逻辑错误，如类型不匹配）、eofbit（到达流末尾）。
    • 控制信息（Control Information）：数据如何呈现，例如 255 应打印成 "255"、"FF"（十六进制）还是 "377"（八进制）。
  • basic_ios：在 ios_base 之上保证流工作正常，并管理数据的来源（控制台、键盘、文件……）。
  • istream：输入流基类，主要操作是 >>；ostream：输出流基类，主要操作是 <<。两者交集即 iostream，同时具备读写能力。
• 头文件：#include <iostream>（cin 与 cout）、<istream>（cin）、<ostream>（cout）、<fstream>（文件流）、<sstream>（字符串流）。
• 设计意图：同一套 <</>> 操作符可以作用于任何流——这正是抽象带来的接口一致性（幻灯片强调：”notice the << and >>? That’s abstraction at work!”）。

3. 提取/插入运算符的”空白分词”规则

• 定义与目的：<< 和 >> 以空白（whitespace）为界切分数据，这是流最核心的行为规则。
• 核心语法：ss >> first >> last >> language;
• 机制：>> 一直读取到下一个空白字符为止。空白包括：空格 ' '、'\n'、'\t'、'\r'、'\f'、'\v'。注意：>> 会跳过前导空白，但不会消费末尾的分隔符——这会引发后续 getline 的经典 bug（见陷阱部分）。

4. std::getline

• 定义与目的：>> 只能读到空白为止，无法读取”一整行”（例如带空格的名字或引语）。getline 解决”按行读取”的需求。
• 核心语法：std::getline(std::istream& is, std::string& str, char delim = '\n');
• 机制：从 is 一直读取到分隔符 delim（默认 '\n'），把内容存入 str，并且消费（吞掉）分隔符本身。幻灯片特意强调：”getline() consumes the delim character! PAY ATTENTION TO THIS :)”——这是理解一切换行残留问题的钥匙。

5. stringstream（字符串流）

• 定义与目的：把字符串当作流来使用，尤其擅长”混合数据类型的解析与格式化”（mixing data types）。
• 核心语法：构造 std::stringstream ss(initial_quote);；或先 ss << ... 填充再 ss >> ... 读出。
• 设计意图：istringstream/ostringstream/stringstream 位于类层次底部，与 cin/cout 共享同一接口，因此同一套 <</>> 代码既能处理终端也能处理字符串。CS106B 中按行读取文件、A1 提供的 split 工具函数，背后都是 stringstream。

6. 输出流的缓冲与刷新（flush）

• 定义与目的：输出字符先进入中间缓冲区（buffer），在显式 flush 时才真正写到目的地，从而减少慢速 I/O 的次数、提升性能。
• 核心语法：std::cout << std::flush;（只刷新）与 std::cout << std::endl;（换行 + 刷新）。
• 何时刷新：
  1. std::cout << std::flush;
  2. std::cout << std::endl;
  3. 程序正常结束时
  4. 缓冲区满时
  5. tied 流交互时：例如 cout 与 cin 绑定，cin 取输入前 cout 会先 flush，保证提示语先显示。
• std::endl vs '\n'：std::endl = 换行 + flush；'\n' 只换行。循环里用 std::endl 会导致每次迭代都 flush，严重拖慢程序——课程明确建议 “Use ‘\n’!”。
• cerr vs clog：cerr 用于输出错误，无缓冲（立即送出）；clog 用于非关键事件日志，有缓冲。

7. 文件流：std::ofstream / std::ifstream

• 定义与目的：把数据写到文件 / 从文件读取数据。
• 核心语法：
  • 构造：std::ofstream ofs("hello.txt");（构造时即关联文件）
  • 打开标志：std::ios::trunc（默认，截断重建）、std::ios::app（追加）、std::ios::ate（打开后立即跳到文件末尾）
  • 常用成员：is_open()、open()、close()、fail()
• 机制与陷阱：关闭（close()）后再 << 写入会静默失败（不报错、不写入）；调用 open() 可重新关联文件（可换打开模式）。输入/输出文件流在同一来源/目的地上互补：ofstream 写、ifstream 读。

8. std::cin 的行为与失败

• 定义与目的：标准输入流，有缓冲：用户输入先整体进入缓冲区，程序再按空白切词从缓冲区读取。
• 核心语法：std::cin >> pi;
• 机制：若缓冲区为空，则阻塞等待用户输入；若非空，则读到下一空白为止。当 cin >> double 时遇到非数字的单词（如 "Fernandez"），提取失败：流置 failbit，目标变量保持原值或变为 0，且之后所有 >> 读取都会直接失败——直到你 clear() 恢复状态（本讲先认识现象，A1 不会深究恢复）。

代码示例与逐步解说（核心）

示例 1：stringstream 混合类型解析（课堂代码 recap.cpp 改写）

// C++11（课程以 C++20 编译，本示例仅用 C++11 特性）
#include <iostream>
#include <sstream>
#include <string>

int main() {
    // 1. 构造一个装着整段文本的字符串流（等价于 ss << initial_quote）
    std::string initial_quote =
        "Bjarne Stroustrup C makes it easy to shoot yourself in the foot\n";
    std::stringstream ss(initial_quote);

    // 2. 按空白分词，依次取走 "Bjarne" / "Stroustrup" / "C"
    std::string first, last, language;
    ss >> first >> last >> language;

    // 3. 剩余部分用 getline 整行取走（含前导空格）
    std::string extracted_quote;
    std::getline(ss, extracted_quote);

    std::cout << first << " " << last << " said this: '" << language
              << " " << extracted_quote << "'\n";
    return 0;
}

• 代码做什么：ss >> first >> last >> language 用空白把引语前三个词切出来；std::getline(ss, extracted_quote) 把剩下的 " makes it easy to shoot yourself in the foot"（前面带一个空格，因为 >> 不消费分隔符）整行装入 extracted_quote；最后打印。
• 特性机制解说：>> 是”按空白分词器”——它跳过前导空白、提取到下一个空白为止、把分隔符留在流里。而 getline 一直读到 '\n' 并把 '\n' 吃掉。两者一前一后配合，才能既按词取、又按行取。

示例 2：cout / cin 基本输入输出（课堂练习 Exercise 1 & 2）

// C++11
#include <iostream>
#include <string>

int main() {
    // 输出：三个值用同一个 << 接口
    std::cout << "Hello, Streams!\n";
    std::cout << 42 << '\n';
    std::cout << 3.14 << '\n';

    // 输入：先提示、再读取
    std::string name;
    int number;
    std::cout << "Enter your name: ";
    std::cin >> name;               // 读到下一个空白为止（假设名字是单个单词）
    std::cout << "Enter your favourite number: ";
    std::cin >> number;

    std::cout << "Hello " << name << ", your favourite number is "
              << number << "!\n";
    return 0;
}

• 代码做什么：先打印三行（字符串、int、double），再提示用户输入名字和数字并回显。
• 特性机制解说：<< 对每种内置类型都有重载（ostream& operator<<(ostream&, int/double/const char*/...)），编译器按实参类型自动挑选——这就是”类型安全”：printf("%d", 3.14) 是未定义行为，而 std::cout << 3.14 永远正确。cin >> name 与 cin >> number 之间由空白分隔，所以输入 Alice 7 或分行输入 Alice\n7 效果相同。

示例 3：ofstream / ifstream 文件读写（课堂练习 Exercise 4/6 改写，含追加）

// C++11
#include <fstream>
#include <iostream>
#include <string>

int main() {
    // 写：默认 std::ios::trunc —— 文件被截断重建
    std::ofstream out("grades.txt");
    if (!out.is_open()) {
        std::cerr << "Error: could not open file\n";
        return 1;
    }
    out << "Alice" << " " << 92 << "\n";
    out.close();                    // 关闭后不能再写

    // 追加：std::ios::app 保留原有内容
    std::ofstream app("grades.txt", std::ios::app);
    if (app.is_open()) {
        app << "Bob" << " " << 87 << "\n";
    }
    app.close();

    // 读回：while 循环直到文件末尾
    std::ifstream in("grades.txt");
    if (!in.is_open()) {
        std::cerr << "Error: could not open file\n";
        return 1;
    }
    std::string name;
    int grade;
    while (in >> name >> grade) {   // 1. 尝试读取  2. 检查是否成功
        std::cout << "Name: " << name << "  |  Grade: " << grade << "\n";
    }
    return 0;
}

• 代码做什么：写入一条成绩 → 追加第二条 → 逐条读回打印（Alice | 92、Bob | 87）。
• 特性机制解说：
  • while (in >> name >> grade) 是读取循环的标准形态：>> 返回流本身，流在 failbit 置位（读到 EOF 或类型失败）时 operator bool 为 false，循环自然终止——绝不要写 while (!in.eof())。
  • std::ios::trunc 是默认行为：每次运行文件内容被清空重写；std::ios::app 让每次打开都在文件尾追加（课堂 post-practice 的成绩追踪器正是靠它累计 3 名学生）。
  • cerr 无缓冲、立即输出，适合错误信息。

示例 4：cin 失败与 getline 混用的经典 bug（幻灯片 cinGetline 场景）

// C++11
#include <iostream>
#include <string>

int main() {
    double pi, tao;
    std::string name;

    std::cin >> pi;                 // 输入: 3.14
    std::getline(std::cin, name);   // 第一次 getline：吃掉 >> 残留的 '\n' → name = ""
    std::getline(std::cin, name);   // 第二次 getline：真正读入 "Rachel Fernandez"
    std::cin >> tao;                // 输入: 6.2

    std::cout << "my name is: " << name
              << " tao is: " << tao
              << " pi is: " << pi << '\n';
    return 0;
}

• 代码做什么：输入 3.14、Rachel Fernandez、6.2，期望打印 my name is: Rachel Fernandez tao is: 6.2 pi is: 3.14。
• 特性机制解说：这是本讲最经典的 bug 演示。cin >> pi 读到 3.14 后把 '\n' 留在缓冲区；紧接着的 getline 立刻读到这个 '\n'，返回空串并吞掉换行。若不补一次 getline，后续 cin >> tao 会去读 "Fernandez"——double 解析失败，tao 变成垃圾值且流进入 failbit。解法（幻灯片）：在数字读取后多调一次 getline 吃掉残留换行。课程结论：”Don’t use getline() and std::cin >> together, unless you really really have to!”

示例 5：逐行读文件 + stringstream 解析 CSV（A1 预演）

// C++11
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>

int main() {
    std::ifstream in("courses.csv");
    if (!in.is_open()) {
        std::cerr << "Error: could not open file\n";
        return 1;
    }

    std::string line;
    std::getline(in, line);             // 跳过列名（header）行

    while (std::getline(in, line)) {    // 每个记录是一整行
        std::stringstream ss(line);     // 把这一行当流处理
        std::string title, units, quarter;
        std::getline(ss, title, ',');   // 用逗号作分隔符
        std::getline(ss, units, ',');
        std::getline(ss, quarter);
        std::cout << title << " | " << units << " | " << quarter << '\n';
    }
    return 0;
}

• 代码做什么：逐行读取 CSV，跳过第一行列名，把每行按逗号切成三列并打印。
• 特性机制解说：getline 的第三个参数可以换成任意分隔符——这里把默认的 '\n' 换成 ','，实现”按列读取”；外层再按 '\n' 按行读取，形成”行内套列”的两级解析。这正是 A1 中 parse_csv 的思路：ifstream 按行 + stringstream/split 按逗号分列。

与旧标准（如C++98）的对比

• 流本身是 C++98 时代就存在的设施：<iostream>、<fstream>、<sstream> 及其所有核心 API（<<、>>、getline、flush、open/close/is_open）从 C++98 至今几乎没有变化。本讲内容的”新旧对比”主要发生在外围工具上：
• 对比 C 风格 I/O（printf / scanf / FILE*）：C 的 I/O 类型不安全（格式串 %d 与实参类型不匹配是未定义行为）、不可扩展（无法为自定义类型重载）、失败检测靠返回值容易漏。C++ 流对每种内置类型都有重载，自定义类型可在后续课程（L12 运算符重载）中扩展 <</>>，失败有 failbit/eofbit 状态可查。
• 字符串 ↔ 数字转换：C++98 只能靠 stringstream（如 ss << 42; ss >> str;）或 C 函数；C++11 起引入 std::to_string、std::stoi/std::stod 等，简单转换不再需要流。
• std::endl 与 '\n'：自 C++98 起就存在”endl 附带 flush”这一行为，现代 C++ 社区一致建议循环输出用 '\n'（本讲幻灯片也明确要求 “Use ‘\n’!”）。
• 展望 C++23：<print> 头文件引入 std::print / std::println，格式化输出更简洁高效；但流仍是通用、可扩展 I/O 的基石，理解缓冲与状态机制对任何 I/O 方式都适用。

关键要点

1. 流是一条”传送带”：输入流用 >> 读、输出流用 << 写，同一接口覆盖控制台、文件、字符串——这就是抽象的力量。
2. >> 按空白分词、不消费末尾分隔符；getline 读整行、消费分隔符。两者混用前，先想清楚缓冲区里还剩什么。
3. 输出有缓冲：'\n' 只换行，std::endl 换行 + flush；大量循环输出用 '\n'，flush 交给程序结束、缓冲区满与 tied 流。
4. 文件流：构造后先查 is_open()；close() 后写入静默失败；追加用 std::ios::app；读文件用 while (in >> x) 而非 !in.eof()。
5. cin 提取失败会置 failbit 并锁死后续读取；遇到 >> 与 getline 混用时，用”额外一次 getline”消费残留换行。

常见陷阱与注意事项

1. getline 与 cin >> 混用：cin >> pi 之后缓冲区残留 '\n'，紧跟的 getline 读到空串。修复：多调一次 getline（或 std::cin.ignore()）吃掉换行。课程原话：”Don’t use getline() and std::cin together, unless you really really have to!”
2. 对已关闭的流写入：ofs.close() 之后 ofs << ... 静默失败、不报错，排查时极易忽略。
3. 把 std::endl 当换行符：循环内每次迭代都 flush，I/O 次数暴涨，程序明显变慢——'\n' 才是换行符。
4. cin >> double 读到非数字：如 cin >> tao 遇到 "Fernandez"，提取失败、failbit 置位、之后所有读取失效（示例 4 的垃圾值场景）。
5. 忘记检查 is_open()：文件不存在或路径错误时直接读写，读侧得到空数据、写侧悄悄丢弃——先检查再操作。

关联作业提示

A1: SimpleEnroll 几乎完全建立在流之上：

• Part 1 parse_csv：用 std::ifstream 打开 courses.csv；注意”每个记录是一整行“，所以外层用 std::getline(ifs, line) 逐行读，跳过第一行列名（header）；再用提供的 split（内部是 stringstream）或 getline(ss, field, ',') 按逗号分列，把 Title / Units / Quarter 填入 Course 结构体。
• Part 2/3 写文件：用 std::ofstream 写 student_output/courses_offered.csv 与 courses_not_offered.csv；务必先写回列名行，且格式严格为 <Title>,<Units>,<Quarter>（逗号后无空格），否则 autograder 不通过；写完用 close()。
• 流与类型：Course 结构体的字段（std::string 与 int）正是流的 <</>> 能直接处理的类型——回忆幻灯片问题：”remember what types streams deal with?”（流处理的都是可 <</>> 的类型）。
• 提醒：不要在遍历 all_courses 的同时删除元素（A1 明确警告）——先把要保留的课程收集到新容器，再统一删除。

Lecture 5 (Week 3 - Tuesday): 容器 (Containers)

概述

本讲介绍 C++ 标准库（STL）的容器（containers）：std::vector、std::deque、std::map、std::set、std::unordered_map、std::unordered_set。你将学会每种容器的数据结构本质、时间复杂度权衡与适用场景，以及如何统一地遍历它们（for-each 循环，其底层机制是下一讲的主角——迭代器）。容器解决”如何存储一组相关的东西”，是 STL 三大件（容器 / 迭代器 / 算法）的基石，也是 A2（Marriage Pact）的核心工具。幻灯片为图片型（文本极少），本笔记依据课程主题、课堂代码（temperature.cpp、double-agent.cpp）与 C++ 专业知识整理。

核心特性与语法详解

1. 容器是什么（Container）

• 定义与目的：容器是”存储一组对象”的数据结构抽象。STL 提供多种容器，各有不同的底层实现与操作代价，对应不同场景。
• 核心语法：std::vector<int> v {1, 2, 3};（C++11 起支持 {} 列表初始化）。
• 设计意图：不自己手写链表/数组/树——标准库已经实现并优化好了。选择容器的本质是选择时间复杂度：同一个操作在不同容器上开销可以差出几个数量级。

2. 序列容器：std::vector 与 std::deque

• 定义与目的：按”位置”组织元素，元素有先后顺序、可按下标访问。
• std::vector——动态数组：元素存储在一块连续内存中。
  • 随机访问 v[i]：O(1)
  • 尾部插入/删除 push_back/pop_back：均摊 O(1)（容量不足时整体搬家扩容，均摊后仍为常数）
  • 头部/中间插入删除 insert/erase：O(n)（后续元素全部平移）
  • 适用：绝大多数默认选择——需要随机访问、主要在尾部增删。
• std::deque——双端队列：分块连续内存（多段连续缓冲拼接）。
  • 头部与尾部插入/删除 push_front/push_back/pop_front/pop_back：均摊 O(1)
  • 随机访问：O(1)（分块定位）
  • 中间插入删除：O(n)
  • 适用：需要在两端都频繁增删（本讲课后小测：”Which type(s) lets you insert at the back and front equally efficiently?” → std::deque）。
• vector 没有 push_front：头部插入只能用 insert(v.begin(), x)（O(n)）——这是设计上”不给你慢方法”的体现（下一讲会再次遇到这个哲学）。

3. 有序关联容器：std::map 与 std::set

• 定义与目的：按键（key）组织数据，内部是红黑树（平衡二叉搜索树），元素按键有序存储。
• std::map：键 → 值的映射，键唯一。查找/插入/删除：O(log n)。遍历时按键升序输出。
• std::set：只有键、没有值的”集合”，键唯一、有序，查找/插入/删除 O(log n)。
• 核心语法：

  std::map<std::string, int> ages {{"Alice", 20}, {"Bob", 21}};
  ages["Carol"] = 19;                 // 插入或更新
  if (ages.find("Alice") != ages.end()) { /* 存在 */ }
  std::set<int> s {3, 1, 2};          // 内部按 1,2,3 排序存储
  

• 比较运算符要求：map/set 的键类型必须支持 operator<（严格弱序），因为红黑树靠比较维持有序性——这正是课后小测第二问：”Which type(s) requires a comparison operator on the element type?” → std::map, std::set。
• 适用：需要有序遍历、范围查询、按序输出；能接受 O(log n) 的代价。

4. 哈希关联容器：std::unordered_map 与 std::unordered_set

• 定义与目的：用哈希表（hash table）组织数据，以空间换时间。
• 查找/插入/删除：均摊 O(1)（理想情况；最坏 O(n)，取决于哈希质量与负载因子）。
• 不需要比较运算符，需要的是哈希函数（键类型提供 std::hash<T>）与相等比较 operator==。
• 遍历顺序无意义：元素按桶（bucket）存放，顺序与插入顺序、大小关系都无关。
• 为什么通常更快：课后小测第三问：”Which is usually faster: unordered_set or set? Why?” → unordered_set：哈希 + 较小的负载因子（load factor）让查找期望 O(1)，而 set 的红黑树查找严格 O(log n)；元素多时差距明显。
• 适用：只需要”键存在与否 / 键 → 值”、不需要有序输出时，优先选 unordered 版本。

5. 容器的初始化方式

• 核心语法（C++11 起，{} 统一初始化 + initializer_list）：

  std::vector<int> v {1, 2, 3};                 // 三个元素 1,2,3
  std::vector<int> v2(3, 7);                    // 三个元素都是 7（大小 + 初值）
  std::map<std::string, int> m {{"a", 1}, {"b", 2}};   // 嵌套 {} 表示键值对
  std::set<std::string> names {"Chris", "Nick", "Sean"};
  

• 注意区分：vector<int> v{3} 是”一个元素 3”；vector<int> v(3) 是”三个元素 0”。花括号优先匹配 initializer_list。

6. 遍历容器：for-each 循环

• 定义与目的：统一遍历所有容器（vector/deque/map/set/unordered_*）的方式。
• 核心语法：

  for (const auto& elem : container) { /* 使用 elem */ }
  for (const auto& [key, value] : map) { /* C++17 结构化绑定 */ }
  

• 机制：for-each 是语法糖，编译器把它展开成迭代器循环（auto b = c.begin(); auto e = c.end(); for (auto it = b; it != e; ++it) { auto& elem = *it; ... }）——这正是下一讲（L6）的核心内容。map 的元素类型是 std::pair<const K, V>，所以遍历 map 时 elem.first 是键、elem.second 是值。
• 最佳实践：只读遍历用 const auto&（避免拷贝大对象）；需要修改元素用 auto&；unordered_map 的遍历顺序不保证，别依赖。

7. 常用成员函数速查

代码示例与逐步解说（核心）

示例 1：std::vector 与线性扫描（课堂代码 temperature.cpp 补全）

// C++11
#include <iostream>
#include <vector>

// 返回最高温度；没有温度数据时返回 -1
int findPeakHeat(const std::vector<int>& temps) {
    if (temps.empty()) {
        return -1;                      // 空容器保护：不要访问 temps[0]
    }
    int best = temps[0];
    for (const auto& t : temps) {       // 遍历：t 是 const int&
        if (t > best) best = t;
    }
    return best;
}

int main() {
    // 未来 7 天最高气温预报（C++11 列表初始化）
    std::vector<int> weeklyForecast = {62, 63, 65, 68, 69, 66, 65};
    std::cout << "Max temp this week will be " << findPeakHeat(weeklyForecast) << '\n';
    return 0;
}

• 代码做什么：把 7 个温度放进 vector，用 for-each 找出最大值并打印。
• 特性机制解说：std::vector<int> 在堆上维护一块连续内存，weeklyForecast 只持有指向这块内存的指针、大小与容量。const auto& t 让 t 成为元素的引用（不拷贝 int 本身，虽然 int 拷贝便宜，但这是好习惯的起点）；empty() 先于 [0] 检查，避免对空容器访问未定义行为。若数据量更大，可直接用 <algorithm> 的 std::max_element（L10 之后会讲），但手写 for-each 更能理解容器语义。

示例 2：std::map + std::set 找”双重身份员工”（课堂代码 double-agent.cpp 补全）

// C++17（结构化绑定；若只支持 C++11 可改用 pair.first/.second）
#include <iostream>
#include <map>
#include <set>
#include <string>

// 找出出现在多个部门里的员工
std::set<std::string> findDoubleAgents(
        const std::map<std::string, std::set<std::string>>& departments) {
    std::set<std::string> seen;
    std::set<std::string> doubleAgents;

    for (const auto& [dept, members] : departments) {  // C++17 结构化绑定
        for (const auto& name : members) {             // 遍历每个部门的员工集合
            if (seen.count(name)) {                    // 之前见过 → 双重身份
                doubleAgents.insert(name);
            } else {
                seen.insert(name);
            }
        }
    }
    return doubleAgents;                               // 按名字升序返回
}

int main() {
    std::map<std::string, std::set<std::string>> company = {
        {"Sales",      {"Jim", "Dwight", "Phyllis"}},
        {"Accounting", {"Angela", "Oscar", "Kevin"}},
        {"Pranks",     {"Jim", "Pam"}}
    };

    std::set<std::string> multiTaskers = findDoubleAgents(company);
    std::cout << "Double Agents: ";
    for (const auto& name : multiTaskers) std::cout << name << " ";  // 应打印 Jim
    std::cout << '\n';
    return 0;
}

• 代码做什么：公司是 map<部门, set<员工>>；遍历所有部门的所有员工，凡在多个部门出现的名字（Jim 同时在 Sales 和 Pranks）放入结果 set 并打印。
• 特性机制解说：
  • std::map 的遍历元素是 std::pair<const std::string, std::set<std::string>>——C++17 结构化绑定 [dept, members] 等价于 C++11 的 pair.first/pair.second。
  • set 的 count(x) 返回 0 或 1（键唯一），可当”是否存在”用；insert 保持有序（红黑树），所以结果自动按字母序输出。
  • 嵌套容器 map<string, set<string>> 展示了容器可任意组合，这是 STL”组件可拼装”的设计。
  • 整个函数是纯”容器 + 遍历”逻辑，没有手写任何内存管理——这正是容器的价值。

示例 3：std::unordered_map 词频统计（补充示例）

// C++17（结构化绑定；C++11 可用 pair.first/.second）
#include <iostream>
#include <sstream>
#include <string>
#include <unordered_map>

int main() {
    std::string text = "the quick brown fox jumps over the lazy dog the end";
    std::stringstream ss(text);

    std::unordered_map<std::string, int> freq;
    std::string word;
    while (ss >> word) {        // 按空白分词
        ++freq[word];           // operator[]：不存在则默认构造 0，再自增
    }

    for (const auto& [w, c] : freq) {
        std::cout << w << ": " << c << '\n';
    }
    return 0;
}

• 代码做什么：统计一句话里每个单词出现次数。
• 特性机制解说：++freq[word] 依赖 operator[] 的语义——键不存在时默认构造一个 int{0} 并插入，然后自增。这是 map/unordered_map 最方便但也最危险的操作（见陷阱 1）。哈希表让每个单词的查找均摊 O(1)；遍历顺序由桶布局决定、与输入顺序无关。若要”按词频从高到低”输出，需要先把条目搬到 vector 再排序——unordered_map 本身不提供有序遍历。

示例 4：map 的 operator[] 陷阱（补充示例）

// C++11
#include <iostream>
#include <map>
#include <string>

int main() {
    std::map<std::string, int> scores;
    scores["Alice"] = 92;       // 插入

    std::cout << scores["Bob"] << '\n';   // 危险：查询时也插入了 {"Bob", 0}！

    if (scores.find("Bob") != scores.end()) {   // C++20 可写作 scores.contains("Bob")
        std::cout << "Bob exists\n";
    } else {
        std::cout << "Bob does not exist\n";
    }

    std::cout << "size = " << scores.size() << '\n';   // 2，而不是 1！
    return 0;
}

• 代码做什么：试图”查询”Bob 的成绩，结果 Bob 被凭空插入 map。
• 特性机制解说：m[k] 的完整语义是”如果键不存在，就默认构造一个值插进去，然后返回值的引用”。因此只做存在性检查绝不能用 []——应该用 find（C++20 起可用 contains）。这个陷阱对 std::map 与 std::unordered_map 同样成立。

示例 5：std::deque 双端操作（补充示例）

// C++11
#include <deque>
#include <iostream>
#include <vector>

int main() {
    std::deque<int> d;
    d.push_back(1);             // 尾部插入 O(1)
    d.push_front(0);            // 头部插入 O(1)
    d.push_back(2);
    std::cout << d[0] << ' ' << d[1] << ' ' << d[2] << '\n';  // 0 1 2（随机访问 O(1)）

    std::vector<int> v {1};
    v.push_back(2);             // 尾部均摊 O(1)
    // v.push_front(0);         // ❌ vector 没有 push_front！
    v.insert(v.begin(), 0);     // 头部插入要整体平移：O(n)
    return 0;
}

• 代码做什么：对比 deque 与 vector 在头部插入的代价。
• 特性机制解说：deque 内部是”分块连续 + 中央索引”的结构，两端都能 O(1) 增删、仍支持 O(1) 下标访问（比 std::list 强）。课后小测第一问的答案正是 std::deque。而 vector 没有 push_front——C++ 的哲学是不提供注定慢的操作，逼你根据场景选对容器。

与旧标准（如C++98）的对比

• std::vector、std::deque、std::map、std::set C++98 已有（源自 1994 年左右的 SGI STL），底层结构与复杂度约定至今未变。真正的变化在使用体验：
• 无序容器：unordered_map/unordered_set 在 C++11 才进入标准（C++98 时代只能靠 TR1 的 std::tr1::unordered_map 或第三方库）。此前要实现 O(1) 查找只能手写哈希表。
• 初始化：C++98 没有 {} 列表初始化，容器只能”先构造再逐个 insert/push_back”；C++11 的 initializer_list 让 std::map<std::string, int> m {{"a",1},{"b",2}}; 一行完成。
• 遍历：C++98 写 for (std::map<std::string, int>::iterator it = m.begin(); it != m.end(); ++it)，类型冗长易错；C++11 的 auto + 范围 for 让遍历变成 for (const auto& p : m)。
• C++17 结构化绑定：for (const auto& [k, v] : m) 取代了 pair.first/.second 的手工解包；C++17 的 map::try_emplace 解决”先查再插”的重复哈希问题。
• C++20 contains()：m.contains(k) 比 m.find(k) != m.end() 更直白；C++20 的 ranges 视图进一步简化了容器管道操作（L10 之后涉及）。

关键要点

1. 先选对容器，再写代码：随机访问 + 尾部增删 → vector；双端频繁增删 → deque；按键有序查找 → map/set（O(log n)）；只要 O(1) 查找、不在乎顺序 → unordered_map/unordered_set。
2. 有序 vs 无序是根本分歧：map/set 要求键支持 operator< 且遍历有序；unordered_* 要求键支持 std::hash + operator==，遍历无序但通常更快（哈希 + 小负载因子）。
3. for-each 统一遍历一切容器：for (const auto& elem : c) 对 vector/deque/map/set/unordered_* 都成立（map 元素是 pair）；只读用 const auto&。
4. operator[] 会插入默认值：存在性检查用 find/contains/count，不要用 []。
5. 遍历时不要修改容器结构（插入/删除元素会使迭代器失效）——收集到新容器后再统一操作。

常见陷阱与注意事项

1. 用 m[k] 做存在性检查：会默默插入默认值，污染数据、改变 size()。改用 find（C++20 contains）、set 用 count。
2. 对空容器取元素：v[0]、v.front()、v.back() 在容器为空时是未定义行为——先 empty() 检查（示例 1 的 findPeakHeat 返回 -1 正是为此）。
3. vector<int> v{3} vs v(3)：前者是”一个元素 3”，后者是”三个元素 0”——花括号优先匹配 initializer_list，语义完全不同。
4. 误以为 unordered 容器有序：unordered_map 的遍历顺序由哈希桶决定，与插入顺序、键大小都无关；需要有序输出时请用 map，或把条目搬到 vector 再 std::sort。
5. 遍历中插入/删除元素：v.erase(it) 或 m.insert 使相关迭代器失效（vector 尤甚，可能全部失效），在循环里改容器会得到未定义行为——先收集、后修改。
6. 键类型不满足要求：给 map/set 用没有 operator< 的键、给 unordered_* 用没有 std::hash 的类型，编译器直接报错——这不是 bug 而是设计的善意提醒。

关联作业提示

A2: Marriage Pact 的核心工具就是容器与指针：

• Part 1 get_applicants：从 students.txt 逐行读名字，存进 std::set（或 std::unordered_set，二选一，需同步修改函数签名）。这正是本讲容器选择的实战：几千个名字、只需判存在/遍历，两者皆可；short_answer.txt 的 Q1 要求你书面回答两者权衡（有序 vs O(1) 哈希、内存、哈希函数质量）并举一个非课堂示例的合法哈希函数——本讲的复杂度对比表就是你的论据。
• Part 2 find_matches：遍历 students 集合（用 for-each 或迭代器），对每个名字调用你自己写的 initials() 辅助函数，与 kYourName 的缩写比较；匹配的名字把指针放进 std::queue<const std::string*>——注意存的是 std::string*（指向 set 中字符串的地址）而不是字符串本身，这正是本讲”容器存对象、指针指对象”的衔接。
• get_match：从 queue 取”真命天子”时注意 queue 为空的情况（打印 "NO MATCHES FOUND."）。
• Q2 简答题：”为什么存指针而不是名字？set 出作用域后指针会怎样？”——答案与容器元素地址的稳定性、指针悬垂（dangling）有关，是 L6 指针内容的直接延伸，务必结合本讲容器内存模型回答。

Lecture 6 (Week 3 - Thursday): 迭代器与指针 (Iterators & Pointers)

概述

本讲回答上一讲遗留的问题：”for-each 循环（for (const auto& elem : container)）到底是怎么工作的？”答案是迭代器（iterators）：一个在容器中”跟踪当前位置、能前进、能取值”的抽象。你将掌握迭代器的四件套接口（begin/end/++/*/==）、五大迭代器分类（Input / Output / Forward / Bidirectional / Random Access），并理解指针与内存的基本模型——指针是指向内存中任意对象的”地址数字”，迭代器与指针接口同构。这是 STL 泛型算法（L10 的 std::sort 等）能作用于所有容器的基础，也是 A2（Marriage Pact）中”存指针到 queue”与指针悬垂问题（Q2）的知识来源。

核心特性与语法详解

1. 为什么需要迭代器

• 定义与目的：用下标遍历（for (size_t i = 0; i < v.size(); ++i) v[i]）只对连续容器（vector）有效；std::set/std::map 没有下标、内部不是数组，无法用索引。我们需要一个对所有容器统一的遍历抽象。
• 核心语法（四件套）：

  auto it = c.begin();        // 1. 初始化：指向容器第一个元素
  ++it;                       // 2. 前进：移动到下一个元素
  auto& elem = *it;           // 3. 解引用：取得当前元素（it == end() 时未定义！）
  it == c.end()               // 4. 比较：判断是否走完了
  

• 设计意图与最佳实践：课堂用”抓娃娃机”作比喻——迭代器是那只”爪子”：能抓玩具（*it）、能向前移（++it）；容器是那台机器：告诉你从哪里开始（begin()）、何时停止（end()）。容器与迭代器协作，才构成遍历。

2. begin() 与 end() 的语义

• 定义与目的：begin() 返回指向第一个元素的迭代器（容器非空时）；end() 返回past-the-end 迭代器——指向最后一个元素之后一个位置，它从不指向任何元素，只作为”走完了吗？”的哨兵。
• 核心语法：

  auto b = c.begin();  auto e = c.end();
  for (auto it = b; it != e; ++it) { ... }
  

• 机制：
  • 空容器：begin() == end()，循环体一次都不执行。这是循环能安全处理空容器的基础。
  • 对 end() 解引用（*c.end()）是未定义行为——end 后面没有元素。
  • --e（先 auto e = c.end(); --e;）可得到最后一个元素的迭代器（要求双向迭代器）。

3. for-each 循环的展开（编译器做了什么）

• 定义与目的：for (auto elem : s) 是迭代器循环的语法糖。
• 核心语法（幻灯片给出的等价展开）：

  // 你写的：
  for (auto elem : s) { std::cout << elem; }
  // 编译器看到的：
  auto b = s.begin();
  auto e = s.end();
  for (auto it = b; it != e; ++it) {
      auto elem = *it;
      std::cout << elem;
  }
  

• 机制：因此 for-each 对任何提供 begin/end 与迭代器四件套的类型都成立——这正是它能同时遍历 vector、map、set、deque、unordered_* 的原因（上一讲的课后小测即由此引出）。

4. 迭代器的类型：为什么那么长，以及 auto / using

• 定义与目的：std::map<int, int>::iterator 这类类型名极其冗长。
• 核心语法：

  std::map<int, int> m {{1,2},{3,4},{5,6}};
  auto it = m.begin();                    // C++11 起：让编译器推断
  auto elem = *it;                        // elem 是 std::pair<int, int>
  // 显式写法（C++98 风格）：
  std::map<int, int>::iterator it2 = m.begin();
  

• 机制：<map> 头文件内部有 using iterator = /* 某种迭代器类型 */;（using 是类型别名，等价于 C 的 typedef）。*m.begin() 的类型是 std::pair<const int, int>，所以 auto elem = *it; 得到的是 pair 的拷贝。幻灯片提醒：”Iterator types are really long, so we like to use auto with iterators.”

5. ++it 还是 it++？

• 定义与目的：前缀与后缀自增语义不同，代价不同。
• 核心语法（迭代器类的两个重载）：

  Iterator& operator++();      // 前缀 ++it：先自增，返回指向同一对象的引用
  Iterator  operator++(int);   // 后缀 it++：自增，但返回旧值的拷贝
  

• 机制：迭代器是完整的对象，拷贝它比拷贝 int 贵得多。后缀版本为了返回旧值必须做一次拷贝，因此循环里统一写 ++it。Bjarne 的原话：”++i is sometimes faster than, and is never slower than, i++… why not just write ++i instead? You never lose anything, and you sometimes gain something.”

6. 迭代器分类（五大类型）

• 定义与目的：不是所有迭代器生而平等——不同容器支持的操作不同，按”能力”分级；算法（如 std::sort）会要求最低级别的迭代器。
• 分类（能力从弱到强）：
  • Input（输入）：最基本，只能读：auto elem = *it;。单遍（single-pass）语义，如流迭代器。
  • Output（输出）：只能写：*it = elem;。
  • Forward（前向）：Input 的加强，支持多遍遍历（multi-pass guarantee：it1 == it2 蕴含 ++it1 == ++it2，即同一个迭代器可以反复前进、重走同一段）。所有 STL 容器迭代器都至少是 Forward。为什么流不是？——流读一次就没了，无法重放，所以流迭代器只是 Input。
  • Bidirectional（双向）：Forward 之上支持 --it 后退。std::map、std::set 的迭代器属于此类（红黑树节点只能沿链前后移动）。
  • Random Access（随机访问）：最强大，支持 it += n、it - n、it[n]、it1 < it2 等”任意跳转与比较”。std::vector、std::deque 的迭代器属于此类（底层连续/近连续内存）。
• 机制与为什么重要：std::sort 需要随机访问迭代器（它要反复跳跃划分区间）。std::sort(vec.begin(), vec.end()) ✅ 可编译；std::sort(set.begin(), set.end()) ❌ 编译失败——set 的迭代器只是双向的。C++ 的设计哲学：”不提供注定慢的方法“：在红黑树上做 it + 5 是 O(n) 的慢操作，所以 map/set 的迭代器干脆不提供随机访问，让错误在编译期暴露。

7. 指针与内存（Pointers and Memory）

• 定义与目的：迭代器指向容器元素；指针指向内存中的任意对象。理解指针前先理解内存。
• 内存基础：
  • 每个变量都住在内存的某个地址；程序的所有地址构成地址空间（64 位系统从 0x0 到 2^64-1）。
  • 内存按字节寻址：每个字节一个编号；对象的地址 = 它最低字节的地址。int 占 32 位 = 4 字节，int x = 106; 的地址是其 4 个字节中最低的那个（字节序有大小端之分，演示常用 Big Endian，实际多为 Little Endian）。
• 取地址与解引用：

  int x = 106;
  int* px = &x;      // & = 取地址运算符：得到 x 的地址
  std::cout << *px;  // * = 解引用：顺着地址取回对象，打印 106
  

• 指针就是”一个数字”：px 里存的不过是一个无符号整数（地址值，如 0x50527c），打印 px 看到的就是这个数。
• 指针可以指向任何对象：结构体 StanfordID* p = &id; p->name;（-> 等价于 (*p).）、std::vector<int>* p = &v;、数组元素 int* arr = &v[0];。
• 数组指针算术（vector 是连续内存，所以指针算术成立）：

  int* arr = &v[0];
  arr += 1;  // 前进一个 int（不是 1 字节！按所指类型缩放）
  ++arr;
  if (arr == &v[4]) ...
  

• 迭代器与指针同构：vector<T>::iterator 的底层类型几乎就是 T*（真实实现中不是裸指针，但接口完全一致：初始化、+=、++、*、==）。所以对 vector 而言，指针遍历和迭代器遍历写起来一模一样。

代码示例与逐步解说（核心）

示例 1：用迭代器遍历 std::set（幻灯片示例，含 for-each 对照）

// C++11
#include <iostream>
#include <set>

int main() {
    std::set<int> s {1, 2, 3, 4};

    // 手写迭代器循环（set 没有下标，只能这样遍历）
    for (auto it = s.begin(); it != s.end(); ++it) {
        std::cout << *it << ' ';
    }
    std::cout << '\n';

    // for-each 是上面这段的语法糖（编译器自动展开）
    for (auto elem : s) {
        std::cout << elem << ' ';
    }
    std::cout << '\n';
    return 0;
}

• 代码做什么：用两种等价方式打印 1 2 3 4（set 自动升序）。
• 特性机制解说：s.begin() 是 std::set<int>::iterator；++it 沿红黑树的中序遍历移动到下一个节点；*it 解引用取出节点里的 int；it != s.end() 用哨兵判断结束。注意迭代器是双向的——s.begin() 没有下标、it += 2 会编译失败，这正体现了”容器实现决定迭代器能力”。

示例 2：迭代器四件套与空容器（幻灯片接口逐条演示）

// C++11
#include <iostream>
#include <vector>

int main() {
    std::vector<char> v {'d', 'a', 'w', 'g', 's'};

    auto it = v.begin();              // 1. 初始化：指向 'd'
    ++it;                             // 2. 前进：指向 'a'
    auto& elem = *it;                 // 3. 解引用：拿到元素的引用
    std::cout << elem << '\n';        // a
    std::cout << (it == v.end() ? "at end\n" : "not at end\n");  // not at end

    ++it; ++it; ++it; ++it;           // 4 次前进：'w' → 'g' → 's' → 哨兵位
    std::cout << (it == v.end() ? "reached end\n" : "not end\n"); // reached end

    std::vector<int> empty;
    std::cout << (empty.begin() == empty.end()
                      ? "empty: begin == end\n" : "?\n");
    return 0;
}

• 代码做什么：完整走一遍 begin/++/*/== 四件套，并验证空容器的 begin() == end()。
• 特性机制解说：end() 返回的哨兵不指向元素——it 走过第 5 个元素后与 end() 相等，此刻若执行 *it 就是未定义行为。空容器时 begin()==end()，任何”从头走到尾”的循环体自然执行零次，这就是 for-each 能安全处理空容器的原因。

示例 3：用迭代器做递归二分查找（课堂代码 binary-search.cpp 补全）

// C++11
#include <iostream>
#include <iterator>   // std::distance
#include <vector>

// 在 [begin, end) 区间内递归查找 value（区间为半开区间）
bool binarySearch(std::vector<int>::iterator begin,
                  std::vector<int>::iterator end, int value) {
    if (begin >= end) {                    // 1. 基准情形：区间为空
        return false;
    }

    auto mid = begin + (std::distance(begin, end) / 2);   // 2. 中点迭代器

    if (*mid == value) {                   // 3. 命中
        return true;
    }
    if (*mid > value) {
        return binarySearch(begin, mid, value);           // 左半 [begin, mid)
    }
    return binarySearch(mid + 1, end, value);             // 右半 [mid+1, end)
}

int main() {
    std::vector<int> data = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
    int testValues[] = {23, 2, 91, 40};    // 命中 / 首边界 / 尾边界 / 未命中

    std::cout << "Recursive Iterator Binary Search Test:\n";
    for (int val : testValues) {
        std::cout << "Searching for " << val << ": "
                  << (binarySearch(data.begin(), data.end(), val)
                          ? "SUCCESS" : "FAILURE") << '\n';
    }
    return 0;
}

• 代码做什么：对有序 vector 递归二分查找；begin/end 是迭代器而非下标，体现”用迭代器表达区间”。
• 特性机制解说：
  • begin >= end 依赖随机访问迭代器才有的比较运算——若把参数换成 std::set<int>::iterator 将无法编译（二分查找本来就需要随机访问）。
  • begin + n 是”跳过 n 个元素”的随机访问运算；std::distance(begin, end) 计算两个迭代器之间的元素个数。
  • 区间写作 [begin, end)（左闭右开）是 STL 的通用约定：左端点包含、右端点（end）不包含。递归分治时天然用 [begin, mid) 与 [mid+1, end) 表达左右两半。
  • 把区间当”值”传来传去，正是迭代器比下标优雅的地方：同一套代码可推广到 deque 等随机访问容器。

示例 4：指针基础——取地址、解引用、指向任意对象（幻灯片示例）

// C++11
#include <iostream>
#include <string>
#include <vector>

struct StanfordID {
    std::string name;
};

int main() {
    int x = 106;
    int* px = &x;                 // & 取地址：px 保存 x 的地址
    std::cout << x << '\n';       // 106
    std::cout << *px << '\n';     // 106（* 解引用）
    std::cout << px << '\n';      // 0x…（地址本身，一个"数字"）

    StanfordID id {"rfern"};
    StanfordID* p = &id;
    auto name = p->name;          // -> 等价于 (*p).name

    std::vector<int> v {1, 2, 3, 4, 5};
    int* arr = &v[0];             // 指向 vector 底层连续数组的首元素
    std::cout << *arr << ' ';     // 1
    arr += 1; std::cout << *arr << ' ';   // 2（指针算术按 int 大小缩放）
    ++arr;    std::cout << *arr << ' ';   // 3
    arr += 2; std::cout << *arr << ' ';   // 5
    if (arr == &v[4]) std::cout << "At last index";
    std::cout << '\n';
    return 0;
}

• 代码做什么：展示 & 取地址、* 解引用、-> 成员访问、以及指向 vector 内部数组的指针算术，输出 106 106 0x… 1 2 3 5 At last index。
• 特性机制解说：px 里存的只是一个地址数字；*px 让编译器”按 int* 的类型信息去那地址读取 4 字节”。arr += 1 前进的不是 1 字节而是 1 个 int（4 字节）——指针算术按所指类型的大小缩放，这正是 int* 与 char* 区别的根源。vector 保证元素连续存放，所以 &v[0] 之后可以放心做数组式指针算术；若指向 set 的节点则完全无效（节点不连续）。

示例 5：迭代器与指针的接口同构（幻灯片对照）

// C++11
#include <iostream>
#include <vector>

int main() {
    std::vector<int> v {1, 2, 3, 4, 5};

    // 用裸指针遍历 vector 的底层数组
    int* p = &v[0];
    for (int* q = p; q != p + 5; ++q) std::cout << *q << ' ';
    std::cout << '\n';

    // 用迭代器遍历——接口一模一样
    for (auto it = v.begin(); it != v.end(); ++it) std::cout << *it << ' ';
    std::cout << '\n';

    // 随机访问操作逐条对照
    auto it = v.begin();
    it += 1; std::cout << *it << ' ';             // 2
    ++it;    std::cout << *it << ' ';             // 3
    it += 2; std::cout << *it << ' ';             // 5
    if (it == v.end() - 1) std::cout << "At last element";
    std::cout << '\n';
    return 0;
}

• 代码做什么：先用指针、再用迭代器，走完全相同的”初始化 → 随机访问 → 前进 → 比较”路线，输出两遍 1 2 3 4 5 与 2 3 5 At last element。
• 特性机制解说：幻灯片指出，vector<T>::iterator 底层类型几乎就是 T*（”In the real STL implementation, the actual type is not T*. But for all intents and purposes, you can think of it this way.”）。两者共享同一接口：*、++、+=、==、<。区别在于：迭代器是类型安全、容器感知的抽象（对 map/set 会是另一种实现），且自带 end() 哨兵约定；指针则更”原始”，可以指向内存里任何地方——包括不该碰的地方。这就是 A2 中”存指针”需要小心的原因。

与旧标准（如C++98）的对比

• 迭代器是 C++98 就有的 STL 核心设施：begin()/end()/++/*/==、五大分类、std::distance/std::advance 在 C++98 里都已存在。本讲真正的新东西是使用体验：
• C++98 的冗长遍历：for (std::map<std::string, int>::const_iterator it = m.begin(); it != m.end(); ++it)——类型名长到令人窒息，还容易写错 const_iterator。C++11 的 auto + 范围 for 让遍历变成 for (const auto& p : m)，由编译器生成迭代器循环。幻灯片正是用”set 没有下标 → 只能迭代器”来引出这一点。
• C++11 起：auto 推断迭代器类型；范围 for（for (auto elem : s)）正式成为语法糖；cbegin()/cend() 提供只读迭代器。
• C++20 ranges：std::ranges::sort、视图（views）把”迭代器对”升级为”范围”抽象，但仍建立在迭代器之上；课程 L10 之后会展开。
• 指针方面：裸指针与手动 new/delete 是 C++98 时代的内存管理常态，极易泄漏；C++11 的智能指针（std::unique_ptr 等）把”指针”封装成 RAII 对象（课程 L16 详细讲）。本讲先理解裸指针的机制，后续再学安全封装。
• 对比 C：指针与指针算术（arr + i）直接继承自 C；C++ 的迭代器是 C 指针思想的安全泛化——把”指针能做的操作”抽象成接口，让每个容器都能提供。

关键要点

1. 迭代器四件套：auto it = c.begin(); → ++it → *it → it != c.end()；end() 是”过去末尾”的哨兵，永远不要解引用 end()。
2. for-each 就是迭代器循环：for (auto elem : s) 被编译器展开为 begin/end/++/* 循环，所以它对一切提供 begin/end 的容器统一有效；空容器由 begin()==end() 天然处理。
3. 迭代器按能力分级：Input(读) → Output(写) → Forward(多遍) → Bidirectional(可退) → Random Access(可跳)；std::sort 等算法要求随机访问，map/set 只给双向——”不给慢方法”。
4. 循环里写 ++it 而不是 it++：前缀不拷贝旧值，”never slower, sometimes faster”（Bjarne）。
5. 指针 = 内存地址 = 一个数字：& 取地址、* 解引用、-> 访问成员；指针算术按所指类型缩放；vector<T>::iterator 与 T* 接口同构。

常见陷阱与注意事项

1. 解引用 end()：*c.end()、c.end()[0] 都是未定义行为；越界访问（如对 size 3 的 vector，it += 3 后再 *it，幻灯片专门演示过）同样 UB——迭代器不像下标有 at() 帮你检查。
2. 对空容器解引用 begin()：空容器 begin()==end()，*v.begin() 是 UB；先判空或依赖循环条件。
3. 滥用 it++：把 i++ 的坏习惯带到迭代器上，每次迭代白做一次对象拷贝；统一 ++it。
4. 指针/迭代器算术越界：arr += 100 超出数组边界后再解引用是 UB；arr == &v[4] 这类比较也只在同一数组内才有定义。
5. 迭代期间修改容器：insert/erase 会使迭代器失效（vector 扩容可能使全部失效），之后再用旧迭代器是 UB——本讲先记住现象，L13（特殊成员函数）与后续课程会讲透容器与迭代器的生命周期。
6. 存指针后容器析构（A2 Q2 的核心）：把指向 set 元素的指针存进 queue，一旦 set 出作用域，指针就悬垂（dangling）——解引用是 UB。指针”指向谁”的责任完全在程序员。

关联作业提示

A2: Marriage Pact 是迭代器与指针的实战舞台：

• Part 2 find_matches：遍历 std::set<std::string> students 找与你同缩写的人。set 没有下标，只能用本讲的迭代器循环或 for-each（for (const auto& name : students)）；作业提示也明确建议回看”Thursday’s lecture on iterators and pointers”。
• 存指针到 std::queue：匹配成功时把 &name（指向 set 中字符串的地址，注意不能存局部变量 name 的地址，要存 *it/元素的地址）push 进 std::queue<const std::string*>。
• Q2 简答题：”为什么存指针而不存字符串？set 出作用域后指针会怎样？”——答案要用到本讲的指针模型：拷贝整个字符串昂贵、指针廉价；set 的节点在插入后地址稳定（不像 vector 扩容会搬移），所以 set 存活期间指针有效；一旦 set 析构，指针悬垂，解引用即 UB。这正是”指针指向的对象生命周期由程序员负责”的体现。
• binary-search.cpp 的区间思维：[begin, end) 半开区间约定在 A2 遍历 set、以及未来一切 STL 算法（std::sort、std::find）中反复出现，务必内化。

Lecture 7 (Week 4 - Tuesday): 类 (Classes)

概述

本讲是 C++ 面向对象编程的起点：C 语言没有对象，无法把”数据”与”操作这些数据的函数”封装在一起，而 C++（最初就叫 “C with Classes”）通过 类（class） 这一用户自定义类型实现了封装、继承与多态。学习目标是掌握 struct 与 class 的区别、public/private 访问控制、头文件（.h）与源文件（.cpp）的分离、构造器（默认/带参/成员初始化列表/重载）、this 指针、getter/setter、析构函数、类型别名，以及继承的三种方式（public/protected/private）、虚函数与 vtable、菱形继承与虚继承。这些是后续讲”类模板”“const 正确性”以及作业 A3 的地基。

核心特性与语法详解

1. struct vs class：默认访问级别

• 定义与目的：struct 和 class 几乎完全相同，唯一区别是默认访问级别：struct 的成员默认 public，class 的成员默认 private。结构体适合”纯数据聚合”（如 std::pair），类适合”封装 + 行为”。
• 核心语法：

  struct Point { int x; int y; };      // 成员默认 public
  class  Point { int x; int y; };      // 成员默认 private！
  

• 设计意图与最佳实践：类的设计哲学是信息隐藏：数据成员放在 private 区，只通过 public 接口（成员函数）间接访问，这样可以在 setter 里做合法性校验（例如拒绝负数 id），防止用户把对象弄成无效状态。

2. public / private 访问控制

• 定义与目的：public 成员对所有人可见（用户接口）；private 成员只对本类可见（实现细节）；protected 介于两者之间——对子类可见、对外部不可见（详见本讲”继承”一节）。
• 核心语法：

  class ClassName {
  private:
      // 只有本类的成员函数能访问
  public:
      // 所有人都能访问
  };
  

• 设计意图与最佳实践：”用户能碰 public，摸不到 private”。公开的应该是做什么（接口），隐藏的应该是怎么做（实现）。后续若改实现，只要接口不变，调用方代码不用动。

3. 头文件（.h）与源文件（.cpp）分离

• 定义与目的：.h 定义接口（类声明、函数原型、类型定义、常量），被多个源文件共享；.cpp 实现接口（成员函数的函数体），被单独编译成目标文件。
• 核心语法：

  // StanfordID.h —— 接口
  class StanfordID {
  public:
      StanfordID(std::string name, std::string sunet, int idNumber);
      std::string getName();
  private:
      std::string name;
  };
  

  // StanfordID.cpp —— 实现
  #include "StanfordID.h"
  StanfordID::StanfordID(std::string name, std::string sunet, int idNumber)
      : name{name}, sunet{sunet} {}
  std::string StanfordID::getName() { return this->name; }
  

• 设计意图与最佳实践：.cpp 里定义成员函数时必须用 类名:: 作为作用域（就像 std:: 之于标准库），告诉编译器”这个函数属于哪个类”。注意：class StanfordID {...}; 结尾要加分号；StanfordID::StanfordID(...) 中 :: 前面的名字是类、后面的名字是构造器名。

4. 构造函数（Constructor）

• 定义与目的：构造函数在对象创建时初始化其状态（成员变量）。课堂例子 StanfordID 的对象需要 name、sunet、idNumber 三个字段，构造函数负责把它们设好。
• 核心语法（语法就是类名）：

  // 带参构造器（.cpp 中实现）
  StanfordID::StanfordID(std::string name, std::string sunet, int idNumber)
      : name{name}, sunet{sunet}, idNumber{idNumber} {}
  

• 设计意图与最佳实践：
  • 成员初始化列表（name{name}，注意花括号）：直接初始化成员，是首选方式（避免先默认构造再赋值）。
  • 构造器重载：编译器根据实参个数/类型自动选择调用哪一个（StanfordID s1; 调默认构造器，StanfordID s2{"a","b",1}; 调带参构造器）。
  • 构造函数体内还可以做参数校验（例如 if (idNumber > 0) ...），保证对象一出生就是合法的。

5. this 指针

• 定义与目的：this 是指向”当前对象”的指针，用于在参数名与成员名相同时消除歧义。
• 核心语法：

  void StanfordID::setName(std::string name) {
      this->name = name;   // 左边是成员，右边是参数
  }
  

• 设计意图与最佳实践：当参数和成员同名时，name = name; 只是”参数赋给自己”，成员根本没被修改——这是经典 bug。写 this->name 明确”我要的是这个对象的 name 成员”。

6. Getter / Setter

• 定义与目的：私有字段不直接暴露，通过 getter（读）和 setter（写）受控访问；setter 内部可以做校验（如 setID 拒绝负数）。
• 核心语法：

  std::string StanfordID::getName() { return this->name; }
  void StanfordID::setID(int idNumber) {
      if (idNumber >= 0) { this->idNumber = idNumber; }
  }
  

• 设计意图与最佳实践：把”数据的合法性规则”收进 setter 一处，所有调用方自动受益。现代 C++ 还要求只读 getter 标记为 const（见 Lecture 9 的 const 正确性）。

7. 析构函数（Destructor）

• 定义与目的：对象生命周期结束时（离开作用域）自动调用，负责释放动态分配的资源（delete [] my_array;）。不写也可以——只要类里没有 new 出来的资源，编译器会隐式生成析构函数。
• 核心语法：

  StanfordID::~StanfordID() {
      // free/deallocate any data here（本例无动态资源，可为空）
  }
  

• 设计意图与最佳实践：析构函数不能手动调用（除非极特殊情况），它在对象离开作用域时自动触发。凡是构造器里 new 过的，析构函数里必须对应 delete（这引出了后面的”三/五法则”与 RAII 思想）。

8. 类型别名（Type Aliasing）

• 定义与目的：为类型起一个同义标识符，提高可读性、便于统一修改。
• 核心语法（C++11 起用 using，等价于 C++98 的 typedef）：

  using String = std::string;   // 之后 String 就是 std::string
  String name;
  

• 设计意图与最佳实践：在类内部 using String = std::string; 后，整个类可以统一用短名，将来想换成 std::u8string 只改一行。using 比 typedef 更清晰且支持模板别名。

9. 继承（Inheritance）：public / protected / private

• 定义与目的：动态多态（不同对象共用同一接口）与可扩展性（通过子类为基类增加特定属性）。例如 Circle : public Shape、”Player is an Entity”。
• 核心语法：

  class Circle : public Shape { ... };      // is-a 关系
  class B : protected A { ... };            // 接口只对子类可见
  class B : private   A { ... };            // 默认！接口只对本类可见
  

• 设计意图与最佳实践：三种继承方式决定基类成员的访问级别如何”传递”：

  基类成员	class B: public A	class B: protected A	class B: private A（默认）
  public	public	protected	private
  protected	protected	protected	private
  private	不可访问	不可访问	不可访问

  经典判断（课堂 Pop Quiz）：实现 class MyStack : ______ MyVector 时应选 private——因为用户不该用 vector 的 insert 破坏栈的约束，子类也不需要 vector 的接口；而 Player : public Entity 必须是 public，因为”玩家真的是一个实体”，必须完整暴露实体的公共接口。注意：class 的继承默认是 private（class B : A 等价于 class B : private A），这是最常见的错误之一。

10. 虚函数、纯虚函数与 vtable

• 定义与目的：virtual 开启动态分派——通过基类指针/引用调用时，实际执行的是对象真实类型（运行时类型）的版本。virtual 的机制是给对象附加一个vpointer，指向一张vtable（虚函数表），表里记录了每个虚函数该调用哪个实现。
• 核心语法：

  class Shape {
  public:
      virtual double area() const = 0;   // 纯虚函数：无默认实现
  };
  class Circle : public Shape {
  public:
      double area() const override { return 3.14 * _radius * _radius; }
  };
  

• 设计意图与最佳实践：纯虚函数（= 0）在基类”声明但不在基类实现”，强制子类必须覆盖；含纯虚函数的类是抽象类，不能实例化。override 关键字让编译器帮你检查”是否真的覆盖了基类的虚函数”，防止拼写错误静默地创建新函数。多态基类还应把析构函数声明为 virtual（见陷阱部分）。

11. 菱形继承（Diamond Problem）与虚继承

• 定义与目的：当 B、C 都继承 A，而 D 同时继承 B 和 C 时，D 会得到两份 A 的子对象（D 里有两个 hello()），obj.hello() 产生歧义——这就是菱形问题。
• 核心语法：

  class B : virtual public A { ... };   // 虚继承：共享一份 A
  class C : virtual public A { ... };
  class D : public B, public C { ... }; // D 中只有一份 A
  

• 设计意图与最佳实践：虚继承让 B、C 共享同一份 A 子对象，D obj; obj.hello(); 不再歧义。幻灯片给的定义：”Virtual — existing in essence, but not literally”——virtual 意味着创建 vtable、意味着把静态类型判断推迟到运行时。菱形继承在实际工程中应尽量避免（接口设计复杂、布局开销大），但理解它能帮助理解多重继承的本质。

代码示例与逐步解说（核心）

示例 1：为什么需要 class——struct 的无力（C++11）

代码：

// C++11
#include <iostream>
#include <string>

struct StanfordID {
    std::string name;
    std::string sunet;
    int idNumber;   // 所有字段默认 public
};

int main() {
    StanfordID s;
    s.name = "Preston Seay";
    s.sunet = "pseay";
    s.idNumber = 12345;
    s.idNumber = -12345;  // 💀 用户可以直接破坏数据
    std::cout << s.name << " " << s.idNumber << "\n";
}

代码做什么：构造一个 StanfordID 结构体并逐字段赋值，然后演示用户可以随意把 idNumber 改成负数——结构体对数据毫无保护。

特性机制解说：struct 的成员默认是 public，编译器对成员访问不做任何检查，s.idNumber = -12345; 与 s.name = ... 完全等价。这正是”没有访问控制”的体现：数据与操作它的规则没有绑定在一起，任何代码都能绕过约束。类的引入就是为了把 idNumber >= 0 这类”规则”与数据本身封装起来。

示例 2：完整的 StanfordID 类——封装、构造器重载、this、getter/setter、析构（C++11）

代码：

// C++11
#include <iostream>
#include <string>

class StanfordID {
private:
    std::string name;
    std::string sunet;
    int idNumber;

public:
    // 默认构造器（重载之一）
    StanfordID()
        : name{"John Appleseed"}, sunet{"jappleseed"}, idNumber{1} {}

    // 带参构造器（成员初始化列表 + 参数校验）
    StanfordID(std::string name, std::string sunet, int idNumber)
        : name{name}, sunet{sunet}, idNumber{idNumber} {
        if (idNumber < 0) this->idNumber = 0;   // this-> 区分参数与成员
    }

    // getter
    std::string getName() const { return name; }
    std::string getSunet() const { return sunet; }
    int getID() const { return idNumber; }

    // setter（带校验）
    void setID(int idNumber) {
        if (idNumber >= 0) this->idNumber = idNumber;
    }

    // 析构函数：本类没有 new 资源，可为空
    ~StanfordID() {}
};

int main() {
    StanfordID defaultStudent;                  // 调用默认构造器
    StanfordID s{"Preston Seay", "pseay", 12345}; // 调用带参构造器
    s.setID(-1);        // 被拒绝：负数无效
    s.setID(999);       // 生效
    std::cout << s.getName() << " " << s.getSunet()
              << " " << s.getID() << "\n";
    std::cout << defaultStudent.getName() << "\n";
    // 输出: Preston Seay pseay 999
    //       John Appleseed
}

代码做什么：先构造默认学生与带参学生；setID(-1) 被校验逻辑拒绝，setID(999) 生效；最后打印两人信息。对象 defaultStudent 与 s 在 main 结束离开作用域时自动调用析构函数。

特性机制解说：

• 构造器重载：StanfordID defaultStudent; 与 StanfordID s{...}; 实参个数不同，编译器在重载决议（overload resolution）中选出对应版本。
• 成员初始化列表：name{name} 中，花括号左侧是成员、右侧是参数。成员在进入函数体之前就已初始化（直接构造，而非先默认构造再赋值），这正是它优于 name = name; 的原因。
• this 指针：this->idNumber = idNumber; 中 this 是 StanfordID*，指向”正在被调用的那个对象”。s.setID(999) 时 this 指向 s，于是改写的是 s 的成员。成员函数调用其实等价于 setID(&s, 999)——this 是隐藏的第一个参数。
• 析构函数：~StanfordID() {} 没有显式调用点，main 结束时两个对象自动析构。

示例 3：Shape 抽象基类与多态——纯虚函数、override、动态分派（C++11）

代码：

// C++11
#include <iostream>

class Shape {
public:
    virtual double area() const = 0;  // 纯虚函数：抽象类
    virtual ~Shape() = default;       // 多态基类必须虚析构
};

class Circle : public Shape {
private:
    double _radius;
public:
    explicit Circle(double radius) : _radius{radius} {}
    double area() const override { return 3.14 * _radius * _radius; }
};

class Rectangle : public Shape {
private:
    double _width, _height;
public:
    Rectangle(double w, double h) : _width{w}, _height{h} {}
    double area() const override { return _width * _height; }
};

int main() {
    Circle c{2.0};
    Rectangle r{3.0, 4.0};
    const Shape* shapes[] = {&c, &r};   // 基类指针数组
    for (const Shape* s : shapes) {
        std::cout << s->area() << "\n"; // 输出 12.56 与 12
    }
    // Shape s;  // ❌ 抽象类不能实例化
}

代码做什么：定义抽象基类 Shape（纯虚 area()），Circle 与 Rectangle 继承并覆盖 area()；main 用基类指针数组统一调用，每次调用都会执行真实类型的 area。

特性机制解说：

• 纯虚函数：= 0 告诉编译器”基类只声明接口，不提供实现”，同时使 Shape 成为抽象类，Shape s; 无法编译。
• 动态分派：s->area() 的静态类型是 const Shape*，但运行时通过对象的 vpointer → vtable 查到应该调 Circle::area() 还是 Rectangle::area()。virtual 关键字给 Shape 的对象悄悄附加了一个 vtable 指针，这使对象内存变大、调用多一次间接跳转——这是 C++ 中虚函数不是默认开启的原因（”opt in”）。
• override：double area() const override 若与基类签名不匹配（比如漏写 const），编译器直接报错而不是静默新建函数。

示例 4：菱形继承与虚继承的修复（C++11）

代码：

// C++11
#include <iostream>

class A {
public:
    void hello() const { std::cout << "hello from A\n"; }
};

class B : virtual public A {};   // 虚继承
class C : virtual public A {};   // 虚继承

class D : public B, public C {}; // D 只共享一份 A

int main() {
    D obj;
    obj.hello();   // ✅ 不再歧义
    obj.B::hello();// 仍可显式选择路径
    obj.C::hello();
}

代码做什么：B、C 通过 virtual public A 继承 A，D 同时继承 B 与 C，最终 D 里只有一份 A 子对象，obj.hello() 直接可用。

特性机制解说：如果不加 virtual，D 会包含两份 A 子对象（一份经 B、一份经 C），obj.hello() 就歧义到必须写 obj.B::hello()。虚继承让 B、C 共享同一个 A 子对象——编译器会把共享基类子对象放到派生对象末尾，并通过偏移量访问，实现”一份拷贝”。代价是对象布局更复杂、访问稍慢，所以只在确实需要时才用虚继承。

与旧标准（如 C++98）的对比

关键要点

• class 默认 private，struct 默认 public；封装是类的灵魂——数据私有、接口公开、规则收进 setter。
• 构造函数用成员初始化列表（花括号）初始化成员，比在函数体内赋值更高效、更安全，还能做参数校验。
• this 是隐藏的”当前对象指针”；参数与成员同名时必须 this->member = param;。
• class B : A 默认是 private 继承；表达 is-a 关系必须显式 class B : public A，否则基类公共接口对外不可见。
• 多态基类要写 virtual 析构函数，纯虚函数（= 0）制造抽象类；菱形继承用 virtual public 虚继承修复歧义。