Stefansky

CSAPP 第三章程序的机器级表示

2026-05-20T01:29:10.000Z

# CSAPP 第三章程序的机器级表示

编译器基于编程语言的规则、操作系统的惯例、目标机器的指令集生成机器代码。

汇编代码是机器代码的一种形式，它是机器代码的文本表示。

高级代码可移植性好，而汇编代码与特定机器密切相关。

能够阅读汇编代码：

好处：可以理解编译器的优化能力，并分析代码中隐含的低效率

条件：了解编译器将高级语言转换为机器代码的转换方式。

精通细节很重要，是理解更深和更基本概念的先决条件。要认真研究示例、完成练习。

32位机器可以使用约 4GB 的随机访问存储器，64位机器可以使用 256TB(2^48) 的内存空间(这里说的是主存)。

# 3.2 程序编码

汇编器产生的目标代码是机器代码的一种形式，它包含二进制形式表示的所有指令，但还没有填入全局值的地址。

# 3.2.1 机器级代码

影响机器级程序的两种抽象：

指令集架构：定义了处理器状态、指令的格式、指令对状态的影响。

虚拟地址：机器代码将内存看成一个按字节寻址的数组。

对机器代码可见的处理器状态：

程序计数器

整数寄存器文件：保存临时数据或重要的程序状态

条件码寄存器：保存最近执行的算术或逻辑指令的状态信息。

一组向量寄存器：保存一个或多个整数或浮点数值

C 语言中的数组和结构，在机器代码中用一组连续的字节来表示。

汇编代码不区分有符号数和无符号数，不区分指针的不同类型，不区分指针和整数。

一条机器指令只执行一个非常基本的操作。

# 3.2.2 代码示例

反汇编

使用反汇编器可以根据机器代码产生汇编代码。如：48 89 d3 → mov %rdx,%rbx

机器代码与反汇编表示的特性：

x86-64 的指令长度范围为 1~15 字节。常用指令和操作数少的指令所需字节少。

从十六进制字节值到汇编指令，格式为：某个数字唯一地对应某个汇编指令，比如 mov 指令以 48 开头。

指令结尾的 'q' 是大小指示符，大多数情况下可以省略。

从源程序转换来的可执行目标文件中，除了程序过程的代码，还包含启动和终止程序的代码，与操作系统交互的代码。

链接器的任务之一就是为函数调用找到匹配的函数的可执行代码的位置。

# 3.2.3 关于格式的注解

在汇编代码中，以 ‘.’ (点) 开头的行是指导汇编器和链接器工作的伪指令。

# 3.3 数据格式

字节：byte，8位；字：word，16位；双字：double words，32位；四字：quad words，64位。

对应的指令后缀：movb, movw, movl, movq。

这里说的都是整数，浮点数使用一组完全不同的指令和寄存器。

# 3.4 访问信息

一个 64 位 CPU 中包含一组 16 个存储 64 位值的通用目的寄存器，用来存储整数和指针。

16 个寄存器标号为 rax**<sub>rbp，r8</sub>r15**

16 个寄存器的低位部分都可以作为字节、字、双字、四字来单独访问。分别表示为 al, ax, eax, rax。

低位操作的规则：

将寄存器作为目标位置时，生成字节和字的指令会保持剩下的字节不变

生成双字的指令会把高位四字节置为 0.

16个寄存器的作用

rax：返回值

rsp：栈指针

rdi, rsi, rdx, rcx, r8, r9：第 1 到第 6 个参数

rbx, rbp, r12~r15：被调用者保存

r10, r11：调用者保存

# 3.4.1 操作数指示符

指令的操作数有三种类型：立即数，寄存器，内存引用

最常用的寻址方式：Imm(rb, ri, s)：Imm + rb + ri*s

s 为比例因子，只能是 1，2，4，8 中的某一个

# 3.4.2 数据传送指令

mov类

mov 只会更新目的操作数指定的寄存器字节或内存位置。

mov 类是最简单的数据传送指令，mov 类有 5 种：

movb, movw, movl：传送字节、字、双字

movq：传送四字。如果源操作数是立即数，只能是双字，然后符号扩展到四字（假的四字）

movabsq：传送绝对的四字。只能以立即数作为源操作数，以寄存器为目的。可以传送任意 64 位立即数。

movq 用来传送寄存器和内存引用中的四字，movabsq 用来传送四字的立即数

mov 类的源操作数和目的操作数不能同时为内存，即不能将值从内存复制到内存。

mov 指令中寄存器的大小必须与 mov 的后缀字符大小匹配。

movb $-17, %al

movz类

movz 系列和 movs 系列可以把较小的源值复制到较大的目的，目的都是寄存器。

movz 将目的寄存器剩余字节做零扩展，movs 做符号扩展

movz类：movzbw, movzbl, movzbq, movzwl, movzwq（movzbw 即从字节复制到字，其他类似）

movs类：movsbw, movsbl, movsbq, movswl, movswq, movslq, cltq

cltq： 没有操作数，将 eax 符号扩展到 rax，等价于 movslq %eax,%rax

# 3.4.3 数据传送示例

局部变量通常保存在寄存器中。

函数返回指令 ret 返回的值为寄存器 rax 中的值

强制类型转换是通过 mov 指令实现的。

当指针存在寄存器中时，a = *p 的汇编指令为： mov (rdi), rax

# 3.4.4 压入和弹出栈数据

栈向下增长，栈顶的地址是栈中元素地址中最低的。栈指针 rsp 保存栈顶元素的地址。

出入栈指令：

pushq rax：压栈，栈指针减 8 并将 rax 中的值写入新的栈顶地址，等价于：subq $8, (rsp) ; movq rax,(rsp)。

popq rax：出栈，栈指针加 8 并将出栈的值写入 rax 中，等价于：movq (rsp),rax ; add $8,(rasp)

使用 mov 指令和标准的内存寻址方法可以访问栈内的任意位置，而非仅限于栈顶。

# 3.5 算术和逻辑操作

x86-64 的每个指令类都有对应四种不同大小数据的指令

算术和逻辑操作共有四组：

加载有效地址

leaq S, D：将 S 的地址保存到 D 中，D 必须是寄存器

一元操作

inc D: D+1

dec D: D-1

neg D：取负

not D：取补

二元操作（加减乘，与或异或，没有除法）

add s, d: d=d+s

sub s, d: d=d-s

imul s, d: d=d*s 乘

xor s, d: d=d^s 异或

or s, d: d=d|s 或

and s,d: d=d&s 与

移位

sal k,d: d=d<<k 左移

shl k,d: d=d<<k 左移，等同于 sal

sar k,d: d=d<<k 左移，算术右移，左端补符号位

shr k,d: d=d<<k 左移，逻辑右移，左端补零

# 3.5.1 加载有效地址

leaq 实际上是 movq 指令的变形。操作是从内存读数据地址到寄存器。

leaq 在实际应用中常常不用来取地址，而用来计算加法和有限形式的乘法

leaq 9(rdi, rsi, 4), rax;//x in rdi,y in rsi。此操作实际上等于将 x+4*y+9 的结果存入 rax

# 3.5.2 一元和二元操作

一元操作中的操作数既是源又是目的。

二元操作中的第二个操作数既是源又是目的。

因为不能从内存到内存，因此当第二个操作数是内存地址时，要先从内存读出值，执行操作后再把结果写回去。

注意 sub s,d 是 d-s 而不是 s-d

# 3.5.3 移位操作

移位操作的移位量可以是一个立即数或放在单字节寄存器 cl 中。

当移位量大于目的数的长度时，只取移位量低字节中的值（小于目的数长度）来作为真实的移位量。

# 3.5.4 特殊的算术操作

两个 64 位数的乘积需要 128 位来表示，x86-64指令集可以有限的支持对 128 位数的操作，包括乘法和除法。

128 位数需要两个寄存器来存储，移动时也需要两个 movq 指令来移动。

这种情况对于有符号数和无符号数采用了不同的指令。

# 3.6 控制

条件语句、循环语句、分支语句都要求有条件的执行。

机器代码提供两种低级机制来实现有条件的行为：

测试数据值，然后根据测试的结果来改变控制流或数据流

使用 jump 指令进行跳转

# 3.6.1 条件码

条件码寄存器都是单个位的，是不同于整数寄存器的另一组寄存器。

条件码描述了最近的算术或逻辑操作的属性，可以通过检测这些寄存器来执行条件分支指令。

常用条件码：

CF：进位标志。 最近的操作使最高位产生了进位。可以用来检查无符号数的溢出

ZF：零标志。 最近的操作的结果为 0

SF：符号标志。 最近的操作的结果为负数。

OF：溢出标志。 最近的操作导致了补码溢出

除了 leaq 指令外，其余的所有算术和逻辑指令都会根据运算结果设置条件码。

此外还有两类特殊的指令，他们只设置条件码不更新目的寄存器：

