C 与 C++ 根基专题：保持锋利 + 为 OS 梦打底

与 08 总纲 §2 完全一致：C/C++ 是根基，不是交付主线。先把边界划清楚，免得它反向吞掉你宝贵的主线时间。

1.1 什么时候必须用 C/C++

1.2 什么时候坚决不用

• 商业交付主线不用：工作台、后端服务、数据库专题一律 Go（见 10/11 模块）。C/C++ 内存管理成本高、编译慢、招人贵，拿来写业务系统是用错工具。
• 不追新特性：本模块只要求 C++17 写得顺、看得懂 C++20；不碰模板元编程炫技、不做大型 C++ 工程重构。

1.3 与 Go 的互补关系（记住这张表）

一句话定位：Go 让你把东西卖出去、跑起来；C/C++ 让你知道机器底层发生了什么。后者每周只花 1 小时，但它决定你四阶段之后能不能再往上走一层。

安装本体只在 09 模块讲（§1.7），这里只做"装好之后怎么起一个最小工程"。版本纪律：照抄下表，不要自己选版本。

2.1 你需要装的东西（与 09 一致）

2.2 最小 CMake 工程（三个文件，完整可跑）

新建目录 cpp-root/，里面放三个文件：

CMakeLists.txt

cmake_minimum_required(VERSION 3.20)
project(root_demo C CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# 常用开关：把警告打开，错误尽量早暴露
if(MSVC)
    add_compile_options(/W4 /permissive-)
else()
    add_compile_options(-Wall -Wextra)
endif()

add_executable(root_demo main.cpp)

main.cpp

// main.cpp —— 验证工具链是否通：打印一句 + 算个斐波那契
#include <cstdio>

int fib(int n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
}

int main() {
    std::printf("toolchain ok: fib(10) = %d\n", fib(10));
    return 0;
}

构建与运行命令（PowerShell，在 cpp-root/ 目录里执行）

cmake -S . -B build
cmake --build build --config Release
.\build\Release\root_demo.exe

看到输出 toolchain ok: fib(10) = 55 即工具链通了。之后本模块所有练习都往这个工程里加新 .cpp / .c 文件、在 CMakeLists.txt 里加一行 add_executable(...) 即可。

不教指针是什么。下面每个小节只给"一句话本质 + 一个完整练习"。五个练习全是阶段四读 Go runtime 时天天见面的东西：链表、内存池、字符串、位操作、环形缓冲。

3.1 指针与数组的本质

本质一句话：数组名是"首元素地址"的语法糖，指针是"一个保存地址的变量"。arr[i] 编译后永远是 *(arr + i)——偏移量按元素大小缩放。你当年写 Delphi/Qt 的手感在这里，提醒自己别在边界上偷懒。

3.2 结构体与内存布局

本质一句话：struct 成员按声明顺序连续排列，编译器可能插入填充字节对齐。这直接决定 sizeof、决定缓存行利用率、决定你后面 §5 的一切。

3.3 内存管理：malloc/free、栈与堆

本质一句话：局部变量在栈上（函数返回即失效），malloc 在堆上（你必须 free）。返回局部变量地址是 C 里最经典的自毁。

3.4 函数指针与回调

本质一句话：函数名 decays 成函数指针；回调 = 把"要做什么"当参数传进去。你写 Qt 信号槽、Go 里传函数值，底层都是这个。

3.5 五个练习（每个都是完整可编译文件）

练习 ① 链表（插入/遍历/销毁）

// list.c —— 单向链表：尾插、遍历、整体销毁
#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int value;
    struct Node* next;
} Node;

Node* list_push(Node* head, int v) {
    Node* n = (Node*)malloc(sizeof(Node));
    n->value = v;
    n->next = NULL;
    if (head == NULL) return n;
    Node* cur = head;
    while (cur->next) cur = cur->next;
    cur->next = n;
    return head;
}

void list_print(const Node* head) {
    for (const Node* p = head; p; p = p->next)
        printf("%d -> ", p->value);
    printf("NULL\n");
}

void list_free(Node* head) {
    while (head) {
        Node* next = head->next;
        free(head);
        head = next;
    }
}

