万物基于C语言：丹尼斯·里奇与C语言帝国的兴起与永恒

1
2
3
4

每个B程序运行：
  → 需要先启动B解释器（占大量内存）
  → 解释器再逐行翻译程序（速度慢）
  → 浪费了PDP-11本就不多的内存和算力

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

B语言的致命缺陷：
  ✗ 只有一种数据类型（字）
  ✗ 解释型执行，速度慢
  ✗ 没有结构体，复杂数据难组织

C语言的关键创新：
  ✓ 引入基本数据类型（char、int、float等）
  ✓ 编译型语言，生成直接可执行的机器码
  ✓ 引入结构体（struct），可以自定义复杂数据类型
  ✓ 指针（pointer），直接操作内存地址
  ✓ 预处理宏（#define）

1
2
3
4
5
6
7
8

传统操作系统：用汇编写（完全不可移植）
    → 换一台机器，代码全部重写
    → 只有极少数人能维护和修改

UNIX + C：用C语言写（可移植）
    → 换一台机器，只需要重写硬件相关的1000行代码（硬件抽象层）
    → 其余99%的代码直接复用
    → 大幅降低了操作系统移植和演进的成本

1
2
3
4
5
6
7
8
9

UNIX需要C语言：
  → C语言足够低级，可以直接操作硬件（系统调用）
  → C语言足够高级，代码比汇编更易读、更易维护
  → C语言编译出的程序运行效率极高，接近汇编

C语言需要UNIX：
  → UNIX是C语言的第一个大型"试验场"
  → UNIX证明了C语言可以写出真实的生产级操作系统
  → UNIX的普及带动了C语言的传播

1
2
3
4
5

// C语言：不保护数组越界
int arr[5] = {1, 2, 3, 4, 5};
printf("%d\n", arr[10000]); // 越界访问，编译器不报错
// 运行结果：不知道是多少（未定义行为）
// 可能：输出一个随机数、崩溃、或者恰好是内存里的另一个变量

1
2
3
4
5

// C语言的强制类型转换：你想怎么转就怎么转
int i = 65;
char *p = (char *)&i;   // 把int指针强转为char指针
printf("%c\n", *p);     // 可能输出 'A'，也可能输出其他字符
// 编译器不会阻止你——它相信你知道你在做什么

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

C语言操作系统家族：

UNIX系列：
  ├── AT&T UNIX（原始版，C语言编写）
  ├── BSD系列
  │     ├── FreeBSD（Netflix等公司用它处理网络流量）
  │     ├── macOS / iOS（Darwin内核）
  │     └── OpenBSD（安全加固）
  └── Solaris（AURORA、甲骨文内部使用）

Linux系列：
  └── Linux内核（2026年：3000万行代码，全部C语言）
       └── Android系统底层（基于Linux内核）
       └── 服务器、嵌入式设备、超级计算机、桌面

Windows：
  └── Windows内核（C语言 + C++混合）
       └── NT内核：进程管理、内存管理、文件系统
       └── Windows API：应用程序接口层

其他：
  └── 嵌入式RTOS（FreeRTOS、VxWorks）
  └── 智能手表OS、路由器OS、交换机OS

1
2
3
4
5
6
7
8

如果把这3000万行代码打印成书：
  → 每页50行，每页约0.5cm厚
  → 共600万页
  → 叠加高度：30公里
  → 从深圳地面叠到大气层边缘

一个人读这些代码（每行1分钟）：
  → 读完需要：3000万分钟 = 57年（不吃不喝不睡）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

C语言的"语言家族"：

                    C（1972）
                      │
    ┌─────────┬───────┼────────┬─────────┐
    ↓         ↓       ↓        ↓         ↓
  C++       Java   Python    Perl    Objective-C
 (1979)   (1995)  (1991)   (1987)    (1984)

 JavaScript   C#     Go     Rust    PHP
   (1995)  (2000) (2009)  (2010)   (1995)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// CPython的Python/ceval.c（简化示例）
case TARGET(BINARY_ADD): {
    PyObject *right = POP();
    PyObject *left = TOP();
    PyObject *sum = PyNumber_Add(left, right);
    Py_DECREF(right);
    Py_DECREF(left);
    if (sum == NULL)
        goto error;
    SET_TOP(sum);
    DISPATCH();
}
// Python的高级语法（a + b），底层是C语言的函数调用
// 内存管理（Py_DECREF/Py_INCREF）、对象系统全部由C实现

1
2
3
4
5
6
7

Java源代码（.java）
    ↓ javac 编译器
Java字节码（.class）
    ↓