cmp s1, s2： 除了不更新目的寄存器外与 sub 指令的行为相同

test s1, s2： 除了不更新目的寄存器外与 and 指令的行为相同

# 3.6.2 访问条件码

条件码一般不直接读取，常用的使用方法有 3 种：

根据条件码的某种组合，使用 set 指令类将一个字节设置为 0 或 1。

条件跳转到程序的某个其他部分

有条件地传送数据

set 指令类

set 指令的目的操作数是低位单字节寄存器元素或一个字节的内存位置。set 会将该字节设置为 0 或 1

set 指令类的后缀指明了所考虑的条件码的组合，如 setl (set less) 表示“小于时设置”

注意到上图中，set 指令对于大于、小于的比较分为了有符号和无符号两类。

大多数时候，机器代码对无符号和有符号两种情况使用一样的指令。

使用不同指令来处理无符号和有符号操作的情况：

不同的条件码组合：

不同版本的右移：sar 和 shr

不同的乘法和除法指令

汇编语言中数据本身不区分有符号和无符号，通过不同的指令来区分有符号操作和无符号操作。

注意在汇编代码中，8字节的操作数可能是 long，long long 或指针

# 3.6.3 跳转指令

跳转指令的目的地由一个标号指明

jmp .L1 ;//跳转到 .L1 。在实际的跳转指令中，.L1 会直接编码为跳转目标的地址。

movq (rax),rdx

.L1:

popq rdx

jmp 可以是直接跳转，即操作数为标号。也可以间接跳转，即操作数是寄存器或内存引用，这种情况下跳转到寄存器中存储的地址处。

跳转指令分为有条件跳转和无条件跳转，只有 jmp 是无条件跳转。有条件跳转都只能是直接跳转。

有条件跳转类似 set 指令系列，根据条件码寄存器的值来判断是否进行跳转。

# 3.6.4 跳转指令的编码

跳转指令的机器编码（就是纯粹数字表示的机器语言）有几种方式，其中两种如下：

PC 相对跳转：使用目标地址与跳转指令之后下一条指令的地址之间的差来编码。可以用 1、2 或 4 个字节来编码。

绝对地址编码：使用目标的绝对地址。用 4 个字节直接指出。

汇编器和链接器会自己选择适当的编码方式

# 3.6.5 用条件控制来实现条件分支

汇编代码层面的条件控制类似于 c 语言的 goto 语句。

汇编语言使用条件码和条件跳转来起到和 c 语言中 if 相似的作用

'C 语言'

if( x<y ) { i++ }

else { i-- }

'汇编'

cmpq rsi,rdi

jge .L2

incl rax;

.L2:

    decl rax;

# 3.6.6 用条件传送来实现条件分支

条件传送不会改变控制流，而是根据条件码决定是否改写目的寄存器。

常见指令形式为 cmovXX S, D

其中源操作数可以是寄存器或内存，目的操作数只能是寄存器

条件传送常用于实现简单的条件表达式，例如：

v = x < y ? x : y;

使用条件传送的好处：

避免分支预测失败带来的代价

在两种结果都容易提前算出的情况下，通常比真正跳转更高效

条件传送的局限：

两个分支对应的值通常都要先算出来

如果某一分支有副作用，或者计算代价很大，就不适合用条件传送

# 3.6.7 循环

机器级代码中没有 for、while、do-while 这样的“循环语法”，只有测试 + 跳转

do-while 最自然，因为它本来就是“先执行一次，再判断”

它通常会被翻译成：

执行循环体

测试条件

条件成立时跳回循环开头

while 往往会被改写成带条件跳转的 do-while 形式

也就是先跳到测试代码，再根据测试结果决定是否进入循环体

for 本质上也可以拆成：

初始化部分

条件测试部分

循环体部分

更新部分

因此在汇编层面，for 和 while 通常没有本质区别

break 和 continue

break 对应跳到循环结束位置

continue 对应跳到下一轮测试或更新位置

# 3.6.8 switch语句

switch 语句是一种多重分支

编译器实现 switch 的方式主要有两种：

使用一连串 cmp 和 jump

使用跳转表（jump table）

当 case 的值分布比较稠密时，编译器更倾向于使用跳转表

做法通常是：

先检查开关值是否越界

若越界则跳到 default

若不越界，则用开关值作为索引，从表中取出目标地址并进行间接跳转

跳转表的本质是一个地址数组

当 case 值很稀疏时，使用跳转表会浪费空间，这时编译器通常改用比较和分支

# 3.7 过程

过程调用是机器级程序中最核心的机制之一。

一个过程调用需要处理 3 件事：

传递控制

传递数据

为局部数据分配和释放空间

# 3.7.1 运行时栈

过程调用依赖于运行时栈

当过程 P 调用过程 Q 时，控制和数据都通过栈来组织

每次过程调用都会在栈上分配一块空间，称为栈帧

栈帧中通常保存：

返回地址

被保存的寄存器

局部变量

为调用其他过程准备的参数空间

栈向低地址方向增长，因此分配栈帧通常表现为rsp 减小

过程返回时，对应栈帧被释放，rsp 恢复

# 3.7.2 转移控制

过程调用和返回分别由 call 和 ret 指令实现

call label

先把返回地址压入栈中

再跳转到被调用过程的开始位置

ret

从栈中弹出返回地址

然后跳转到该地址继续执行

call 可以是：

直接调用：目标是一个标号

间接调用：目标地址保存在寄存器或内存中。函数指针调用就是这种形式

# 3.7.3 数据传送

过程之间传递数据主要依赖寄存器和栈

x86-64 中，整数和指针参数的前 6 个通常通过寄存器传递：

rdi, rsi, rdx, rcx, r8, r9

如果参数超过 6 个，其余参数通过栈传递

返回值通常通过 rax 返回

有些较大的返回结果不会直接放在寄存器里，而是通过调用者提供的一块内存区域来返回

调用者保存和被调用者保存

有些寄存器属于调用者保存

如果调用者希望这些值在 call 后仍然有效，就必须自己先保存

有些寄存器属于被调用者保存

如果被调用过程要使用它们，就要先保存，结束前再恢复

这套约定保证了不同过程编译出来后仍然能够正确协作

# 3.7.4 栈上的局部存储

当局部变量太多，或者必须有内存地址时，编译器会把它们放在栈帧里

例如：

局部数组

结构体局部变量

需要取地址的局部变量

为了给这些数据分配空间，过程开始时通常会执行类似：

subq $32, %rsp

这表示在栈上开辟 32 字节空间

函数结束前再通过 addq 或直接恢复 rsp 来释放这些空间

# 3.7.5 寄存器中的局部存储空间

如果局部变量是简单的标量值，而且生命周期合适，编译器更愿意把它们保存在寄存器里

这样做的优点是：

访问速度快

不需要内存读写

便于编译器做优化

因此，优化后的代码里常常看不到“局部变量名”，只能看到若干寄存器在承担变量角色

# 3.7.6 递归过程

递归并不需要特殊的指令支持。

它只是一个过程直接或间接调用自己

每次递归调用都会产生一个新的栈帧，因此：

每一层调用都有自己独立的返回地址

每一层调用都有自己独立的局部变量

递归之所以可行，本质上依赖于栈对“多个未完成调用”的保存能力

递归层次过深会导致栈空间耗尽

这就是栈溢出的一个常见来源

# 3.8 数组分配和访问

数组在机器级程序中表现为一段连续分配的内存

数组访问的关键问题是：如何从基址和下标算出元素地址

# 3.8.1 基本原则

若数组 A 的基址为 x，元素类型大小为 L，那么：

&A[i] = x + i * L

这说明数组访问本质上是地址计算

编译器会尽量利用 x86-64 的比例寻址模式来完成这样的计算

如果元素大小是 1、2、4、8 字节，那么通常可以直接利用硬件支持的比例因子

# 3.8.2 指针运算

在 C 语言中，数组名在很多场景下会退化为指向首元素的指针

因此：

A[i]

和

*(A + i)

本质上是同一件事

指针加法并不是按字节递增，而是按所指对象的大小递增

例如 int *p 中，p+1 实际上是地址加 4（假设 int 为 4 字节）

两个同类型指针相减，得到的也不是字节差，而是元素个数差

# 3.8.3 嵌套的数组

多维数组在内存中仍然是按线性方式存放的

C 语言采用行优先（row-major） 次序

例如二维数组 AR 中，Ai 的地址为：

&A[i][j] = x + (i * C + j) * L

其中 x 是数组起始地址，L 是每个元素的大小

因此访问二维数组时，编译器要先算出“第 i 行的起始偏移”，再加上列偏移

# 3.8.4 定长数组

如果数组维度在编译时就已知，那么很多地址计算都可以在编译阶段部分化简

例如一行有多少字节，可以直接当作常数使用