int main(void) {
    Node* head = NULL;
    for (int i = 1; i <= 5; ++i) head = list_push(head, i * 10);
    list_print(head);      /* 10 -> 20 -> 30 -> 40 -> 50 -> NULL */
    list_free(head);
    return 0;
}

练习 ② 内存池（定长块，替代频繁 malloc/free）

// pool.c —— 固定大小内存块池：预先分配一大块，用空闲链表串起来
#include <stdio.h>
#include <stdlib>

#define BLOCK_SIZE  64
#define POOL_BLOCKS 16

typedef struct FreeNode {
    struct FreeNode* next;
} FreeNode;

typedef struct Pool {
    char storage[POOL_BLOCKS * BLOCK_SIZE];
    FreeNode* free_list;
} Pool;

void pool_init(Pool* p) {
    p->free_list = NULL;
    for (int i = POOL_BLOCKS - 1; i >= 0; --i) {
        FreeNode* n = (FreeNode*)(p->storage + i * BLOCK_SIZE);
        n->next = p->free_list;
        p->free_list = n;
    }
}

void* pool_alloc(Pool* p) {
    if (p->free_list == NULL) return NULL;
    FreeNode* n = p->free_list;
    p->free_list = n->next;
    return (void*)n;
}

void pool_free(Pool* p, void* block) {
    FreeNode* n = (FreeNode*)block;
    n->next = p->free_list;
    p->free_list = n;
}

int main(void) {
    Pool p;
    pool_init(&p);
    void* a = pool_alloc(&p);
    void* b = pool_alloc(&p);
    printf("a=%p b=%p\n", a, b);
    pool_free(&p, a);
    pool_free(&p, b);
    printf("pool ok\n");
    return 0;
}

练习 ③ 字符串处理（不依赖库的 strcpy/strlen 手写字）

// str.c —— 手写 strlen / strcpy / 统计单词数
#include <stdio.h>

size_t my_strlen(const char* s) {
    const char* p = s;
    while (*p) ++p;
    return (size_t)(p - s);
}

char* my_strcpy(char* dst, const char* src) {
    char* head = dst;
    while ((*dst++ = *src++)) ;   /* 连 '\0' 一起拷 */
    return head;
}

int count_words(const char* s) {
    int n = 0, in = 0;
    for (; *s; ++s) {
        if (*s == ' ' || *s == '\t' || *s == '\n') {
            in = 0;
        } else if (!in) {
            in = 1;
            ++n;
        }
    }
    return n;
}

int main(void) {
    char buf[64];
    my_strcpy(buf, "hello rooted c");
    printf("len=%zu words=%d buf=%s\n",
           my_strlen(buf), count_words(buf), buf);
    return 0;   /* len=14 words=3 */
}

练习 ④ 位操作（标志位与位域）

// bits.c —— 置位/清位/取位；位操作是驱动与协议层的家常便饭
#include <stdio.h>

#define FLAG_READ   (1u << 0)
#define FLAG_WRITE  (1u << 1)
#define FLAG_EXEC   (1u << 2)
#define FLAG_ADMIN  (1u << 3)

static void set(unsigned* flags, unsigned f)  { *flags |= f; }
static void clear(unsigned* flags, unsigned f){ *flags &= ~f; }
static int  has(unsigned flags, unsigned f)   { return (flags & f) != 0; }

int main(void) {
    unsigned flags = 0;
    set(&flags, FLAG_READ | FLAG_WRITE);
    set(&flags, FLAG_ADMIN);
    printf("read=%d exec=%d admin=%d\n",
           has(flags, FLAG_READ),
           has(flags, FLAG_EXEC),
           has(flags, FLAG_ADMIN));   /* 1 0 1 */
    clear(&flags, FLAG_ADMIN);
    printf("after clear admin=%d\n", has(flags, FLAG_ADMIN)); /* 0 */
    return 0;
}

练习 ⑤ 环形缓冲（单读单写，无锁思路）

// ring.c —— 定长环形缓冲：这就是 Go channel 底层的兄弟结构
#include <stdio.h>

#define CAP 8

typedef struct {
    char buf[CAP];
    int head;   /* 读位置 */
    int tail;   /* 写位置 */
    int count;  /* 当前元素数 */
} Ring;