JVM（用C++编写，而C++的STL部分用C实现）
    ↓
机器码

1
2
3
4
5
6
7

Go的组成部分：
  ├── 编译器（go tool compile）：Go语言本身写成
  ├── 运行时（runtime）：部分Go写成，部分C写成
  ├── GC（垃圾回收器）：Go写成
  └── 标准库的系统调用层：用C语言调用操作系统
        ↓
      Linux/BSD/Windows的底层系统调用（C语言API）

1
2
3
4

Rust的架构：
  ├── 编译器前端：Rust写成（语法分析、类型检查）
  ├── 编译器后端（LLVM）：C++写成
  └── 标准库：Rust写成（安全抽象）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

数据库的C语言版图：

关系型数据库：
  ├── MySQL（全部C语言写成，C API是其灵魂）
  ├── PostgreSQL（C语言写成，部分C++）
  ├── SQLite（全部C语言，约15万行代码）
  │     → 世界上最广泛部署的数据库引擎
  │     → 每个iPhone/Android手机里都有它
  │     → 浏览器内置的本地存储
  └── Oracle Database（C语言 + 汇编混合）

NoSQL数据库：
  ├── Redis（C语言写成，高性能内存数据库）
  ├── MongoDB（C++语言写成，但底层存储引擎 WiredTiger 用C）
  ├── Cassandra（C++ + Java，存储层有C）
  └── LevelDB（Google的C++实现，被多款区块链采用）

数据库中间件：
  └── ClickHouse（俄罗斯第一大电商Yandex出品，C++写成）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

嵌入式C语言应用：

汽车电子：
  ├── 发动机控制单元（ECU）
  ├── 防抱死制动系统（ABS）
  ├── 安全气囊控制
  ├── 车载信息娱乐系统（部分）
  │     → 实时操作系统：QNX（全部C）、FreeRTOS（C）
  │     → CAN总线协议栈（C语言实现）

消费电子：
  ├── 智能手表固件（RTOS，C语言）
  ├── 数码相机固件（C + 汇编）
  ├── 路由器/交换机固件（C语言）
  │     → OpenWrt：Linux内核 + C语言应用层
  │     → Cisco IOS：纯C语言

工业控制：
  ├── PLC（可编程逻辑控制器）
  ├── 工业机器人控制
  ├── 电力系统SCADA

微控制器（MCU）：
  ├── STM32系列（ARM Cortex-M）
  ├── ESP32（Wi-Fi + 蓝牙物联网芯片）
  └── Arduino（AVR单片机）
        → 全部用C语言编程（部分支持汇编）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

为什么不用Python？因为Python太慢了（解释执行）
为什么不用Java？因为Java需要JVM，JVM太重（至少几MB内存）
为什么不用Go？因为Go的运行时（runtime）太大（几MB）

嵌入式系统的资源：
  → 微控制器：2KB RAM，32KB Flash
  → 智能传感器：1KB RAM，16KB ROM
  → 实时系统：确定性延迟要求，微秒级响应

C语言的优势：
  → 直接操作硬件寄存器
  → 零运行时开销（No Runtime）
  → 生成的机器码极其精简（几十字节就能跑）
  → 编译后的二进制文件可以小到几KB

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

主流运行时技术栈：

Python → CPython（纯C实现）
Ruby   → CRuby/MRI（纯C实现）
PHP    → Zend Engine（C语言实现）
Perl   → Perl解释器（C语言实现）
Lua    → Lua解释器（纯C实现，极其轻量，游戏开发最爱）
Ruby   → JRuby → JVM → 底层仍是C

对比：完全不需要C的语言
  → 纯解释型（无编译无虚拟机）：Shell脚本
  → 自举（自己写自己）：Go、Rust（可以不用C编译）
  → WebAssembly：可以不依赖C，直接编译到Wasm

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

C语言编译工具链（以GCC为例）：

源代码（C/C++语言）
    ↓
  GCC前端（预处理、语法分析、语义分析）
    ↓
  中间表示（IR，GIMPLE）
    ↓
  GCC后端（目标代码生成）
    ↓
  汇编（as）
    ↓
  目标文件（.o，机器码）
    ↓
  链接器（ld，链接库文件）
    ↓
  可执行文件（机器码）

整个GCC工具链本身，也是用C语言写成的。
这意味着：你用C语言写的C语言编译器，可以编译它自己。
这叫"自举"（Bootstrap）。

1
2

int *p = NULL;     // 显式声明一个整型指针，初始化为空
*p = 42;           // 显式解引用，写入内存

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

C语言家族简谱：