这样生成的汇编代码通常更简洁，也更容易优化

这就是为什么固定维度数组经常能得到更高效的机器代码

# 3.8.5 变长数组

变长数组（VLA）的维度直到运行时才知道

这意味着：

行大小要在运行时计算

整个数组所需空间也要在运行时计算

栈帧大小因此不再固定

编译器通常会动态调整 rsp 来为它分配空间

由于涉及更多运行时计算，变长数组对应的机器代码往往比定长数组复杂

# 3.9 异质的数据结构

数组中的元素类型完全相同，而结构体和联合允许把不同类型的数据组织在一起

理解它们的机器级表示，对于分析内存布局很重要

# 3.9.1 结构

结构体的各个字段按照一定顺序存放在一段连续内存中

每个字段相对于结构起始地址都有一个固定偏移量

因此访问结构字段时，机器代码所做的事情就是：

基址 + 固定偏移

例如 p->x 往往会被编译成“先取出 p，再访问某个固定偏移位置”

嵌套结构的访问，本质上只是多层偏移量的叠加

# 3.9.2 联合

联合（union）的所有字段共享同一段存储空间

也就是说，不同字段的起始地址相同

联合的大小至少要能够容纳它的最大成员

联合的用途之一是：

用同一段位模式，从不同类型的角度来解释数据

但程序员必须自己保证“当前读取的字段”与“最近写入的字段”在语义上是合理的

# 3.9.3 数据对齐

为了提高存取效率，很多数据对象都会按某种对齐要求存放

例如 4 字节对象通常希望地址是 4 的倍数，8 字节对象通常希望地址是 8 的倍数

对齐会带来一个结果：填充字节（padding）

填充可能出现在：

结构字段之间

结构体尾部

结构体尾部补齐的原因是：如果这个结构体再组成数组，那么数组中每个元素的起始地址仍然要满足对齐约束

因此，字段顺序不同，结构体大小也可能不同

# 3.10 在机器级程序中将控制与数据结合起来

前面分别讨论了控制和数据。

真正的程序错误，往往出现在二者结合的地方，尤其是指针、数组、栈帧和控制转移交织时

# 3.10.1 理解指针

指针保存的是地址

但“这个地址该按什么类型解释”，由指针类型决定

同一个地址：

作为 char * 读取，含义可能是一个字节

作为 int * 读取，含义可能是 4 个字节组成的整数

因此，指针既强大也危险

空指针、悬垂指针、越界指针都会导致不可预期的行为

从机器级角度看，处理器只是在使用某个地址，它并不知道这个地址在 C 语言语义下是否合法

# 3.10.2 应用:使用GDB调试器

GDB 可以帮助我们把高级语言和机器级执行过程联系起来

常见用途：

查看寄存器：info registers

反汇编函数：disas

查看内存：x/16gx addr

单步执行：stepi、nexti

设置断点：break

用 GDB 观察程序时，可以清楚地看到：

参数进入了哪些寄存器

栈帧是如何变化的

条件跳转究竟依据了什么条件码

这对于理解汇编代码和排查底层错误都非常重要

# 3.10.3 内存越界引用和缓冲区溢出

数组和缓冲区本质上都是连续内存区域

如果程序写入超过边界的数据，就会覆盖相邻内存内容

这可能破坏：

其他局部变量

保存的寄存器值

返回地址

这类错误之所以危险，是因为机器指令通常不会自动进行边界检查

因此一个看似普通的数组写操作，可能最终改变控制流

# 3.10.4 对抗缓冲区溢出攻击

现代系统使用了多种机制来减轻缓冲区溢出的危害：

栈随机化（ASLR）

栈不可执行

栈保护值（canary）

这些机制的作用是：

增加攻击者预测地址的难度

阻止把栈中的数据直接当成代码执行

在返回前检查栈帧是否被破坏

但最根本的方法仍然是：写出不发生越界访问的程序

# 3.10.5 支持变长栈帧

有些过程的栈帧大小在编译时并不固定，例如：

使用变长数组

使用 alloca 在运行时申请栈空间

这会让 rsp 在过程执行期间发生额外变化

在这种情况下，如果仍然需要稳定地访问某些局部变量或保存值，编译器更可能使用 rbp 作为帧指针

也就是说：

rsp 更适合表示“当前栈顶”

rbp 更适合表示“本过程栈帧中的固定参考位置”

# 3.11 浮点代码

浮点数据的处理和整数明显不同。

x86-64 中，现代编译器通常使用 XMM 寄存器 和一套专门的浮点指令来处理单精度和双精度数

# 3.11.1 浮点传送和转换操作

浮点数据的传送常使用：

movss：传送单精度浮点数

movsd：传送双精度浮点数

整数和浮点数之间的转换则使用专门的转换指令

例如：

cvtsi2sd：整数转双精度

cvttsd2si：双精度转整数（带截断）

这说明浮点和整数虽然都存放在寄存器里，但它们的处理路径并不相同

# 3.11.2 过程中的浮点代码

浮点参数和返回值通常通过 XMM 寄存器 传递

常见约定是：

前若干个浮点参数放在 xmm0 ~ xmm7

浮点返回值放在 xmm0

因此一个过程如果同时接收整数参数和浮点参数，编译器需要分别管理两套寄存器约定

# 3.11.3 浮点运算操作

浮点加减乘除也有各自的专用指令，例如：

addss / addsd

subss / subsd

mulss / mulsd

divss / divsd

这些指令处理的是浮点编码后的位模式，但语义遵循 IEEE 浮点规则

因此结果会受到舍入、无穷大、NaN 等规则影响

# 3.11.4 定义和使用浮点常数

和整数立即数不同，很多浮点常数不会直接编码在运算指令里

编译器通常把它们放在某个只读数据区中

使用时先把常数加载到寄存器，再参与计算

所以在反汇编中，经常能看到某条浮点指令访问一个常量表中的地址

# 3.11.5 在浮点代码中使用位级操作

虽然浮点数有自己的算术规则，但它们本质上仍然是一组位

因此也可以通过某些按位操作来完成特殊处理

例如：

修改符号位来实现取负

清除符号位来实现绝对值

这种做法依赖于对 IEEE 浮点表示格式的理解

# 3.11.6 浮点比较操作

浮点比较通常使用专门的比较指令，如 ucomiss、ucomisd

它们会设置条件码，然后再配合 set 或 jump 指令使用

与整数比较不同的是，浮点比较还要考虑 NaN

一旦操作数中出现 NaN，比较结果会涉及“无序（unordered）”这一特殊情况

因此浮点比较的行为比整数比较更复杂

# 3.11.7 对浮点代码的观察结论

浮点代码与整数代码相比，有几个明显特征：

使用不同的寄存器集合

使用不同的传送、转换、比较和运算指令

必须遵守 IEEE 浮点语义，而不能简单套用整数规则

因此分析浮点程序时，不能只靠“整数运算直觉”去理解它

# 3.12 小结

本章讨论了 C 程序如何被翻译成机器级表示。

核心内容包括：

寄存器和数据传送

算术与逻辑运算

条件码、跳转、循环和 switch

过程调用、栈帧和递归

数组、结构体、联合和对齐

缓冲区溢出等底层安全问题

浮点代码的专用表示方式

理解这些内容的意义不只是“会读汇编”。

更重要的是：

能理解编译器到底做了什么

能分析程序性能和隐藏的低效率

能更准确地定位底层 bug

能从机器级角度理解安全问题产生的原因

这正是学习“程序的机器级表示”的价值所在

‍

CSAPP 第二章信息的表示和处理

2026-05-19T15:53:44.000Z

# CSAPP 第二章信息的表示和处理

第二章 信息的表示和处理

计算机使用二值信号存储和表示信息

当计算结果太大以至于不能表示时，就会产生溢出。

浮点数表示的精度有限，因而浮点运算是不可结合的。

整数的表示范围小但是精确，浮点数表示的范围大但是是近似的。

许多安全漏洞是由算术运算的微妙细节导致的。

# 2.1 信息存储

计算机一般使用字节作为最小的可寻址的内存单位。

在机器级程序中不包含关于数据类型的信息。

指针的值是某个存储块的第一个字节的虚拟地址。

每个程序对象可以视为一个字节块。

# 2.1.1 十六进制表示法

十六进制以 0x 开头。

A：10；C:12；F：15

# 2.1.2 字数据大小

每个计算机有对应的字长，虚拟地址用一个字来编码，所以字长决定了虚拟地址空间的大小。64 位机器的指针类型长度为 8 字节

32位机器的虚拟地址空间为 4GB，64 位字长的虚拟地址空间位 16 EB。

int32_t 和 int64_t 类型分别为 4 字节和 8 字节，不受机器影响。使用确定大小的整数类型很有用。

对 32 位和 64 位机器而言，char、short、int、long long 长度都是一样的，为 1，2，4，8。long 的长度不一样。