int ring_push(Ring* r, char c) {
    if (r->count == CAP) return -1;      /* 满 */
    r->buf[r->tail] = c;
    r->tail = (r->tail + 1) % CAP;
    ++r->count;
    return 0;
}

int ring_pop(Ring* r, char* out) {
    if (r->count == 0) return -1;        /* 空 */
    *out = r->buf[r->head];
    r->head = (r->head + 1) % CAP;
    --r->count;
    return 0;
}

int main(void) {
    Ring r = {0};
    for (char c = 'a'; c < 'a' + 5; ++c) ring_push(&r, c);
    char out;
    while (ring_pop(&r, &out) == 0) putchar(out);
    putchar('\n');   /* abcde */
    return 0;
}

五个练习的共同用途：它们就是你在阶段四读 Go runtime 时会反复遇到的原语。链表=调度器运行队列；内存池=mcache/mheap；环形缓冲=channel；位操作=goroutine 状态标志。现在手写一遍，将来读源码就是"老朋友见面"。

你是 C++98 时代过来的。这十几年标准加了很多东西，下面只挑"你现在写现代代码绕不开"的，配一个完整示例。

4.1 必须知道的七件事

C++20 的模块（module）与概念（concepts）知道有这回事即可：模块替代 #include 加速编译，concepts 给模板参数加约束。本模块不展开，你写 C++17 就够打根基。

4.2 与"C++98 时代"差异速览表

4.3 一个完整现代 C++ 示例（把上面特性串起来）

// modern.cpp —— RAII + unique_ptr + lambda + STL + constexpr
#include <memory>
#include <vector>
#include <algorithm>
#include <iostream>

constexpr int kMaxItems = 8;   // 编译期常量

int main() {
    // 1) unique_ptr 独占数组，离开作用域自动 delete[]
    auto buf = std::make_unique<int[]>(kMaxItems);
    for (int i = 0; i < kMaxItems; ++i) buf[i] = (i * i) % 7;

    // 2) vector + lambda + STL 算法
    std::vector<int> v(buf.get(), buf.get() + kMaxItems);
    std::sort(v.begin(), v.end(), [](int a, int b) { return a > b; });

    // 3) 范围 for 打印
    for (int x : v) std::cout << x << ' ';
    std::cout << '\n';

    // buf 在这里自动释放，无需 delete[]
    return 0;
}

选型纪律：默认 unique_ptr；只有共享所有权绕不开时才用 shared_ptr。滥用 shared_ptr 会引入循环引用与难以追踪的生命周期——这是现代 C++ 最常见的过度设计。

这一节是全模块的"理论核心"。Go 把 GC 和虚拟内存替你藏起来了，但阶段四你要读 runtime、要写 toy kernel，这层必须自己看得见。

5.1 最小必要理论（四条）

• 虚拟内存：每个进程以为自己独占整个地址空间；操作系统用页表把虚拟地址映射到物理内存。你后面 QEMU 第 5 站就是亲手建页表。
• 地址空间分区：代码段（text）放指令；数据段（data/bss）放全局与静态变量；堆（heap）向上增长给 malloc；栈（stack）向下增长放函数局部变量与返回地址。
• 栈 vs 堆：栈分配/释放只是移动栈指针，极快但大小有限、函数返回即失效；堆灵活但要你自己管、有碎片。
• 缓存与局部性、对齐：CPU 按缓存行（通常 64 字节）搬数据；连续访问比随机访问快一个数量级。结构体成员按对齐填充，把"高频访问的成员"放一起能显著提速。

5.2 演示程序：亲手打印你的内存布局

// layout.cpp —— 打印代码/全局/堆/栈四类地址，建立"地址空间直觉"
#include <cstdio>
#include <cstdlib>

int g_global = 42;            // 数据段
static int g_static = 7;      // 数据段（本文件可见）

void some_function() {        // 代码段
    int local = 1;            // 栈
    std::printf("  函数 some_function 地址 : %p\n", (void*)&some_function);
    std::printf("  栈上局部变量 local 地址 : %p\n", (void*)&local);
}

int main() {
    int* heap = (int*)malloc(sizeof(int) * 4);   // 堆

    std::printf("代码段  &main            : %p\n", (void*)&main);
    std::printf("数据段  g_global        : %p\n", (void*)&g_global);
    std::printf("数据段  g_static        : %p\n", (void*)&g_static);
    std::printf("堆     heap[0]         : %p\n", (void*)&heap[0]);
    some_function();

    free(heap);
    return 0;
}