1972 — C语言（丹尼斯·里奇，贝尔实验室）
  │
  ├─→ 1979 — C with Classes → C++（Bjarne Stroustrup）
  │              │
  │              ├─→ 游戏引擎（Unreal Engine 5）
  │              ├─→ 操作系统（Windows核心）
  │              ├─→ 数据库（MySQL client API）
  │              └─→ Web浏览器（Chrome、Firefox）
  │
  ├─→ 1983 — Objective-C（Brad Cox）
  │              │
  │              └─→ macOS / iOS 应用开发
  │
  ├─→ 1995 — Java（James Gosling）
  │              │        （受C++影响，语法相似）
  │              └─→ 企业级应用、Android开发
  │
  ├─→ 1995 — JavaScript（Brendan Eich）
  │              │        （语法受C/Java影响）
  │              └─→ Web前端、后端（Node.js）
  │
  ├─→ 2000 — C#（Anders Hejlsberg）
  │              │        （C/C++/Java语法影响）
  │              └─→ Windows应用、游戏（Unity）
  │
  ├─→ 2009 — Go（Google，肯·汤普森参与创建）
  │              └─→ 云原生、微服务、容器（Docker/Kubernetes）
  │
  └─→ 2010 — Rust（Mozilla Graydon Hoare）
                 └─→ 追求内存安全的新一代系统语言

1
2
3

int arr[10];
arr[1000000] = 42; // 不报错，直接写入未知内存区域
// 这是无数安全漏洞的根源（缓冲区溢出）

1
2
3
4

// 这个表达式你能直接看出结果吗？
if (flags & FLAG != 0) { ... }
// 实际上：flags & (FLAG != 0)，而不是(flags & FLAG) != 0
// C语言的优先级规则非常反直觉，且历史上留下了一些错误

1
2
3
4

#define SQUARE(x) x * x
int a = 5;
int b = SQUARE(a + 1); // 结果是 5 + 1 * 5 + 1 = 11，不是36！
// 应该用内联函数替代宏，但C89时代没有内联函数

1
2
3
4
5
6

// C语言字符串：手动管理内存，容易出错
char *s1 = "hello";
char *s2 = malloc(6);
strcpy(s2, s1);     // 如果忘记malloc就会崩溃
free(s2);           // 如果忘记free就内存泄漏
// 里奇说："如果能重来，字符串处理会是我第一个重做的部分"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

早上8:00 — 醒来
  ├── 手机的基带处理器 → 运行C语言的固件
  ├── Android系统底层 → Linux内核（C语言）
  └── 闹钟App → Java/Kotlin → JVM → 最终调用的系统服务由C写成

早上8:30 — 开车上班
  ├── ABS防抱死系统 → C语言的ECU固件
  ├── 车载导航 → 嵌入式Linux（C语言）
  ├── 胎压监测 → C语言的传感器固件
  └── 汽车CAN总线 → C语言的车载网络协议栈

上午9:00 — 打开电脑工作
  ├── macOS/Windows启动 → 内核由C语言写成
  ├── VS Code编辑器 → Electron框架 → Node.js → V8引擎 → C++
  ├── Git操作 → C语言写成的Git
  └── MySQL数据库查询 → C语言写成的数据库

上午10:00 — 打开浏览器
  ├── Chrome浏览器 → V8引擎（C++）→ C语言基础服务
  ├── HTTP请求 → OpenSSL库（C语言）→ TLS加密
  └── 浏览网页 → 每个网页由浏览器渲染引擎（C++）处理

中午12:00 — 数据库操作
  ├── MySQL查询 → C语言引擎
  ├── Redis缓存 → C语言引擎
  └── 消息队列 → Kafka（Java/Scala）→ 底层仍是C语言/Linux

下午2:00 — 部署服务到云服务器
  ├── Docker容器 → Go语言外壳 → Linux内核（C语言）
  ├── Kubernetes编排 → Go语言 → Linux（C语言）
  └── Nginx反向代理 → C语言写成的HTTP服务器

晚上8:00 — 回家
  ├── 智能电视 → 嵌入式Linux（C语言）
  ├── 游戏机 → 底层固件（C/汇编）
  ├── Wi-Fi路由器 → OpenWrt Linux（C语言）
  └── 你的智能手表 → FreeRTOS（C语言）

这一天，你直接或间接使用了多少行C语言代码？
  → Linux内核：3000万行
  → OpenSSL：50万行
  → Nginx：10万行
  → MySQL：300万行
  → SQLite：15万行
  → ……加上其他所有固件、驱动、协议栈
  → 总计：可能超过1亿行