float 和 double 的长度一样，分别为 4，8

程序对 char 有无符号一般不敏感。

# 2.1.3 寻址和字节顺序

对于跨越多字节的对象，它的地址是它所用字节中的最小地址。

两种字节存储法：

小端法：数字的低位在前（前就是最小地址）

大端法：数字的高位在前

大多数 Intel 都是小端法，不是所有。

# 2.1.4 表示字符串

C 语言字符串是以 null 字符结尾的字符数组，即 '\0'

ASCII 字符适合编码英文文档。

Unicode（UTF-8）使用 4 字节表示字符，一些常用的字符只需要 1 或 2 个字节。所有 ASCII 字符在 UTF-8 中是一样的。

JAVA 使用 UTF-8 来编码字符串。

# 2.1.5 表示代码

二进制代码是不兼容的，一般无法在不同机器间移植。

从机器的角度看，程序就是一个字节序列。

# 2.1.6 布尔代数

布尔代数是在 0 和 1 基础上的定义

可以把字节看作是一个长为 8 的位向量。

位向量的一个应用是表示有限集合。如位向量 [0110 1001] 表示集合 A = {0,3,5,6}。

# 2.1.7 C 语言中的位级运算

位运算的常见应用是实现掩码。掩码表示从一个字中选出的位的集合，如掩码 0xFF 表示一个字的低 8 位。

表达式 ~0 可以生成一个全 1 的掩码，不管机器的字大小是多少。

# 2.1.8 C 语言中的逻辑运算

逻辑运算符 && 和 || 如果第一个参数就能确定结果，就不再计算第二个参数

# 2.1.9 C 语言中的移位运算

左移 k 位丢掉最高的 k 位，并在右端补 k 个 0。

右移分为逻辑右移和算术右移。逻辑右移左端补 0，算术右移左端补最高有效位的值。

一般都对有符号数使用算术右移，即补符号位的值。无符号数，只能是逻辑右移，即补 0

# 2.2 整数表示

无符号表示与补码表示

有符号数到无符号数的转换会产生漏洞，避免错误的方法之一是绝不使用无符号数。

除了 C 以外很少有语言支持无符号整数，Java 就只支持有符号数

# 2.2.1 整数数据类型

在 64 位系统上

int：4字节，可表示十进制数字位数：10位（-20~20亿以内）

long long：8字节，可表示十进制数字位数：19位（千亿亿级）

long：8字节

double：8字节，精度15位，可表示十进制数字位数308位

float：4字节，精度6位，可表示十进制数字38位

char： -128~127

java 只支持有符号数。

# 2.2.2 无符号数的编码

无符号表示、补码表示与数据的映射都是双射，即一一对应。

# 2.2.3 补码编码

补码的定义实际就是将符号位解释为负权。

C 库头文件 <limit.h> 定义了一组常量来限定不同整数数据类型的取值范围。INT_MAX、INT_MIN、UINT_MAX

C 库头文件 <stdint.h> 中定义了 uint16_t, int32_t 等类型，用于声明确定宽度类型的整数。

# 2.2.4 有符号数和无符号数之间的转换

在有符号数与无符号数之间进行强制类型转换的结果是保持位值不变，只改变解释位的方式。

补码 x 转无符号数

$x \ge 0$ ，值不变

$x < 0$ ，转换后的值为 $2^w + x$

无符号数 x 转补码

$x < 2^{w-1}$ ，值不变

$x \ge 2^{w-1}$ ，转换后的值为 $x - 2^w$

# 2.2.5 C 语言中的有符号数和无符号数

C 语言中有符号数和无符号数相加减，有符号被转换成无符号。

# 2.2.6 扩展一个数字的位表示

扩展无符号数使用零扩展，即在最高位前加 0

扩展有符号数使用符号扩展，即在最高位前加最高有效位的值

# 2.2.7 截断数字

对一个 w 位的数字截断为一个 k 位数字，将丢弃高 w-k 位。

对于无符号数而言，截断后的数字实际上等于 w mod 2^k，即取余。

# 2.3 整数运算

# 2.3.1 无符号加法

考虑溢出，C 语言不会将溢出作为错误发出信号

当 $x+y \ge 2^w$ 时，实际结果为 $s = x+y-2^w$

对任意的 $x+y$ ，有 $s = (x+y) \bmod 2^w$

溢出的结果： 和小于两个加数

检验溢出的方式： 如果 $s<x$ ，说明溢出

无符号数的非： $x \mapsto 2^w - x \ (x>0)$

# 2.3.2 补码加法

当 $x+y \ge 2^{w-1}$ 时， $s = x+y-2^w$

当 $x+y < -2^{w-1}$ 时， $s = x+y+2^w$

正溢出的结果是负数，负溢出的结果是正数。

检验溢出的方式： 当 $x,y>0$ 而 $s\le 0$ 时是正溢出；当 $x,y<0$ 而 $s\ge 0$ 时是负溢出

# 2.3.3 补码的非

当 x = TMin，-x = TMin；当 x ≠ TMin，-x = -x

补码非的位级表示：对每一位求补，结果再加 1

计算补码非的第二种方法： 假设 k 是最右边的 1 的位置，对 k 左边的所有位取反

# 2.3.4 无符号乘法

无符号乘法的积 m = (x*y) % 2^w

# 2.3.5 补码乘法

可以认为补码乘法和无符号乘法的位级表示是一样的

C语言在运算时将 x,y 视为无符号数进行乘法运算，结果取余后将其按补码方式解释

补码乘法的积 m = (x*y) % 2^w

# 2.3.6 乘以常数

大多数机器上，整数乘法需要 10 个或更多的时钟周期，而加法、减法、位级运算和移位只需要 1 个时钟周期

编译器对整数乘法进行优化的方式：用移位和加法或减法运算的组合来代替常数因子的乘法。

左移 k 位等于乘以 2^k

如 x * 14 = (x<<3)+(x<<2)+(x<<1) = (x<<4)-(x<<2)

判断如何移动的方式很简单：14 的位级表示为 1110，所以分别左移 3，2，1

# 2.3.7 除以 2 的幂

大多数机器上，整数除法更慢，需要 30 个或更多的始终周期。

（只有）除以 2 的幂可以用移位运算来代替，无符号采用逻辑右移，补码采用算术右移

对于有符号数而言，算术右移的结果相当于进行除法运算后向下舍入

使用 (x+(1<<k)-1)>>k 的结果相当于进行除法运算然后向零舍入

代码实现

(x<0 ? x+(1<<k)-1 : x) >> k;

# 2.3.8 关于整数运算的最后思考

补码使用了与无符号算术运算相同的位级实现，包括加法、减法、乘法甚至除法。都有完全一样或非常类似的位级行为。

# 2.4 浮点数

浮点数对于非常大，非常接近零，近似值计算都很有用

# 2.4.1 二进制小数

小数的二进制表示法只能表示那些能够写为 $x \times 2^w$ 的数，其他的数都是近似表示。 $x$ 必须可以由形如 $2^i + 2^j + \dots + 2^n$ 的多项式表示。

浮点运算的不精确性可能产生严重后果

# 2.4.2 IEEE 浮点表示

IEEE 浮点标准的表示形式为： $V = (-1)^S \times M \times 2^E$ ，它分为三部分：

符号：S 决定是负数还是正数

阶码：E 的作用是对浮点数加权

尾数：M 是一个二进制小数。规格化值时范围是 $1 \le M < 2$ ，非规格化值时范围是 $0 \le M < 1$

在对浮点数的位编码时：

一个单独的符号位编码直接编码 S

k 位的阶码字段 e 编码 E；float 中 k=8，double 中** k=11**

n 位的小数字段 f 编码 M；float 中 n=23，double 中** n=52**

E 和 M 的编码方式分为三种情况：

规格化的值： 阶码字段即不全为 0 也不全为 1 时属于规格化值（0001~1110）

阶码字段解释方式： $E = e - (2^{k-1}-1)$ ；如 $k=4$ 时， $E$ 的范围是 $-6$ 到 $7$ ；单精度为 $-126$ 到 $127$

小数字段解释方式：M = 1 + f

非规格化的值：阶码字段全为 0 时属于非规格化形式

阶码字段解释方式：E = 1 - (2^(k-1)-1) ；与规格化值中 e = 1 时的 E 相同

小数字段解释方式：M = f

特殊值： 阶码字段全为 1 时，分两种情况：

小数字段全为 0：表示无穷

小数字段非零：表示 NaN。 比如 ∞-∞ 的结果就返回 NaN

# 2.4.3 数字示例

0 有 +0.0 和 -0.0 两种表示方式

最大非规格化数到最小规格化数的过渡是平滑的。

浮点数能够使用正数排序函数来排序，即浮点数的位级表示当用整数方式来解释时是顺序的（正数升序负数降序）。

# 问题 2.1