跑一遍你会看到：代码段地址最低，数据段在其后，堆在中间向上长，栈地址最高（向低地址方向）。把这张图记住——后面 Go runtime 的 mheap/goroutine 栈、QEMU 里的页表，全是在这个图上做文章。

这是 07 报告"操作系统梦在 QEMU 里继续"的执行版，与 08 阶段四"Go runtime 源码深潜 + QEMU toy kernel"完全一致。每周时间盒推一站，不求快，求每站亲手跑通。参考资源只写书名，照读即可，不用跳出教程去找。

6.1 第 1 站完整代码（引导扇区打印，照做即通）

准备两样东西：①装 QEMU（Windows 下装 qemU 模拟器，命令行 qemu-system-x86_64 可用）；②装 NASM 汇编器。然后新建 boot.asm：

; boot.asm —— 第一个引导扇区：QEMU 启动后屏幕上打印一行字
org 0x7c00            ; BIOS 把本扇区加载到物理地址 0x7C00
bits 16               ; 开机默认 16 位实模式

start:
    mov si, msg       ; DS:SI 指向字符串
.print:
    lodsb             ; 取一个字符到 AL，SI++
    or al, al         ; 碰到字符串结束符 0？
    jz .halt          ; 是 → 停住
    mov ah, 0x0e      ; BIOS teletype 功能号
    mov bh, 0         ; 页码
    int 0x10          ; 调用 BIOS 视频中断打印 AL
    jmp .print
.halt:
    hlt               ; 停机，等中断
    jmp .halt

msg db "Hello, toy kernel!", 0

times 510 - ($ - $$) db 0   ; 填零到第 510 字节
dw 0xaa55                   ; 最后两字节是引导魔数

构建与运行（PowerShell，在 boot.asm 所在目录）：

nasm -f bin boot.asm -o boot.bin
qemu-system-x86_64 boot.bin

QEMU 窗口弹出、屏幕上出现 Hello, toy kernel! 即为第 1 站通过。看到的原理：BIOS 读磁盘第一个扇区到 0x7C00，校验最后两字节是 0xAA55 后跳转执行——你刚写的 512 字节就是"操作系统的第一步"。

与 08 的一致性：08 §2 阶段四（第 4 月起持续）明确写"15 C/C++ 根基专题配合 QEMU toy kernel（osdev 路线）每周时间盒推进"；本节六站就是该条目的展开。QEMU 里跑 toy kernel 是梦想基金，不是交付压力——卡住一周就停在那一周，不影响主线。

与 08 §3 周末盘一致：周六下午的"C/C++/QEMU 时间盒"。1 小时硬上限，到点就停，绝不延期到主线时间。

7.1 标准模板（30 分钟理论 + 30 分钟动手）

7.2 全年节奏建议（12 个月，每周 1h ≈ 50h）

• 第 1–2 月：§2 工具链 + §3 五个练习各走一遍，手感焊住。
• 第 3–4 月：§4 现代 C++ 要点 + §5 内存模型，配合阶段一读 Go 内存模型。
• 第 5 月起：进入 §6 QEMU 六站，每月推进约 1 站，一年走完前 4–5 站（第 5、6 站更深，按节奏来）。

至少覆盖你在本模块会真实踩到的坑。按"报错原文 / 原因 / 解决"三列对照。

复制到日程本，三项全部打勾才算本模块闭环。它不要求你成为 C++ 专家，只要求"手感在、工具链通、OS 梦迈出第一步"。

验收不过怎么办：回到 §8 报错表对照；还不行就把报错原文 + 复现步骤喂给 AI（按 08 §6 双会话评审流程），不要在一个问题上消耗主线时间——本模块每周只有 1 小时，卡住就记录、下周再来。

本模块所有版本号均来自全系列唯一事实来源 versions.md（见 09 模块 §4 总表）。这里列出与 C/C++ 直接相关的条目。

来源表

（编者整理：本模块的五个 C 练习、现代 C++ 示例、内存布局演示、QEMU 六站路线与每周时间盒模板为基于 07/08 结论的执行化设计，无外部独立来源。）