十六进制中 A,C,F 分别是多少。
如何定义有确定字长的整数，在哪个头文件中
计算机的字长是什么？字长决定了什么？
short, int, long long 长度分别是多少，long 长度是多少
一个 int 对象的地址是它所占哪个字节的地址
多字节类型的小端法和大端法分别是什么，一般计算机是哪种方法
ASCII 和 Unicode 分别应用于哪些情况？两者的关系是什么
掩码是什么？如何生成全 1 的数字
什么是逻辑右移和算术右移，有符号数用哪个？无符号数用哪个
int, long long, char，short 可表示的范围分别是多少
float, double 的精度和可表示范围分别是多少
补码如何解释位
有符号数和无符号数的强制类型转换是如何转换的
有符号转无符号数值如何变化？无符号转有符号数值如何变化？
如何扩展有符号数？如何扩展无符号数？
截断一个无符号数从数学运算上如何理解？

# 回答2.1

A 是 10，C 是 12，F 是 15
使用 int32_t, int64_t, uint32_t, uint64_t。定义在头文件 <stdint.h> 中
分别是 2，4，8 位，long 在 32 位程序中是 4 位，在 64 位机器中是 8位
32 位计算机的字长是 32 位，64 位计算机的字长是 64 位，字长w决定了虚拟空间的大小：<= 2^w。
最小字节的地址
小端法将低位表示在低字节，大端法将高位表示在低字节。大部分是小端法。
ASCII 用于英文文档，UTF-8 用于多语言，所有的 ASCII 字符在 UTF-8 中是一样的
掩码用来筛选一个数字的某几位，~0 的结果是全 1
逻辑右移左边补 0，算术右移左端补符号位，有符号数用算术右移，无符号数用逻辑右移
int 大约是 10 位十进制精度（约 $-20$ 亿到 $20$ 亿）；long long 大约是 19 位；char 为 $-128$ 到 $127$ ；short 为 $-32768$ 到 $32767$
6位，10 的 38 次方以内；15位，10 的 308 次方以内；
最高位解释为负权
位值不变，改变解释的方式
若 $x<0$ ，则 $u_x = x + 2^w$ ；若无符号数 $u_x \ge 2^{w-1}$ ，则 $x = u_x - 2^w$
左端填充为符号位；左端填充为 0
对 2^k 取模

# 问题 2.2

考虑溢出，无符号加法的计算公式，无符号乘法的计算公式？如何检验溢出？
考虑溢出，补码加法的计算公式，补码加法溢出的特点是什么？如何检验溢出？
考虑溢出，补码乘法的计算方法
补码的非怎么求？
整数乘法的计算速度？整数乘法的优化方式？如何判断移动的方式？
整数除法的计算速度？除以 2 的幂的优化方式？
整数补码运算与无符号运算的关系
浮点数表示法的限制
浮点数位级表示的三个部分？double 分别有多少位？
阶码和尾数的三种编码方式分别是什么？
最小的正非规格化值、最大的非规格化值、最小的正规格化值、最大的规格化值的位级表示分别是怎样的？
什么是向偶数舍入？浮点数的近似匹配采用哪种舍入方式？有什么优点
浮点运算满足什么运算性质？不满足什么性质？
从 float 或 double 转换到 int 可能会发生什么情况？

# 回答2，2

s=(x+y)%2^w；m=(x*y)%2^w；检验加法溢出：s<x 或 s<y
分三种情况，不溢出，正溢出，负溢出；特点：正溢出的结果是负数，负溢出的结果是正数；检验溢出：结果变号了就是溢出了
将两个乘数当成无符号数进行乘法计算，截断溢出的部分后，将剩余部分用补码方式解释
按位求反再加一
大于等于 10 个时钟周期；用移位+加法/减法优化；根据移位程度 k 的位级表示来判断
大于等于 30 个时钟周期；逻辑右移或算术右移；算术右移的结果是向下舍入，可以调整为向零舍入
在位级表示上完全相同或非常相似
只能表示 x * 2^y 类的数，其他数字只能近似表示
符号、阶码、尾数；1，11位，52位
规格化值：阶码非全 0 且非全 1，指数偏移量为 $2^{k-1}-1$ ，尾数为 $1+f$ ；非规格化值：阶码全 0， $E = 1-(2^{k-1}-1)$ ，尾数为 $f$ ；特殊值：阶码全 1，尾数全 0 表示无穷，尾数非全 0 表示 NaN
末位为1，其他为0；尾数全1，其他全0；阶码末位为1，其他全0；阶码末位和符号位为0，其他全1；
非中间值向近舍入，中间值向偶数舍入；采用向偶数舍入；优点是统计结果不偏差
满足交换性和单调性，不满足结合性和分配性
可能溢出和舍入；如果溢出，转换结果都是 100000，是一个负数。

CSAPP 第一章计算机系统漫游

2026-05-19T14:56:26.000Z

# CSAPP 第一章计算机系统漫游

# 1.1 信息就是位 + 上下文

程序的生命周期从源程序（源文件） 开始。源程序实际上就是由 0 和 1 组成的位序列。

一般用 ASCII 标准来表示文本字符，实际上是用一个字节的整数值来表示一种字符。

源文件中每个文本行都是以看不见的 '\n' 结束的。

只由 ASCII 字符组成的文件成为文本文件，其他都是二进制文件。.cpp 文件就是文本文件。

系统中的所有信息都是由一串比特（bit：位）表示的，区分不同数据对象的唯一方法就是根据上下文。

C 语言的特点

C 语言小而简单
C 语言是为了实现 unix 而设计的
C 语言与 unix 关系密切
C 语言是系统级编程的首选，也非常适用于应用级程序。

# 1.2 程序被其他程序翻译成不同的格式

从源程序到目标程序要经历四个步骤：

源程序被预处理器处理得到修改了的源程序（文本文件，hello.i）
再由编译器处理得到汇编程序（文本文件,hello.s）
汇编程序由汇编器处理得到可重定位目标程序（二进制文件,hello.o）
最后由链接器链接得到可执行目标程序（二进制文件,hello）

预处理阶段

预处理器根据 # 开头的命令修改原始的 c 程序。比如根据 #include<stdio.h> 命令把头文件 stdio.h 的内容直接插入到程序文件中。

编译阶段

汇编语言程序中的每条语句都以一种标准的文本格式确切地描述一条低级机器语言指令。

汇编阶段

汇编器将hello.s翻译成机器语言指令，把这些指令打包成一种叫可重定向目标程序的格式，并将结果保存至目标文件hello.o中。

链接阶段

比如 printf 函数是一个标准 C 库函数，存在于 printf.o 中，这是一个单独的预编译好了的目标文件。链接器将其与汇编得到的二进制文件合并得到可执行目标文件。

# 1.3 了解编译系统如何工作是大有用处的

用处：

优化程序性能
理解链接时出现的错误
避免安全漏洞

# 1.4 处理器读并解释储存在内存中的指令

shell 是一个命令行解释器，它输出一个提示符（>>），等待输入一个命令行，然后执行命令。如果输入的是可执行文件的名字，就运行该文件。

# 1.4.1 系统的硬件组成

主要包括总线、I/O 设备、处理器、主存储器四个部分

总线

总线一次可以传输一个定长的字节块，称为字。64位系统即总线一次可以传输 64 位（8字节），这里一个字就是 8 字节

I/O 设备

每个 I/O 设备通过一个控制器或适配器与 I/O 总线相连。

控制器是 I/O 设备本身或主板上的芯片组，适配器则是一块插在主板上的卡。

主存

主存是由一组动态随机存取内存（DRAM） 组成的。

从逻辑上看，存储器是一个线性的字节数组，每个字节都有唯一的地址。

处理器

处理器是解释存储在主存中指令的引擎。

处理器的核心是一个程序计数器（PC)

程序计数器是一个大小为一个字的存储设备，存储CPU即将执行的下一条指令的地址。

处理器就是在不断执行程序计数器指向的指令。每执行一条，程序计数器更新一次，指向下一条指令。

处理器会按照指令执行模型（指令集架构） 解释指令中的位并执行相应操作。

每条指令的操作是围绕主存、寄存器文件、算数/逻辑单元（ALU） 进行的。

寄存器文件：单个字长，有唯一的名字。

ALU： 计算新的数据和地址值。

几个简单指令的操作：

加载：从主存复制一个字或字节到寄存器，覆盖原来内容

存储：从寄存器复制一个字或字节到主存，覆盖原来内容

操作：把两个寄存器的内容复制到 ALU，ALU 对这两个字做算术运算，并把结果存到一个寄存器中

跳转：从指令中抽取一个字复制到程序计数器中，覆盖原来内容。

区分处理器指令集架构和微体系架构：

指令集架构： 每条机器指令的效果

微体系架构： 处理器实际上是如何实现的

# 1.4.2 运行 hello 程序

执行目标文件时，shell 程序将位于磁盘目标文件中的字符逐个读入寄存器，然后放到主存中。之后处理器就开始执行目标文件的机器语言指令，从 main 程序开始。

利用直接存储器存取（DMA） 可以不通过寄存器，直接将数据从磁盘到达内存。

以输出打印 hello world 为例，处理器将 hello world 的字节复制到寄存器，然后再复制到显示器，最后显示在屏幕上。

整个流程：读取文件字符到寄存器 → 存储到主存 → 执行指令 → 加载 helloworld 到寄存器 → 复制到显示器 → 显示

# 1.5 高速缓存至关重要

从主存读取一个字比磁盘快 1000 万倍。

从寄存器文件读取比主存块 100 倍，并且差距还在加大。

高速缓存（cache）用来解决处理器与主存间的差异。

L1 高速缓存位于 CPU 上，容量为数万字节（几十 MB）。L1 比 L2 快 5 倍。

L2 高速缓存通过一条特殊的总线与 CPU 连接，容量为数十万到数百万字节（几百 MB 到几 GB）。L2 比主存快 5~10 倍

新的系统还有 L3。

通过让高速缓存里存放可能经常访问的数据，让大部分的内存操作都在高速缓存中完成。

# 1.6 存储设备形成层次结构

存储器层次结构共 7 层，主要思想是上一层的存储器作为低一层的高速缓存。

从上到下，容量更大，运行更慢，每字节价格更便宜。

0层：寄存器

1层：L1高速缓存(SRAM)

2层：L2高速缓存(SRAM)

3层：L3高速缓存（SRAM）

4层：主存（DRAM）

5层：本地二级存储（本地磁盘）

6层：远程二级存储（分布式文件系统，Web服务器）

# 1.7 操作系统管理硬件

操作系统的两个基本功能：

防止硬件被失控的应用程序滥用
向应用程序提供简单一致的机制来控制复杂的低级硬件设备

操作系统所应用的三个基本的抽象概念：

进程：对处理器、主存和 I/O 设备的抽象表示
虚拟内存：对主存和磁盘的抽象表示
文件：对 I/O 设备的抽象表示

# 1.7.1 进程

进程： 对操作系统正在运行的程序的一种抽象。

并发运行： 一个进程的指令和另一个进程的指令是交错执行的。

一个系统可以同时运行多个进程，实际上这些进程是并发运行的。

操作系统通过上下文切换来实现并发运行。上下文是跟踪进程运行所需的所有状态信息，可能存在于PC、寄存器文件、主存等地方。

任何时刻，单处理器只能执行一个进程的代码。

操作系统内核是操作系统代码常驻主存的部分，从一个进程到另一个进程的转换是由内核管理的。

内核不是一个独立的进程，是一系列代码和数据结构的集合。

当应用程序需要操作系统的某些操作时，就把控制权传递给内核，内核执行完操作后返回应用程序。

# 1.7.2 线程

一个进程由多个线程组成，每个线程都运行在进程的上下文中，共享同样的代码和全局数据。

多线程之间比多进程之间更容易共享数据，且线程一般来说比进程更高效。

# 1.7.3 虚拟内存

机器级程序将内存视为一个庞大的字节数组，称为虚拟内存。

内存的每个字节由地址来标识，所有可能地址的集合就是虚拟地址空间。

虚拟内存使每个进程都以为自己独占了主存。每个进程看到的内存都是一致的，即虚拟地址空间。

在linux中，每个进程看到的虚拟地址空间由以下几个部分组成：

程序代码和数据

堆（运行时堆）

共享库

栈（用户栈）

内核虚拟内存

地址从低到高，最高层的内核虚拟内存保存的是操作系统中的代码和数据，这部分每个进程都一样。

程序代码和数据

对所有进程来说，代码都是从同一个固定地址开始，紧接着是与全局变量对应的数据区。代码和数据区都是按照可执行文件的内容初始化的。代码和数据区在进程开始运行时就被指定了大小。

堆

而运行时堆是根据 malloc 和 free 函数的调用在运行时动态地扩展和收缩的。

共享库

地址空间的中间部分用来存放共享库的代码和数据。如 C 标准库、数学库等都属于共享库

栈

用户栈和堆一样，在程序执行期间可以动态的扩展和收缩，编译器用它来实现函数调用。当调用函数时，栈增长，从函数返回时，栈收缩

# 1.7.4 文件

文件就是字节序列，仅此而已。

每个 I/O 设备，包括磁盘、键盘、显示器、网络，都可以看成是文件。

# 1.8 系统之间利用网络通信

从一个单独的系统而言，网络可以视为一个 I/O 设备。

以在一个远端服务器运行程序为例，在本地输入，在远端执行，执行结果发送回本地输出。

# 1.9 重要主题

# 1.9.1 Amdahl 定律

Amdahl 定律的主要观点：要加速整个系统，必须提升全系统中相当大的部分。

# 1.9.2 并发和并行

区分并发与并行：

并发： 一个通用的概念，指一个同时具有多个活动的系统

并行： 用并发来使系统运行得更快

并行可以在多个抽象层次上运用。从高到低有以下三个层次

1.线程级并行

传统意义上的并发执行是通过单处理器在进程间快速切换模拟出来的。

多处理器系统由一个操作系统控制多个 CPU。结构如下

L1 高速缓存被分为两个部分：一个保存最近取到的指令，一个存放数据。

超线程又称同时多线程，它允许一个 CPU 执行多个控制流。 CPU 有的硬件有多个备份，比如程序计数器和寄存器文件，而其他硬件只有一份，比如浮点算术运算单元。常规 CPU 需要约 20000 个时钟周期来切换线程，超线程 CPU 可以在单个周期的基础上切换线程，比如一个线程在等待数据装在到高速缓存，CPU 就可以去执行另一个线程。

i7 处理器每个核执行两个线程，所以是 4 核 8 线程，8 个线程都并行执行。

2. 指令级并行

每条指令从开始到结束一般需要 20 个或更多的时钟周期，通过指令级并行，可以实现每个周期 2~4 条指令的执行速率。

如果比一个周期一条指令更快，就称为超标量处理器，现在一般都是超标量。

3. 单指令、多数据并行

在最低层次上，现代处理器允许一条指令产生多个可以并行执行的操作，称为单指令、多数据并行，即 SIMD 并行。

# 1.9.3 计算机系统中抽象的重要性

指令集架构是对 CPU 硬件的抽象，使用这个抽象，CPU 看起来好像一次只执行机器代码程序的一条指令，实际上底层硬件并行地执行多条指令。

虚拟机是对整个计算机系统的抽象，包括操作系统、处理器和程序。

# 问题1.1

信息的两个要素
文本文件是由什么组成的
从源程序到目标程序的四个阶段
系统硬件组成的四个部分
从逻辑上看主存是什么样的
主存硬件上是什么组成的
处理器的核心是什么？它主要干什么
用最简单的方式描述处理器运行的过程
指令操作围绕哪三个部件执行
四个指令操作：加载、存储、操作、跳转分别是什么
指令集架构和微体系架构分别是什么
CPU 执行一个目标文件的流程
从源程序到得出运行结果的整个流程

# 回答1.1

位+上下文
由 ASCII 标准表示的字符
预处理器，编译器，汇编器，链接器
处理器、主存、I/O 设备、总线
一串线性字节数组，每个字节有唯一的地址
动态随机存取内存（DRAM）
程序计数器，一个字，存储下一条指令的地址。
执行 PC 所指向的指令，然后更新 PC。
主存、寄存器和 ALU，寄存器存放一些指令和数据、状态等，ALU 计算数据和地址
略
一个描述指令的效果，一个是硬件实现方式
把文件从磁盘读取到寄存器，再放到主存（直接存取可以实现不经过寄存器），然后从主存读取指令开始执行，如果要显示一个数字，把数字读到寄存器，再输出到显示器
源程序→目标程序→处理器执行目标程序

# 问题1.2

主存比磁盘快多少，寄存器比主存快多少
L1 cache 位于哪里？有多大？有多快？L2 呢？
高速缓存是怎么用的？
存储器层次结构有几层，主要思想是什么？
操作系统的三个基本抽象概念是什么
什么是进程？进程有什么特点
什么是操作系统内核？主要做什么
什么是虚拟地址空间？由几个部分组成
并发和并行的区别，和顺序执行的区别
什么是线程级并行
什么是超线程
什么是指令级并行
什么是单指令、多数据并行
什么是指令集架构

# 回答1.2

千万倍，百倍。这表明如果需要从磁盘取指令来执行是慢的可怕的。
CPU上，几十MB，比 L2 快 5 倍；L2 通过特殊的总线与 CPU 相连，几百 MB<sub>几 GB，比主存快 5</sub>10 倍
把可能经常访问的数据放到高速缓存中
7层，用上一层做下一层的高速缓存
进程、虚拟内存、文件
系统正在执行的程序，系统在某一时刻只能执行一个进程
操作系统常驻主存的部分，负责管理进程的切换，方式是上下文切换。
进程看到的是一个虚拟的地址空间。从低到高依次是程序代码和数据、运行时堆、共享库、用户栈、内核虚拟内存
并发是交错执行，并行是同时执行，顺序是执行完一个再执行另一个
四个核一个核一个线程就是四线程并行，
超线程可以实现一个核两个线程。因为如PC、寄存器等硬件有多个备份，可以在一个线程需要等待拷贝的时候执行另一个线程。相当于充分利用硬件交错执行不同线程。
一个指令需要20多个时钟周期，并行后一秒可以执行2~4个指令
一个指令的几个简单操作并行执行（硬件层面）
一种抽象，看起来好像是指令顺序依次执行，实际上背地里是指令级并行。

堆排序

2026-05-19T14:38:26.000Z

# 堆排序

# 一、堆的知识点笔记

# 1. 堆的基本概念

堆是一种特殊的完全二叉树，通常用数组顺序存储。

堆有两个核心要求：

结构上必须是完全二叉树。
数值上要满足堆的大小关系。

大根堆要求：

父节点 >= 子节点

小根堆要求：

父节点 <= 子节点

大根堆的堆顶是最大值。
小根堆的堆顶是最小值。

# 2. 堆的数组下标关系

如果数组下标从 1 开始：

父节点 i
左孩子 2i
右孩子 2i + 1

如果数组下标从 0 开始：

父节点 (i - 1) / 2
左孩子 2i + 1
右孩子 2i + 2

考试中很多堆题默认下标从 1 开始。

# 3. 堆的插入操作

堆插入新元素时，不能指定位置插入。

标准流程是：

1. 新元素先放到堆的末尾
2. 和父节点比较
3. 如果不满足堆的性质，就向上调整

以大根堆为例：

如果新元素 > 父节点，就交换
如果新元素 <= 父节点，就停止

以小根堆为例：

如果新元素 < 父节点，就交换
如果新元素 >= 父节点，就停止

插入操作的调整方向是向上调整。

时间复杂度：

O(log n)

易错点：

最后一次判断“不需要交换”的比较也要算入关键字比较次数。

# 4. 堆的删除操作

堆最常见的删除操作是删除堆顶元素。

大根堆删除堆顶，就是删除最大值。
小根堆删除堆顶，就是删除最小值。

标准流程是：

1. 删除堆顶元素
2. 用最后一个元素补到堆顶
3. 从堆顶开始向下调整

为什么用最后一个元素补堆顶？

因为堆必须保持完全二叉树结构。
最后一个元素是最右下角的叶子结点，删除它不会破坏完全二叉树。

如果用堆顶的子结点补上去，中间会留下空洞，还要继续补空位，过程复杂，也不符合标准堆删除操作。

# 5. 删除后的向下调整

以大根堆为例，向下调整时：

1. 先比较左右孩子，选较大的孩子
2. 再让当前元素和较大的孩子比较
3. 如果当前元素小，就交换
4. 继续向下检查

以小根堆为例，向下调整时：

1. 先比较左右孩子，选较小的孩子
2. 再让当前元素和较小的孩子比较
3. 如果当前元素大，就交换
4. 继续向下检查

删除操作的调整方向通常是向下调整。

时间复杂度：

O(log n)

易错点：

向下调整中，最后一次判断“不需要交换”的比较也要算入关键字比较次数。

# 6. 大根堆能不能删除特定元素

可以删除，但不擅长。

如果只知道元素值，不知道位置，需要先查找该元素。

查找：O(n)
调整：O(log n)
整体：O(n)

如果已经知道该元素的位置，就可以：

1. 用最后一个元素替换该位置
2. 根据情况向上或向下调整

如果替换后的元素比父节点大，大根堆中要向上调整。
如果替换后的元素比孩子小，大根堆中要向下调整。

所以准确说：

堆不是不能删除特定元素，而是不擅长快速查找并删除特定元素。

# 7. 堆是否支持插入到特定位置

一般不支持。

堆的插入位置由完全二叉树结构决定，新元素必须先插入到最后一个位置。

堆不是按位置组织数据的，而是按优先级组织数据的。

所以堆关心的是：

堆顶最大或最小
父子之间满足大小关系
整体保持完全二叉树

它不关心某个元素必须放在哪个具体位置。

# 8. 建堆操作

建堆不是从第一个元素开始调，而是从最后一个非叶子结点开始调。

如果有 n 个元素，最后一个非叶子结点是：

n / 2

从这个位置开始，依次向前调整：

n/2, n/2 - 1, ..., 1

建堆的时间复杂度是：

O(n)

注意：

如果一个一个插入来建堆，复杂度是：

O(nlog n)

但堆排序中的建初始堆是自底向上调整，所以是：

O(n)

# 9. 堆排序

堆排序的基本流程是：

1. 建初始堆
2. 输出堆顶元素
3. 用最后一个元素补堆顶
4. 重新调整堆
5. 重复直到排序完成

如果要从小到大排序，通常使用大根堆。
每次把最大值放到数组末尾。

堆排序时间复杂度：

最好：O(nlog n)
平均：O(nlog n)
最坏：O(nlog n)

空间复杂度：

O(1)

稳定性：

不稳定

原因是堆排序中会发生远距离交换，相同关键字的相对顺序可能被改变。

# 10. 堆与 Top-K 问题

堆非常适合处理海量数据中的前 k 个数问题。

如果要选最大的 k 个数，用小根堆。

原因是：

小根堆堆顶是当前 k 个候选数中最小的数。
如果新数比堆顶还小，就没资格进入最大 k 个数。
如果新数比堆顶大，就替换堆顶，然后调整小根堆。

如果要选最小的 k 个数，用大根堆。

原因是：

大根堆堆顶是当前 k 个候选数中最大的数。
如果新数比堆顶还大，就没资格进入最小 k 个数。
如果新数比堆顶小，就替换堆顶，然后调整大根堆。

记忆：

选最大 k 个数，用小根堆
选最小 k 个数，用大根堆

堆顶保存的是当前结果中最容易被淘汰的那个元素。

# 二、做题整理

# 第 2 题

题目文字版

简单选择排序算法的比较次数和移动次数分别为（）。

A. O(n)，O(log₂n)
B. O(log₂n)，O(n²)
C. O(n²)，O(n)
D. O(nlog₂n)，O(n)

答案

[!NOTE]
解析

简单选择排序每一趟都要在未排序部分中找最小值。

比较次数为：
(n - 1) + (n - 2) + ... + 1 = O(n²)
但是每一趟最多只交换一次，所以移动次数是：
O(n)
所以答案是：
比较次数 O(n²)，移动次数 O(n)

# 第 5 题

题目文字版

在含有 n 个元素的小根堆中，下标从 1 开始，关键字最大的元素可能存储在（）位置。

A. n/2
B. n/2 + 2
C. 1
D. n/2 - 1

答案

[!NOTE]
解析

小根堆满足：
父节点 <= 子节点
所以堆顶一定是最小值。

关键字最大的元素一般只能出现在叶子结点中。

下标从 1 开始时：
1 到 n/2 是非叶子结点
n/2 + 1 到 n 是叶子结点
四个选项中，只有 n/2 + 2 属于叶子结点区域。

所以选：
B

# 第 7 题

题目文字版

构建 n 个记录的初始堆，其时间复杂度为（）；对 n 个记录进行堆排序，最坏情况下其时间复杂度为（）。

A. O(n)
B. O(n²)
C. O(log₂n)
D. O(nlog₂n)

答案

A，D

[!NOTE]
解析

构建初始堆不是一个一个插入，而是从最后一个非叶子结点开始向前调整。

所以建堆时间复杂度是：
O(n)
堆排序时，建堆之后要进行大约 n - 1 次删除堆顶和向下调整。

每次调整最多走堆的高度：
O(log₂n)
所以堆排序最坏时间复杂度是：
O(nlog₂n)

# 第 9 题

题目文字版

对由相同的 n 个整数构成的二叉排序树和小根堆，下列说法中不正确的是（）。

A. 二叉排序树的高度大于或等于小根堆的高度。
B. 对二叉排序树进行中序遍历可以得到从小到大的序列。
C. 从小根堆的根结点到任意叶结点的路径构成从小到大的序列。
D. 对小根堆进行层次遍历可以得到从小到大的序列。

答案

[!NOTE]
解析

A 正确。
小根堆是完全二叉树，结构最紧凑，所以高度较低。普通二叉排序树可能不平衡，高度大于或等于小根堆高度。

B 正确。
二叉排序树的中序遍历结果是递增序列。

C 正确。
小根堆满足：
父节点 <= 子节点
所以从根结点到叶结点的路径上，关键字是非递减的。

D 错误。
小根堆只保证父子之间有序，不保证层次遍历整体有序。

所以选：
D

# 第 11 题

题目文字版

对关键字序列：

23, 17, 72, 60, 25, 8, 68, 71, 52

进行堆排序，输出两个最小关键字后的剩余堆是（）。

A. {23, 72, 60, 25, 68, 71, 52}
B. {23, 25, 52, 60, 71, 72, 68}
C. {71, 25, 23, 52, 60, 72, 68}
D. {23, 25, 68, 52, 60, 72, 71}

答案

[!NOTE]
解析

要输出两个最小关键字，所以要建立小根堆。

原序列：
23, 17, 72, 60, 25, 8, 68, 71, 52
建成小根堆后：
8, 17, 23, 52, 25, 72, 68, 71, 60
第一次输出最小值 8。

用最后一个元素 60 补到堆顶：
60, 17, 23, 52, 25, 72, 68, 71
向下调整后：
17, 25, 23, 52, 60, 72, 68, 71
第二次输出最小值 17。

用最后一个元素 71 补到堆顶：
71, 25, 23, 52, 60, 72, 68
向下调整：
23, 25, 71, 52, 60, 72, 68
继续调整：
23, 25, 68, 52, 60, 72, 71
所以最终剩余堆是：
23, 25, 68, 52, 60, 72, 71
选：
D
注意，B 虽然也是一个合法小根堆，但它不是按照题目给定序列执行堆排序过程得到的结果。

# 第 16 题

题目文字版

已知序列：

25, 13, 10, 12, 9

是大根堆，在序列尾部插入新元素 18，再将其调整为大根堆，调整过程中元素之间进行的比较次数是（）。

A. 1
B. 2
C. 4
D. 图片中被笔迹遮挡，未辨清

答案

[!NOTE]
解析

原大根堆：
25, 13, 10, 12, 9
插入 18 后：
25, 13, 10, 12, 9, 18
18 的父节点是 10。

第一次比较：
18 和 10 比
因为：
18 > 10
所以交换：
25, 13, 18, 12, 9, 10
现在 18 的父节点是 25。

第二次比较：
18 和 25 比
因为：
18 < 25
满足大根堆，停止。

所以比较次数是：
2 次
这题容易漏掉最后一次“不需要交换”的比较。

# 第 17 题

题目文字版

已知小根堆为：

8, 15, 10, 21, 34, 16, 12

删除关键字 8 之后需重建堆，在此过程中，关键字之间的比较次数是（）。

A. 1
B. 2
C. 3
D. 4

答案

[!NOTE]
解析

删除堆顶 8，用最后一个元素 12 补到堆顶：
12, 15, 10, 21, 34, 16
开始向下调整。

第一次比较左右孩子：
15 和 10 比
较小的是 10。

第二次比较当前元素和较小孩子：
12 和 10 比
因为：
12 > 10
所以交换：
10, 15, 12, 21, 34, 16
现在 12 还有一个孩子 16。

第三次比较：
12 和 16 比
因为：
12 < 16
满足小根堆，停止。

所以比较次数是：
3 次
选：
C

# 第 18 题

题目文字版

将序列：

6, 1, 5, 9, 8, 4, 7

建成大根堆时，正确的序列变化过程是（）。

A. 6,1,7,9,8,4,5 → 6,9,7,1,8,4,5 → 9,6,7,1,8,4,5 → 9,8,7,1,6,4,5

B. 6,9,5,1,8,4,7 → 6,9,7,1,8,4,5 → 9,6,7,1,8,4,5 → 9,8,7,1,6,4,5

C. 6,9,5,1,8,4,7 → 9,6,5,1,8,4,7 → 9,6,7,1,8,4,5 → 9,8,7,1,6,4,5

D. 6,1,7,9,8,4,5 → 7,1,6,9,8,4,5 → 7,9,6,1,8,4,5 → 9,7,6,1,8,4,5 → ...

答案

[!NOTE]
解析

原序列：
6, 1, 5, 9, 8, 4, 7
一共有 7 个元素，最后一个非叶子结点是：
7 / 2 = 3
所以从第 3 个位置开始向前调整。

第一步，调整 5。

5 的孩子是 4 和 7，较大的是 7。

交换后：
6, 1, 7, 9, 8, 4, 5
第二步，调整 1。

1 的孩子是 9 和 8，较大的是 9。

交换后：
6, 9, 7, 1, 8, 4, 5
第三步，调整 6。

6 的孩子是 9 和 7，较大的是 9。

交换后：
9, 6, 7, 1, 8, 4, 5
此时 6 下沉到第 2 个位置，它还有孩子 1 和 8。

较大的是 8，继续交换：
9, 8, 7, 1, 6, 4, 5
所以正确变化过程是：
6,1,7,9,8,4,5
6,9,7,1,8,4,5
9,6,7,1,8,4,5
9,8,7,1,6,4,5
选：
A

# 三、今天最重要的易错点总结

堆插入时，新元素必须先放到末尾，然后向上调整。
堆删除堆顶时，必须用最后一个元素补到堆顶，然后向下调整。
建堆从最后一个非叶子结点开始，不是从根节点开始。
大根堆向下调整时，优先选较大的孩子。
小根堆向下调整时，优先选较小的孩子。
比较次数题中，最后一次判断“不交换”的比较也要算。
合法堆不唯一，但题目问算法过程时，必须按给定过程一步步调整。
选最大 k 个数用小根堆，选最小 k 个数用大根堆。

‍

Stefansky

CSAPP 第三章 程序的机器级表示

# CSAPP 第三章 程序的机器级表示

# 3.2 程序编码

# 3.2.1 机器级代码

# 3.2.2 代码示例

# 3.2.3 关于格式的注解

# 3.3 数据格式

# 3.4 访问信息

# 3.4.1 操作数指示符

# 3.4.2 数据传送指令

# 3.4.3 数据传送示例

# 3.4.4 压入和弹出栈数据

# 3.5 算术和逻辑操作

# 3.5.1 加载有效地址

# 3.5.2 一元和二元操作

# 3.5.3 移位操作

# 3.5.4 特殊的算术操作

# 3.6 控制

# 3.6.1 条件码

# 3.6.2 访问条件码

# 3.6.3 跳转指令

# 3.6.4 跳转指令的编码

# 3.6.5 用条件控制来实现条件分支

# 3.6.6 用条件传送来实现条件分支

# 3.6.7 循环

# 3.6.8 switch语句

# 3.7 过程

# 3.7.1 运行时栈

# 3.7.2 转移控制

# 3.7.3 数据传送

# 3.7.4 栈上的局部存储

# 3.7.5 寄存器中的局部存储空间

# 3.7.6 递归过程

# 3.8 数组分配和访问

# 3.8.1 基本原则

# 3.8.2 指针运算

# 3.8.3 嵌套的数组

# 3.8.4 定长数组

# 3.8.5 变长数组

# 3.9 异质的数据结构

# 3.9.1 结构

# 3.9.2 联合

# 3.9.3 数据对齐

# 3.10 在机器级程序中将控制与数据结合起来

# 3.10.1 理解指针

# 3.10.2 应用:使用GDB调试器

# 3.10.3 内存越界引用和缓冲区溢出

# 3.10.4 对抗缓冲区溢出攻击

# 3.10.5 支持变长栈帧

# 3.11 浮点代码

# 3.11.1 浮点传送和转换操作

# 3.11.2 过程中的浮点代码

# 3.11.3 浮点运算操作

# 3.11.4 定义和使用浮点常数

# 3.11.5 在浮点代码中使用位级操作

# 3.11.6 浮点比较操作

# 3.11.7 对浮点代码的观察结论

# 3.12 小结

CSAPP 第二章 信息的表示和处理

# CSAPP 第二章 信息的表示和处理

# 2.1 信息存储

# 2.1.1 十六进制表示法

# 2.1.2 字数据大小

# 2.1.3 寻址和字节顺序

# 2.1.4 表示字符串

# 2.1.5 表示代码

# 2.1.6 布尔代数

# 2.1.7 C 语言中的位级运算

# 2.1.8 C 语言中的逻辑运算

# 2.1.9 C 语言中的移位运算

# 2.2 整数表示

# 2.2.1 整数数据类型

# 2.2.2 无符号数的编码

# 2.2.3 补码编码

# 2.2.4 有符号数和无符号数之间的转换

# 2.2.5 C 语言中的有符号数和无符号数

# 2.2.6 扩展一个数字的位表示

# 2.2.7 截断数字

# 2.3 整数运算

CSAPP 第三章程序的机器级表示

# CSAPP 第三章程序的机器级表示

CSAPP 第二章信息的表示和处理

# CSAPP 第二章信息的表示和处理

CSAPP 第一章计算机系统漫游

# CSAPP 第一章计算机系统漫游