第1章：计算机的三大原则

1.1 计算机的三个根本性基础

1. 计算机是执行输入、运算、输出的机器
2. 程序是指令和数据的集合
3. 计算机的处理方式有时与人们的思维习惯不同

1.2 输入、运算、输出是硬件的基础

IC：Integrated Circuit「集成电路」

输入、 运算、 输出

1.3 软件是指令和数据的集合

代码清单 1.1 C 语言的程序示例片段

int a, b ,c;
a = 10;
b = 20;
c = Average(a, b);

将代码清单 1.1 的内容保存为 MyProg.c，编译后会生成可执行文件 MyProg.exe。
用文件查看器打开 MyProg.exe，会看到类似代码清单 1.2 的十六进制数值。

代码清单 1.2　机器语言的程序示例

C7 45 FC 01 00 00 00 C7 45 F8 02 00 00 00 8B 45
F8 50 8B 4D FC 51 E8 82 FF FF FF 83 C4 08 89 45
F4 8B 55 F4 52 68 1C 30 42 00 E8 B9 03 00 00 83

无论是哪个程序，其内容都是数值的罗列，每个数值要么是指令，要么是数据。

1.4 对计算机来说什么都是数字

计算机术语，如“文件句柄”、“公钥”和“私钥”，本质上都是数字。
尽管这与人类的思维习惯不同，但将所有信息都视为数字，能让计算机更高效地处理它们。

1.5 只要理解了三大原则，即使遇到难懂的最新技术，也能轻松应对

计算机是执行程序的机器。 程序是指令和数据的集合。
为了使互 联网上相互连接的计算机能通过程序协同工作，微软公司采用了 SOAP 以及 XML 规范。
SOAP 是关于调用指令的规范，XML 则是定义数据 格式的规范。

1.6 为了贴近人类，计算机在不断地进化

Windows XP 和 Office XP 末尾的 XP， 代表的就是 Experience（体验）。
面向组件编程：Component BasedProgramming
面向对象编程：Object Oriented Programming

1.7 稍微预习一下第2章

一台基本的计算机硬件，只需将 CPU、内存 和 I/O 用电路连接起来，并提供电源和时钟信号 即可。
时钟信号「内含晶振发出电信号」 由时钟发生器发出，其频率（如Pentium CPU，几百MHz到2GHz）决定了CPU的工作速度。

晶振：一种利用石英晶体（又称水晶）的压电效应产生高精度振荡频率的电子元 件。

第2章：试着制造一台计算机吧

2.0 计算机术语和概念

术语

• CPU：Central Processing Unit「中央处理器」
• PIO：Parallel Input/Output「并行输入/输出」
  • 它是由 Zilog 公司为 Z80 CPU 设计的一款配套芯片，主要作用是提供两个可编程的 8 位并行 I/O 端口，用于在 CPU 和外部设备（如键盘、打印机等）之间进行数据传输。
• RAM：Random-Access Memory「随机存取存储器」
• DRAM：Dynamic Random-Access Memory「动态随机存取存储器」
  • 它之所以被称为“动态（Dynamic）”，是因为它需要持续刷新来维持数据。每个 DRAM 单元都由一个电容器和一个晶体管组成。电容器会存储电荷来代表一个数据位（1 或 0），但电容器会随着时间慢慢漏电，因此需要每隔几毫秒就对其中的数据进行一次刷新（充电），以防止数据丢失。
• SRAM：Static Random-Access Memory「静态随机存取存储器」
  • DRAM 与 SRAM 的区别
    • DRAM (动态 RAM):
      • 特点： 需要刷新，结构简单，集成度高。
      • 优势： 成本低，容量大。
      • 用途： 主要用作电脑的主内存（即我们通常所说的“内存条”）。
    • SRAM (静态 RAM):
      • 特点： 无需刷新，结构复杂，集成度低。
      • 优势： 速度快，功耗低。
      • 用途： 主要用作 CPU 的高速缓存（Cache），因为速度对于缓存至关重要。
• DMA：Direct Memory Access「直接存储器访问」
• BUSRQ：Bus Request「总线请求」
• BUSAK：Bus Acknowledge「响应总线请求」
• Pull-up：上拉
• Address Bus：地址总线
• Data Bus：数据总线
• M1：Machine Cycle 1
• INT：Interrupt
• NC：No Connection「未连接 悬空」
• CE：Chip Enable「芯片选通」
• CS：Chip Select「片选」
• MT：Million Transfers per second「百万次传输/秒」
• ALU：Arithmetic Logic Unit 「算术逻辑单元」
• DDR：Double Data Rate「双倍数据速率」

CPU 的位数

CPU 的位数（或称位宽、字长）是一个系统性的概念，它主要由 CPU 内部核心部件的宽度共同决定，是其指令集架构 (ISA) 在底层设计中的体现。
我们可以从以下三个核心维度来理解和定义 CPU 的位数：

1. 核心决定因素：通用寄存器的宽度

结论： 我们通常所说的 CPU 位数（如 32 位、64 位），最直接、最核心的定义就是其 通用寄存器（General-Purpose Registers） 的宽度。

• 通用寄存器： 这是 CPU 内部用于暂时存放参与运算数据和指令地址的极高速存储单元。
  • 32 位 CPU： 拥有 32 位宽的寄存器（如 EAX、EBX寄存器），32 位寄存器 → 4 字节 的存储空间 → $2^{32}$ 不同的数值组合。
  • 64 位 CPU： 拥有 64 位宽的寄存器（如 RAX、RBX寄存器），64 位寄存器 → 8 字节 的存储空间 → $2^{64}$不同的数值组合。
  • CPU内部有多个这样的寄存器。

• 通用寄存器的总字节数： 以常见的x86-64架构为例，它有 16 个 核心的通用寄存器（RAX, RBX, RCX, RDX, RSP, RBP, RSI, RDI, R8-R15）。
  • 每个寄存器容量：8 字节
  • 总容量：16 寄存器 × 8 字节/寄存器 = 128 字节
  • 这 128 字节 是CPU最顶层、最快、无需访问缓存或内存就能直接使用的数据存储空间。
• 其他寄存器： 除了通用寄存器，CPU内部还有更多种类、数量庞大的寄存器，它们共同构成了CPU内部的存储空间。
  • 指令指针（RIP）：64位，存放下一条要执行的指令地址。
  • 标志寄存器（RFLAGS）：64位，存放运算结果的状态（如是否为0、是否溢出等）。
  • 浮点/向量寄存器：用于高性能计算，容量更大。
    • x87 FPU 寄存器：80位宽，有8个。
    • SSE/AVX 寄存器（如XMM0-XMM15, YMM0-YMM15）：
      • XMM寄存器：128位（16字节）
      • YMM寄存器：256位（32字节）
      • （在支持AVX-512的CPU上）ZMM寄存器：512位（64字节）

如果把这些所有类型的寄存器都加起来，总的 “寄存器空间” 会远大于通用寄存器的128字节，可能达到几千字节的量级。

2. 性能支撑因素：ALU 与数据总线的宽度

这两个部件的宽度必须与寄存器宽度协同一致，才能确保 CPU 的高效运行。

A. 算术逻辑单元（ALU）的宽度

• 作用： $\text{ALU}$ 是 CPU 中实际执行所有算术（加、减、乘、除）和逻辑（与、或、非）运算的部件。
• 匹配性： $\text{ALU}$ 的宽度必须与通用寄存器宽度匹配。一个 64 位的 $\text{ALU}$ 才能在一个时钟周期内完成 64 位数据的运算。如果 $\text{ALU}$ 宽度不足，数据需要拆分成多次运算，效率将大打折扣。

B. 数据总线的宽度

• 作用： 数据总线是 CPU 与内存等外部部件之间传输数据的通道。
• 影响： 它的宽度决定了 CPU 每次从内存中读取或写入的数据量（即数据吞吐量）。
• 理想状态： 为了达到最高效率，数据总线宽度应尽可能等于寄存器的宽度。例如，64 位 CPU 搭配 64 位数据总线，一次可传输 8 字节数据，实现高效的数据填充。

3. 限制性因素：地址总线的宽度

地址总线的宽度不直接定义 CPU 的位数，但它决定了 CPU 的寻址能力，即能访问的最大内存容量。

• 决定因素： 可寻址内存大小 = $2^{\text{(地址总线位数)}}$
• 32 位系统： 经典的 32 位 CPU 通常搭配 32 位地址总线，最大可寻址 $2^{32}$ 字节，即 4 GB 内存。
• 64 位系统： 64 位 CPU 的地址总线远超 32 位（实际实现通常为 48 位或 52 位），使其能够支持 $\text{TB}$ 级别的海量内存。

总结比喻：CPU 的位数就像一个工厂

CPU存储层次结构

一、 核心图示：存储金字塔

速度由快至慢，容量由小至大

      / \
     /   \   速度最快，成本最高
    /寄存器\   (CPU核心内部工作区)
   /-------\
  /  L1缓存 \   (每个核心的私人工作台)
 /-----------\
/    L2缓存   \  (每个核心的私人仓库)
------------- \
\    L3缓存    /  (所有核心共享的中央仓库)
 \-----------/
  \  内存   /    (主存，所有程序的工作区域)
   \------/
    \硬盘/       (永久存储，速度最慢)
     \ /

二、 详细对比表格

三、 关键知识点总结

1. 设计哲学：这个分层结构是基于局部性原理（时间和空间局部性），用较小的成本，在速度和容量之间取得最佳平衡。
2. 数据流：
   • 当CPU需要数据时，它按照 寄存器 → L1 → L2 → L3 → 内存 → 硬盘 的顺序逐级查找。
   • 找到数据后，会将其复制到上一级更快的存储中，以便后续快速访问。这个过程对程序是透明的。
3. 寄存器与缓存的本质区别：
   • 寄存器是运算部件，是CPU指令直接操作的对象。
   • 缓存是存储部件/缓冲区，目的是加速对内存的访问。
4. 缓存层级分工：
   • L1：追求极致速度，分为指令缓存和数据缓存，专核心专用。
   • L2：平衡速度和容量，作为L1的后备，专核心专用。
   • L3：追求大容量和共享，解决多核心数据同步与冲突问题，是内存前的最后一道屏障。
5. 性能影响：
   • 缓存命中率的高低直接决定了CPU的“实际工作效率”。缓存越大、越快，CPU“等待”数据的时间就越少，性能就越强。这就是为什么同架构的CPU，缓存大小是关键的性能指标。

计算机时钟频率

核心逻辑：同步与性能

1. 核心作用：系统的“统一节拍” CPU内部数十亿晶体管必须步调一致。确保所有部件在每一个“滴答”瞬间同步完成取指、计算或存取，防止逻辑出错。
2. 同步基准：协调多样频率 尽管 CPU、内存等组件工作速度不同，但它们都源于同一个基准时钟（BCLK）。这种同步机制确保了不同组件间数据交换的准确性。
3. 运行逻辑：频率不等于速度 主频（如 5.0GHz）代表每秒的周期数。但受限于架构，“一个时钟周期”不等于“执行一条指令”。
4. 效率关键：IPC（每周期指令数） 现代 CPU 利用流水线和超标量技术，能在一个周期内处理多条指令。IPC 是衡量架构先进程度的核心指标。
5. 性能判定公式：

性能由“节奏快慢”与“架构效率”共同决定。主频稍低但 IPC 极高的现代处理器，实际性能往往优于高主频的陈旧处理器。

逻辑流程图

graph LR
    A[基准时钟] --> B[统一节拍/同步]
    B --> C{CPU 最终性能}
    D[主频: 频率快慢] --> C
    E[IPC: 架构效率] --> C

硬件架构：从“中央集权”到“分布式”

逻辑链路图 (从物理震动到 C 语言信号)

graph TD
    A[晶振 25MHz] -->|原始信号| B[独立时钟发生器芯片]
    B -->|100MHz BCLK| C[CPU 内部]
    B -->|100MHz| D[PCIe/外设]
    B -->|100MHz| E[PCH 芯片组]

    subgraph CPU 核心
    C -->|PLL 倍频| F[工作主频 5GHz]
    C -->|分频计时| G[Local APIC Timer]
    C -->|计数器| H[TSC 时间戳]
    end
    
    G -->|硬件中断| I[OS 内核]
    I -->|软件信号| J[C 语言 SIGALRM]

术语演进：FSB (外频) vs BCLK (基频)

1. 外频 在现代硬件中被称为 BCLK (Base Clock)，是所有设备的基础同步时钟，标准值是 100 MHz
2. “基准频率”和“外频率”指的其实是同一个概念，即 BCLK (Base Clock)，但“外频”这个术语在过去更为常见
3. 现代计算机系统通过将内存控制器集成到 CPU 内部并使用点对点总线，实现了时钟域的解耦。因此，“外频” 这个描述总线速度的旧术语已经过时。“基准频率” (BCLK) 是更准确的名称，因为它代表了一个统一的时钟源，用于通过不同的倍率和分频器，生成 CPU 核心、内存和 I/O 等所有部件所需的工作频率。

CPU与内存频率

CPU 和内存的频率不同，但两者都以时钟发生器生成的基准频率为基础，通过各自的倍频/分频器工作。

1. CPU 核心频率

2. 内存工作频率

带宽计算中的「频率」与 DDR 技术

在计算内存带宽时，使用的频率必须是有效数据传输速率 (Data Rate)。

1. 带宽公式

2. 频率的实际意义（DDR 技术）

核心区别：时钟频率 vs. 有效数据速率
对于 DDR (Double Data Rate) 内存技术，我们需要区分两个关键数值：

1. 内存时钟频率（Clock Frequency）

• 定义： 这是内存芯片和内存总线实际的物理振荡频率，通常以 MHz 为单位。
• 示例： 对于 DDR4 3200 内存，其基础时钟频率是 $1600\text{ MHz}$。

2. 有效数据速率（Effective Data Rate / Transfer Rate）

• 定义： 这是内存每秒实际进行数据传输的次数，通常以 MT/s（Million Transfers per second，百万次传输/秒）为单位。
• DDR 技术： 因为 Double Data Rate（双倍数据速率），它在一个时钟周期内，通过时钟的上升沿和下降沿进行两次数据传输。
• 计算： 有效数据速率 = 内存时钟频率 $\times 2$
• 示例： $1600\text{ MHz}\times 2=3200\text{ MT/s}$。

术语的简化和约定

在市场营销和口语交流中，人们常常用 $\text{MT/s}$ 的数值来命名和指代内存，并习惯性地将其单位简化为 $\text{MHz}$，以方便计算带宽：

• 当人们说 "DDR4 3200" 时，这个 "3200" 指的就是它的有效数据速率（$3200\text{ MT/s}$）。
• 在带宽计算公式中，我们需要的正是这个每秒传输次数的数值。

计算机频率进阶与超频要点

1. 超频（Overclocking）基础

• 本质： 频率不是固定的，而是人为设定的。超频就是手动修改 $\text{CPU}$ 的倍频或基准频率 ($\text{BCLK}$)，将其工作频率拉高，以提高电脑性能。
• 公式： $\text{CPU}$ 核心频率 = 基准频率 $\times$ 倍频。

2. $\text{CPU}$ 超频策略（现代架构）

3. 内存与频率异步

• 内存频率来源： 现代内存频率通常由 $\text{BCLK}$ 经过一个特定的分频系数 (Ratio) 衍生而来。
• 异步运行 ($\text{Ratio}$)： 内存可以设置一个非整数倍的 $\text{Ratio}$，使其运行频率不必是 $\text{BCLK}$ 的整数倍。
  • 示例： 内存工作在 $\text{2133MHz}$ 或 $\text{2666MHz}$ 等非整数倍值，就是利用了这种高级的 $\text{Ratio}$ (分频比) 功能，实现了异步运作，以获得更高的带宽。

4. 显卡频率的独立性

• 不受 $\text{BCLK}$ 影响： 显卡（$\text{GPU}$）的核心频率和显存频率完全由其自身集成的时钟发生器控制。
• 时钟域隔离： 显卡频率是独立的时钟域，它不依赖于 $\text{CPU}$ 的基准频率 ($\text{BCLK}$) 或内存频率，因此可以随意设置，不需要是 $\text{BCLK}$ 的整数倍。

超频的核心限制因素

超频受到硬件本身的物理极限和系统支持能力的严格限制，主要集中在以下三个方面：

1. 硬件体质（芯片的物理极限）

这是决定超频幅度的最根本因素。

• 频率上限： 每个 $\text{CPU}$ 芯片的晶体管开关速度有其固有的物理上限，超过该频率，芯片就无法保证计算的正确性，导致系统崩溃。
• 耐压上限： 芯片能安全承受的最高电压是固定的。高电压会急剧增加热量和漏电，如果超出安全值，会永久性损坏 $\text{CPU}$ 寿命。

2. 散热能力（温度限制）

散热是超频最实际的障碍，因为更高的频率和电压必然产生更多热量。

• 温度墙： $\text{CPU}$ 有一个最高安全温度 ($\text{Tj}$ Max)。一旦核心温度触及此限制，$\text{CPU}$ 会自动触发热保护机制（降频），使超频失效，性能反而下降。
• 散热系统： 散热器（风冷或水冷）的效率直接决定了系统能承受的最大功耗。散热能力不足，超频就无法稳定运行。

3. 供电与主板设计（$\text{VRM}$ 限制）

主板的质量决定了能否为超频后的 $\text{CPU}$ 提供稳定、充足的电力。

• $\text{VRM}$ 供电能力： 主板上的电压调节模块 ($\text{VRM}$) 必须能够稳定地提供超频所需的大电流。$\text{VRM}$ 用料不足或散热不良会导致供电不稳或自身过热保护，限制超频。
• $\text{BIOS}$ 限制： 非高端的主板（如 $\text{Intel}$ 的 $\text{H}$/$\text{B}$ 系列芯片组）通常会在 $\text{BIOS}$ 中锁定倍频或 $\text{BCLK}$ 调节功能，从软件层面禁止超频。

简而言之： 芯片体质决定了你的理论上限；散热能力决定了你的实际运行上限；而主板供电则决定了你的稳定运行下限。

总线的定义

总线 是计算机内部多个部件之间共享的公共通信通道。它是一组信号线的集合，定义了各部件间传输信息的标准。

总线技术是计算机的“血液循环系统”

一、按总线所处的位置和功能分类（最核心的分类方式）

二、系统总线的细分（三总线结构）

三、常见外部总线（I/O总线）对比

四、按数据传输方式分类

总结笔记表格

存储容量：CPU 寻址能力 vs 内存芯片容量

存储容量的计算核心原则是：地址线决定单元数量，数据线决定单元位宽。 但这套原则应用在 CPU 和内存 IC 上，代表着不同的容量概念。

1. 核心概念对比

2. 场景一：CPU 的最大寻址能力（系统内存上限）

这是从系统宏观的角度，衡量 CPU 能控制的最大内存空间。

3. 场景二：内存芯片（IC）的物理容量

这是从芯片微观的角度，衡量单个内存 IC 的实际存储量。

存储器容量与引脚关系

1. 存储矩阵容量的物理限制

核心原理： 单个存储芯片（如 SRAM/DRAM）的存储矩阵容量不可能大于由其地址引脚和数据引脚决定的理论容量。

• 限制来源： 芯片的引脚是与外界交互的物理接口规格，它决定了芯片的寻址能力和数据传输宽度。

2. TC5517 示例（2K $\times$ 8）

芯片容量： 2048 个单元 $\times$ 8 位/单元 = 2KB。

• 地址引脚： $2^{11}=2048$ $⟹$ 需要 11 根地址引脚 ($A_0\sim A_{10}$)。
• 数据引脚： 8 位宽 $⟹$ 需要 8 根数据引脚 ($D_0\sim D_7$ )。
  存储位置： 程序和数据存储在芯片内部的存储矩阵中。引脚仅是传输地址和数据的通道。

3. 系统级容量扩展（突破单芯片限制）

在更大的计算机系统中，通过使用多片芯片并结合外部译码电路可以扩展总容量。

深度扩展（字扩展/级联）4K × 8（增加寻址单元数）

graph TD
    A11[地址线 A11] --> Decoder[地址译码器]
    Decoder --> CS1[片选 CS1]
    Decoder --> CS2[片选 CS2]
    
    A10_A0[地址线 A10-A0] --> Chip1[芯片1 2K×8]
    A10_A0 --> Chip2[芯片2 2K×8]
    
    CS1 --> Chip1
    CS2 --> Chip2
    
    Chip1 --> DB[数据总线 D7-D0]
    Chip2 --> DB
    
    subgraph "深度扩展结果"
        Result[4K × 8 内存]
    end

核心原理： 芯片分时工作，利用CPU提供的额外地址线来选择不同的芯片。

• 以 2 块 2K×8 芯片扩展成 4K×8 系统为例：
  • 2K=$2^{11}$，所以单个 2K×8 芯片需要 11根地址线（A10​∼A0​）来寻址其内部的 2048 个单元。
  • 目标系统是 4K×8，需要 4K=$2^{12}$，即需要 12根地址线（A11​∼A0​）。
  • 连接方式：
    1. 低位地址线 (A10​∼A0​) 并联到所有芯片的地址引脚上，用于选择芯片内部的单元。
    2. 高位地址线 (A11​) 接入一个地址译码器，该译码器的输出分别连接到两块芯片的片选引脚 ($\overline{CS}$) 上。
       • 当 A11​=0 时，译码器选中芯片1 ($\overline{CS1}$=0,$\overline{CS2}$=1)。
       • 当 A11​=1 时，译码器选中芯片2 ($\overline{CS1}$=1,$\overline{CS2}$=0)。
    3. 两块芯片的数据引脚 (D7​∼D0​) 并联后接上系统的数据总线。
  • 工作方式：
    • 任何时刻，只有一块芯片被片选信号选中（即处于工作状态），另一块芯片处于非工作状态（数据总线呈高阻态，不影响数据）。CPU通过 A11​ 来决定访问哪个 2K 的地址范围。
      • 高位地址A11通过译码器选择不同芯片
      • 低位地址A10-A0并行连接到所有芯片
      • 数据总线共享，通过片选信号隔离
      • 结果：2K×8 + 2K×8 = 4K×8

宽度扩展（位扩展/并联）2K × 16（增加数据总线宽度）

graph TD
    Addr[地址线 A10-A0] --> Chip1[芯片1 2K×8]
    Addr --> Chip2[芯片2 2K×8]
    
    CS[片选 CS] --> Chip1
    CS --> Chip2
    
    Chip1 --> DB_Low[数据总线 D7-D0]
    Chip2 --> DB_High[数据总线 D15-D8]
    
    subgraph "宽度扩展结果"
        Result[2K × 16 内存]
    end

核心原理： 芯片同时工作，每块芯片负责数据总线的不同位段。

• 以 2 块 2K×8 芯片扩展成 2K×16 系统为例：
  • 目标系统是 2K×16，其字数仍是 2K，只需要 11根地址线 (A10​∼A0​)。
  • 连接方式：
    1. 所有地址线 (A10​∼A0​) 并联到所有芯片的地址引脚上，以确保同时访问到两块芯片的同一个地址单元。
    2. 片选信号 ($\overline{CS}$) 并联到所有芯片的片选引脚上，使所有芯片同时被选中。
    3. 数据引脚连接到系统数据总线的不同位段：
       • 芯片1的 D7​∼D0​ 接系统数据总线的低8位 (D7​∼D0​)。
       • 芯片2的 D7​∼D0​ 接系统数据总线的高8位 (D15​∼D8​)。
  • 工作方式：
    • CPU存取一个16位数据时，片选信号同时选中两块芯片，向地址线发送一个地址，两块芯片同时读出或写入数据。芯片1负责低8位，芯片2负责高8位。
      • 所有地址线和控制线完全并联
      • 每个芯片负责数据总线的不同位段
      • 所有芯片同时被选中工作
      • 结果：2K × (8+8) = 2K × 16

核心区别总结

2.1 制作微型计算机所必需的元件

制作微型计算机需要三种基本元件：

• CPU：计算机的“大脑”，用于执行程序。
• 内存：用于存储程序和数据。
• I/O（输入/输出）：用于连接计算机与外部设备。

Z80 微型计算机的电路图

微型计算机元件

为了构建一台简单的微型计算机，我们使用了以下核心组件：

• Z80 CPU: 一款在8位计算机时代广泛应用的经典CPU。
• TC5517 内存: 容量为2KB（2 x 1024 字节），足以满足学习需求。
• Z80 PIO: 一种常与Z80 CPU搭配使用的并行输入/输出芯片，能一次性处理8位数据。

辅助元件

为了驱动 CPU 运转，还需要一个时钟发生器。该元件通过晶振产生时钟信号，这种“滴答”的电信号决定了CPU的运行速度。我们使用的时钟发生器频率为2.5MHz。
注意：这台微型计算机仅作为学习模型，不具备实用价值。

用于输入程序的装置也是必不可少的。

• 输入/输出设备：用指拨开关（如照片 2.1(a) 所示）作为输入装置来编写程序，用8个LED作为输出装置显示结果。
• 辅助元件：一些IC（如74367和7404）来增强外部设备连接的稳定性。
• 其他元件：
  • 电阻：单位：Ω（欧姆）用来控制电流（如照片 2.1(b) 所示），我们使用集成电阻来简化布线。
  • 电容：单位：F（法拉）用来储存电荷。
• 电源：需要一个能将220V交流电转换为5V直流电的开关式稳压电源。
  
  
  

2.2 电路图的读法

在电路图中，连接元件符号的直线代表导线。导线交叉但没有黑点，表示没有连接。只有在交叉处画上一个黑点，才代表此处是连接点。

为了简化电路图，+5V 和 0V 的连接会用专门的符号表示（如图 2.4），而不是直接画出导线。
IC 的引脚是从 1 开始递增按逆时针顺序编号的。数引脚时，需将 IC 上的正方向标志（如半圆形缺口）朝向左边。
举例来说， 带有 14 个引脚的 7404，其引脚序号就如图 2.5 所示。

在电路图中，IC 的引脚排列方式不受物理顺序的限制，而是根据布线方便来布局。
通常会在引脚旁边标注序号，并在IC的矩形符号中用缩写代号（例如：RD代表读取，WR代表写入）来表示引脚的功能。具体代号的含义会在布线时详细解释。

有的电路图会按照引脚的实际物理顺序来绘制，这种图被称为实物布线图。
为了便于理解，本书对部分引脚的功能代号进行了修改。例如，厂商资料中 TC5517 芯片的 OE（Output Enable，输出使能）引脚在这里被改为了 RD（Read，读取）。

2.3 连接电源、数据总线和地址总线

• Vcc = Voltage at the Common Collector（集电极公共电压）正电源输入，提供工作电压。
• GND = Ground（接地），是电路的共同参考点，通常为 0V。

开始布线

请用红铅笔在电路图上完成以下连接：

1. 电源连接：将 +5V 连接到 各个IC「Z80 CPU、TC5517、Z80 PIO、时钟发生器...」 的 Vcc 引脚，并将 0V 连接到它们的 GND 引脚。
2. 连接数据总线和地址总线：
   • 将 Z80 CPU 的 D0~D7 引脚连接到 TC5517 的 D0~D7 引脚。
   • 将 Z80 CPU 的 A0~A7 引脚连接到 TC5517 的 A0~A7 引脚。
   • 将 TC5517 的 A8~A10 引脚连接到 0V。

数字IC

• 工作原理：数字 IC 通过 0V（表示数字 0）和 +5V（表示数字 1）这两种电压来传输电信号，即以二进制形式收发信息。
• 信息单位：
  • 1 比特（bit）：表示 1 个二进制数（0 或 1），是信息的最小单位。
  • 1 字节（byte）：等于 8 比特，是信息的基本单位。本次制作的微型计算机就是一台 8 比特计算机。

给 IC 供电的 Vcc 和 GND 引脚电压是固定的（+5V 和 0V），而其他引脚的电压则在 +5V 和 0V 之间变化，以此传输信息。

CPU 的引脚作用

• 地址总线引脚（A0~A15）：Z80 CPU 共有 16 个地址总线引脚，可以寻址 $2^{16}=65536$ 个数据单元「可以寻址 65536 Byte(64KB)」。
  • A 表示 Address（地址）
• 数据总线引脚（D0~D7）：Z80 CPU 共有 8 个数据总线引脚，每次能输入输出 8 比特（1 字节）的数据。
  • D 表示 Data（数据）
  • 如果想要输入输出大于 8 比特的数据， 就要以 8 比特为单位切分这个数据。

• Z80 CPU是小端序：低位在前，高位在后。
  • 低位字节（Least Significant Byte, LSB）存储在较低的内存地址。
  • 高位字节（Most Significant Byte, MSB）存储在较高的内存地址。
  • 16 个地址总线引脚所能指定的地址共有 65536 个，用二进制 数表示的话就是 0000000000000000～1111111111111111。

Z80 CPU 地址总线与寻址容量

核心结论

Z80 CPU 地址引脚的单位是位 (bit)，而 CPU 寻址的最小单位是字节 (Byte)。这两者共同决定了系统的最大内存容量。

1. Z80 地址总线规格

2. 寻址单位：为什么是 Byte？

• 引脚单位：CPU 的地址引脚的单位是 位 (bit)。
• 寻址单位：在 Z80 及其绝大多数计算机架构中，最小的内存访问单位是 1 个字节 (Byte)。
• 原因：字节（8 bit）是计算机中存储和处理基本数据（如一个字符、一条指令操作码）的最小标准单元。因此，CPU 发出的每个地址编号都对应内存中的 $1\text{ Byte}$ 存储空间。

3. 最大寻址容量计算

地址总线决定了最多能寻址多少个单元，而寻址单位决定了每个单元有多大。

代入 Z80 的数值：

1. 确定地址引脚数

地址引脚（Address Pins，通常标记为 $A_0,A_1,A_2,\dots$）决定了芯片内部有多少个存储单元（或称字，Word）。

2. 确定数据引脚数

数据引脚（Data Pins，通常标记为 $D_0,D_1,D_2,\dots$）决定了每个存储单元可以存储的位数。

3. 计算容量

将两者相乘，得出总容量（以 $bit$ 为单位）。再除以 8，即可得出常用的字节（Byte）容量。

以 TC5517 芯片为例

我们以 TC5517（如 TC5517APL-10）为例，它是一款典型的 $2\text{K}\times 8\text{ bit}$ SRAM 芯片。

1. 确定数据结构：
   • 芯片规格通常表示为： $2\text{K}\times 8\text{ bit}$。
   • $\text{存储单元数 (字数)}=2\text{K}=2\times 1024=2048$ 个。
   • $\text{每个单元的位数}=8\text{ bit}$。
2. 计算地址引脚数 ($N$)：
   • 要表示 2048 个不同的地址，需要的地址引脚数为 $N$ 满足 $2^N=2048$。
   • $2^{10}=1024$
   • $2^{11}=2048$
   • 所以，$\text{地址引脚数}=11$ 个（即 $A_0$ 到 $A_{10}$）。
3. 确定数据引脚数 ($M$)：
   • 芯片可以直接存取 8 位数据，所以 $\text{数据引脚数}=8$ 个（即 $D_0$ 到 $D_7$）。
4. 计算容量：
   • 总位数容量 (bit): $$\text{容量}_{\text{bit}} = 2048 \times 8 = 16384 \text{ bit}$$
   • 总字节容量 (Byte): $$\text{容量}_{\text{Byte}} = \frac{16384}{8} = 2048 \text{ Byte} \quad \text{或} \quad 2\text{KB}$$
     在实际的计算机系统中，主内存（DRAM）通常由多片这样的芯片并行组合起来，以满足CPU地址总线和数据总线的宽度要求（例如，将多片 $\times 8$ bit 的芯片并联，组成一个 $\times 64$ bit 的内存条）。

内存芯片速率的计算

计算理论上的数据传输带宽或数据总线吞吐量：

关于「时钟频率」的精确性

在这个带宽计算公式中的频率，指的必须是数据总线在单位时间内传输数据的次数：

• 对于早期的系统： 这个频率通常与总线时钟频率 (Bus Clock) 相同。
• 对于现代内存（如 DDR SDRAM）： 现代内存技术（DDR, DDR2, DDR3, DDR4 等，DDR = Double Data Rate）在一个时钟周期内可以进行两次数据传输（时钟上升沿和下降沿）。因此，实际的数据传输速率 (Data Rate) 是时钟频率的两倍。

因此，公式应该为：

例如，如果一个 DDR4 内存的时钟频率是 $1600\text{ MHz}$，那么它的数据传输速率（等效频率）是 $1600\text{ MHz}\times 2=3200\text{ MT/s}$（Million Transfers per second，百万次传输/秒）。计算带宽时，应使用 $3200\text{ MHz}$。

示例计算（以 DDR4 内存条为例）

假设有一个现代内存模块（如 DDR4 3200）：

1. 数据总线宽度： 内存控制器到内存模块通常是 64 bit。
2. 数据传输速率： $3200\text{ MT/s}$（相当于 $3200\text{ MHz}$ 频率）。

这个结果 $25.6\text{ GB/s}$ 正是该内存模块的理论峰值带宽。

2.4 连接I/O

PIO 芯片概述

Z80 PIO 包含 4 个 CPU 可寻址的 8 位寄存器，分为 控制 和 数据 两类：

• 功能： 充当 Z80 CPU 与 外部设备 之间的并行数据接口。
• 连接能力： 提供 2 个独立 的 8 位 I/O 端口（端口 A 和 端口 B），最多可连接 2 个 外部设备（如图 2.7 所示）。
• 数据宽度： 每个端口都是一个 8 位 数据通道。
  

划有横线的引脚代号表示其在电压为 0V 时有效；没有横线的则在电压为 +5V 时有效。

内部 4 个寄存器及其作用

Z80 CPU 寻址机制（选中寄存器）

Z80 PIO 与 CPU 连接方法

1. 数据总线对接：将 Z80 PIO 的 D0～D7 数据引脚与 Z80 CPU 同名引脚直接相连，实现数据交换。
2. 地址线选择：
   • PIO 的 $B/\bar{A}$ 引脚接 CPU A0：A0=0 选端口A，A0=1 选端口B。
   • PIO 的 $C/\bar{D}$ 引脚接 CPU A1：A1=0 选数据寄存器，A1=1 选控制寄存器。
3. 地址空间：CPU 通过 A0～A1 的4种状态（00/01/10/11）选择PIO的4个寄存器。
4. 未用引脚处理：
   • CPU 的 A8～A15 地址线未使用，标记为 NC（No Connection，未连接）。
   • 输出引脚可悬空（NC），输入或双向引脚必须固定接 +5V 或 0V 避免悬空。

重点概念示例：控制 LED (输出)

以配置端口 B 为输出并控制 LED 为例：

1. 配置端口 B (控制)：
   • CPU 设置 A1A0=11（选中端口 B 控制寄存器）。
   • CPU 通过数据总线 写入 配置值（例如 C3H​），设定端口 B 为输出模式。
2. 输出数据 (数据)：
   • CPU 设置 A1A0=10（选中端口 B 数据寄存器）。
   • CPU 通过数据总线 写入 要输出的数据（例如 0FH​），该数据立即从端口 B 的 PB0∼PB7 引脚输出，控制 LED 状态。

Z80 PIO 与 CPU 连接简图

注： I/O 操作时，CPU 还会使用 IORQ​（I/O 请求）和 WR/RD（写/读）信号来完成总线操作时序。

PIO 连接到 RAM (TC5517/TC55617) 的原因：中断和数据处理

PIO 连接到 RAM（存储器芯片）并非是为了直接读写数据(PIO 不直接操作内存)，而是为了实现 中断处理 机制和数据暂存：

1. 中断向量（重要）

Z80 PIO 是一个支持中断的设备。当外部设备（如指拨开关）的状态发生变化时，PIO 可以向 CPU 发出中断请求 (INT)。

• 当 CPU 响应中断时，它会向 PIO 发送一个中断响应信号 (M1 和 IORQ​ 组合)。
• 此时，PIO 需要将一个中断向量（一个 8 位数值，用于指向中断服务程序的入口地址）放到数据总线 (D0−D7) 上。
• 这个中断向量本身是存储在PIO内部的（通过CPU初始化时写入）。在 Z80 的中断模式2(IM 2) 下，CPU 会使用这个向量来查阅 RAM 中的中断向量表，从而找到具体的中断服务程序的地址。
  因此，PIO 必须连接到数据总线上，而数据总线同时连接着 RAM，以确保在中断响应过程中，CPU 能从 RAM 正确获取程序地址。

2. 数据暂存和程序运行

虽然 PIO 不会主动直接操作 RAM，但 CPU 从 PIO 读取的输入数据最终要被 CPU 拿到内存中进行处理、比较或暂存，而 CPU 输出给 PIO 的数据也是从内存或内部寄存器中取出的。因此，作为整个数据总线上的设备，PIO 间接地参与了与 RAM 的交互过程。

所有设备间的数据流转（PIO→CPU→RAM 或 RAM→CPU→PIO）都依赖于这条总线

总结： PIO 连接到 CPU 是为了直接的 I/O 控制，而它与 RAM 的联系主要是通过共享数据总线来实现中断向量的传递和程序运行所需的数据流。

2.5 连接时钟信号

Z80 CPU 和 Z80 PIO 需共享时钟信号以同步工作。

• 连接方法：
  将时钟发生器的输出引脚（8号） 同时连接到 Z80 CPU 和 Z80 PIO 的 CLK (Clock) 引脚。在时钟信号线与+5V电源之间连接一个电阻，用于稳定和清理时钟信号波形。
• 题外话：
  计算机部件在时钟信号下的同步运作，可类比于19 世纪英国的查尔斯· 巴贝奇（Charles Babbage）设计的机械式分析机由齿轮驱动。若将其机械部件替换为电子元件，其同步工作的基本原理与现代计算机是相通的。

2.6 连接用于区分读写对象是内存还是I/O的引脚

连接内存(TC5517)和I/O(Z80 PIO)时，地址总线A0-A1冲突，需通过控制信号区分。

解决方案：使用CPU的专用请求引脚

• $\overline{MREQ}$ (内存请求)：CPU与内存传输数据时置0，否则为1
• $\overline{IORQ}$ (I/O请求)：CPU与I/O传输数据时置0，否则为1

具体连接：

1. 内存(TC5517)片选：将CPU的 $\overline{MREQ}$ 引脚连接至TC5517的 $\overline{CE}$ 引脚
   • $\overline{MREQ}=0$ 时激活内存芯片，$\overline{MREQ}=1$ 时隔离（高阻态）
2. I/O(Z80 PIO)片选：将CPU的 $\overline{IORQ}$ 引脚连接至Z80 PIO的 $\overline{CE}$ 和 $\overline{IORQ}$ 引脚
   • $\overline{IORQ}=0$ 时激活PIO芯片，$\overline{IORQ}=1$ 时隔离（高阻态）（两个引脚是因为这样更适用于多I/O场景）

数据方向控制：

• TC5517 (内存)：连接CPU的 $\overline{RD}$ (读/输入) 和 $\overline{WR}$ (写/输出) 引脚至内存同名引脚
• Z80 PIO (I/O)：仅连接CPU的 $\overline{RD}$ 引脚至PIO的 $\overline{RD}$ 引脚
  • $\overline{RD}=0$ 表示CPU从PIO输入数据
  • $\overline{RD}=1$ 表示CPU向PIO输出数据（通过数据总线）

2.7 连接剩余的控制引脚

CPU、内存和I/O上除地址/数据总线外的引脚统称为控制引脚，用于控制IC功能。

剩余控制引脚连接：

• M1：将Z80 CPU的 $\overline{M1}$ 引脚与Z80 PIO的 $\overline{M1}$ 引脚连接。
  • 功能：用于同步操作，标识机器周期的开始。
• INT：将Z80 CPU的 $\overline{INT}$ 引脚与Z80 PIO的 $\overline{INT}$ 引脚连接。
  • 功能：I/O（PIO）通过此引脚向CPU发送中断请求，强制CPU暂停当前程序，转去执行特定中断处理程序（详细机制见第4章）。
  • 核心概念：中断允许外部设备主动通知CPU处理紧急任务。
• WAIT：当这个引脚被拉低时，CPU 会进入等待状态，暂停执行指令，直到引脚恢复高电平。
• NMI：NMI 是 Non-Maskable Interrupt（不可屏蔽中断）。当这个引脚被拉低时，会触发一个最高优先级的中断，CPU 必须立即响应。
• HALT：当这个引脚被拉低时，CPU 会暂停执行，进入“暂停”状态。
• RFSH：用于刷新 DRAM 内存。

总结：
通过连接 $\overline{M1}$ 实现同步，连接 $\overline{INT}$ 使I/O能中断CPU流程。其他未提及控制引脚需根据具体电路需求处理。

RESET（重置）引脚操作：

1. 功能：将Z80 CPU的 $\overline{RESET}$ 引脚先置 0 再恢复 1，可使CPU重置并从内存0号地址重新开始执行指令。
2. 实现方式：通过按键开关电路实现：
   • 默认状态：$\overline{RESET}$ 引脚通过电阻上拉至 +5V（逻辑1）。
   • 按下按键：开关闭合，$\overline{RESET}$ 引脚被短接至 0V（逻辑0）。
   • 释放按键：开关断开，$\overline{RESET}$ 引脚恢复 +5V（逻辑1）。
3. 电阻作用：串联在+5V与开关之间，防止短路（避免开关按下时+5V与0V直接相连导致电源短路）。
4. 常见设计：这种“上拉电阻+开关接地”的结构是数字电路中实现复位、控制等功能的典型设计，广泛用于电路图中。
   

上拉电阻+开关接地详细解析

产生电流的条件

1. 有电压：就像水流需要有水压差一样，电流需要有电压差来驱动。
2. 有闭合回路：电流需要一个完整、不间断的路径来流动。

闭合回路的作用

闭合回路（Closed Circuit） 是电流得以流动的通路。
在闭合回路中，电子可以从电源负极出发，流经所有元件，最终回到电源正极，形成一个连续的循环。只有在这样的回路中，元件才能正常工作，例如灯泡发光、电机转动。

断开回路的作用

断开回路（Open Circuit） 是电流流动的中断。
断开回路通常由开关控制，它的主要作用是停止电流流动。当回路断开时，即使有电压存在，电子也无法形成完整的通路，因此电流为零。这使得我们可以安全地控制和关闭电路中的设备，避免不必要的能耗或危险。

电压降

电压降是指电流流经电路中的某个元件时，这个元件两端的电压会降低的现象。
当电流流过一个电阻时，电阻会消耗一部分电能，导致其两端的电压产生差异，这部分被消耗的电压就是电压降（Voltage Drop）。

要计算电阻的电压降，你不仅需要知道电阻值，还需要知道流经它的电流。仅仅提供电源电压和电阻值，我们无法直接计算电压降

电压降的计算遵循欧姆定律：
$V_{\mathrm{降}}=I\times R$

• $I$ 是流过电阻的电流。
• $R$ 是电阻的阻值。

简单来说：电阻只有在有电流流过时才会产生电压降，如果电流是0，那么电阻就相当于一根普通的导线，不消耗任何电压。

左图电路闭合时「有电流流过」：输入0

这幅图展示了如何将一个 逻辑0（0V） 输入到IC的引脚。

• 按键按下（开关闭合）：当你按下开关时，电路中产生了一个从 +5V 经过电阻，再通过开关到达 0V 的完整回路，根据欧姆定律计算出流过电阻的电流是$I=\frac{5V}{4700\Omega }\approx 0.00106A\approx 1.06mA$ 此时，电阻两端的电压降就是电源电压，为 5V。
• 防止短路的关键：如果这个电阻不存在，你按下开关的瞬间，+5V 会直接与 0V 连接在一起。这相当于在电源两极之间用一根没有电阻的导线直接相连，会产生巨大的短路电流，瞬间烧毁电源或电路。
• 电阻的作用：而有了这个电阻，它就像一个“限流阀”，将整个回路的电流限制在一个非常小的、安全的范围内。虽然 +5V 与 0V 被连接了，但因为有电阻的存在，不会发生危险的短路。此时，电流选择电阻这条通路流向 0V，IC引脚上的电压就被拉到了 0V，从而实现了输入0。

右图电路断开「无电流流过」：输入1

此时，电流无法形成回路，所以流过 4.7kΩ 电阻的电流为 0A。
这幅图展示了如何将一个 逻辑1（+5V） 输入到IC的引脚。

• 按键未按下（开关断开）：开关断开后，IC引脚与 0V 的通路被切断。
• 电阻的作用：此时，IC引脚通过电阻与 +5V 相连。由于IC引脚的输入阻抗非常高，几乎没有电流从 +5V 流向IC引脚。
  根据欧姆定律，电阻上没有电压降「$V\mathrm{降}=I\times R=0A\times 4.7k\Omega =0V$」，因此IC引脚上的电压和电源电压一样，就是 +5V，从而实现了输入1。

欧姆定律 (I=V/R)，
V (Voltage)：电压，单位是伏特（V）。可以理解为驱动电流流动的“电压力”或“势能差”。
I (Current)：电流，单位是安培（A）。表示单位时间内通过导体横截面的电荷量，即电荷流动的速率。
R (Resistance)：电阻，单位是欧姆（Ω）。表示导体对电流流动的阻碍能力。
当电阻 R 趋近于 0 时，通过的电流 I 将会急剧增大。这股巨大的、不受控制的电流会瞬间从电源流向地线，导致电源过载、发热，甚至烧毁电路板或电源本身。这就是我们所说的短路。

RESET 电路与自动上电复位：

电容在通电瞬间充电，使 $\overline{RESET}$ 引脚电压缓慢上升（暂保持低电平，不会立刻上 升到 +5V），充电完成后恢复高电平 +5V，实现自动复位。

• 总线与 DMA：
  • 总线：连接 CPU 数据、地址、控制引脚的总电路。
  • BUSRQ：置 0 时，CPU 与总线隔离（高阻态），允许外部设备直接访问内存（DMA）。
  • BUSAK：CPU 隔离后自动置 0，确认 DMA 就绪。需将 $\overline{BUSAK}$ 连接至 74367 的 $\overline{G1}$/$\overline{G2}$ 引脚（控制后续电路）。
• 未使用引脚处理：
  • 上拉（Pull-up）：将 $\overline{WAIT}$、$\overline{NMI}$ 引脚通过电阻接 +5V（逻辑1），便于后续扩展。
  • 悬空（NC）：$\overline{HALT}$、$\overline{ASTB}$ 等引脚不连接。
• Z80 PIO 外部连接：
  • PA0～PA7（PA 表示 Port A）、PB0～PB7（PB 表示 Port B）连接外部设备（如指拨开关和 LED）。
  • IEI 上拉至 +5V，其余引脚（IEO、$\overline{ASTB}$、ARDY、$\overline{BSTB}$、BRDY）悬空。
• 总结：
  • 计算机核心工作原理：CPU 在时钟同步下，从内存读取指令，处理数据，并与 I/O 设备交互。即使现代计算机，基础原理与此相同。

（注：74367 为总线驱动器，用于增强信号或扩展连接，具体功能后续说明。）

2.8 连接外部设备，通过DMA输入程序

元件连接与数据写入

1. 开关连接：
   • 数据开关：第一个指拨开关连接到内存 TC5517 的数据总线引脚 D0～D7。
   • 地址开关：第二个指拨开关连接到 TC5517 的地址总线引脚 A0～A7。
   • 写入控制：按键开关连接到 TC5517 的 $\overline{WE}$（写使能）引脚。
   • 内存状态：TC5517 的 $\overline{RD}$（读）引脚上拉到 +5V，$\overline{CE}$（片选）引脚连接到 0V。
2. 写入操作：拨动指拨开关设定地址和数据，按下按键开关即可将数据写入 TC5517。

隔离与 DMA 控制

1. 隔离需求：为防止程序执行时开关状态干扰电路，需要使用 74367 三态总线缓冲器进行隔离。
2. 74367 特性：
   • 导通：当控制引脚 $\overline{G1}$ 和 $\overline{G2}$ 同时为 0 时，信号通过。
   • 隔离：当 $\overline{G1}$ 和 $\overline{G2}$ 同时为 1 时，74367 与电路隔离。
3. DMA 启用：
   • 打开 Z80 CPU 的 $\overline{BUSRQ}$ 开关，CPU 进入 DMA 状态。
   • CPU 通过 $\overline{BUSAK}$（总线应答）引脚输出 0。
4. 控制布线：将 Z80 CPU 的 $\overline{BUSAK}$ 引脚连接到所有 74367 的 $\overline{G1}$ 和 $\overline{G2}$ 引脚上。这使得 CPU 进入 DMA 状态后，74367 导通，开关信号才能通过总线，实现通过 DMA 向内存写入数据。

2.9 连接用于输入输出的外部设备

Z80 PIO 输入/输出布线

数据输入（指拨开关）

用于从外部输入数据的指拨开关连接到 Z80 PIO 的 PA0～PA7 引脚。布线采用直接连接方式。

注意：不使用 74367目的是确保微型计算机在程序运行时能够实时地从指拨开关获取输入数据。

数据输出（LED）

用于向外部显示数据的 LED 连接到 Z80 PIO 的 PB0～PB7 引脚。

1. 连接方式： LED 必须通过电阻连接到 +5V。根据惯例，这个电路设计是：输入 0V 时点亮 LED，输入 +5V 时关闭 LED（如图 2.9 所示）。
2. 驱动 IC： LED 必须通过 7404 反相器 连接到 Z80 PIO。
3. 最终逻辑： 7404 的作用是反转电信号（0 变 1，1 变 0）。
   • 当 Z80 PIO 输出 0V (逻辑 0) 时，7404 将其反转为 +5V，LED 熄灭。
   • 当 Z80 PIO 输出 +5V (逻辑 1) 时，7404 将其反转为 0V，LED 点亮。
   • 这种设计实现了：Z80 PIO 输出 1 时 LED 点亮，输出 0 时 LED 熄灭。

IC 供电与未用引脚

所有集成电路（如 74367 和 7404）的 Vcc 引脚都必须连接到 +5V，而 GND 引脚连接到 0V。对于这些 IC 上未使用的引脚（标有 NC 或未连接的），可以选择空着不接，或将它们连接到 GND 上。

Z80 CPU、Z80 PIO、7404、LED 之间的数据输入输出

CPU 与外部设备交换数据的过程分为两个阶段：初始化配置 和 数据交换。

1. 初始化配置（设置端口工作模式）

在进行任何数据读写之前，CPU 必须通过 控制寄存器 来配置 PIO 端口的工作模式。

• 配置目标： 将端口 A 设置为输入模式（连接指拨开关），将端口 B 设置为输出模式（连接 LED）。

2. 数据交换（实际读写数据）

数据输入（从指拨开关到 CPU）

1. 外部输入： 指拨开关的状态（开/关）以电平形式直接反映在 Z80 PIO 的 PA0～PA7 引脚上。
2. CPU 寻址： Z80 CPU 将地址信号设置为 $\text{A1}=0$ 和 $\text{A0}=0$（即 I/O 地址 00），选中 端口 A 数据 寄存器。
3. CPU 读取： CPU 执行 $\text{IN}$（输入）指令。Z80 PIO 将当前 PA0-PA7 引脚上的电平状态读入端口 A 数据寄存器，然后通过 $\text{D0}$～$\text{D7}$ 数据总线发送给 CPU。
4. CPU 接收： CPU 接收这 8 位数据，存入其内部的通用寄存器中进行处理。

数据输出（从 CPU 到 PIO）

1. CPU 准备数据： CPU 在内部完成数据处理，生成一个 8 位输出值。
2. CPU 寻址： Z80 CPU 将地址信号设置为 $\text{A1}=1$ 和 $\text{A0}=0$（即 I/O 地址 10），选中 端口 B 数据 寄存器。
3. CPU 写入： CPU 执行 $\text{OUT}$（输出）指令。CPU 将其 8 位输出数据通过 $\text{D0}$～$\text{D7}$ 数据总线写入 Z80 PIO 的端口 B 数据寄存器。
4. PIO 输出： Z80 PIO 立即将端口 B 数据寄存器的值输出到 PB0～PB7 引脚上。

输出到 LED（从 PIO 到 LED）

数据从 Z80 PIO 的 PB 端口出来后，必须经过 7404 反相器才能驱动 LED，以实现正确的逻辑。

1. Z80 PIO 输出数据： PB 端口上的 8 位信号（$\text{+5V}$ 或 $\text{0V}$）代表了 CPU 希望 LED 呈现的状态（$1$ = 亮, $0$ = 灭）。
2. 7404 反相：
   • 每个 PB 引脚连接到 7404 反相器的一个输入端。
   • 7404 将接收到的信号反转。
     • PB = 1 (+5V) $\to$ 7404 输出 0V。
     • PB = 0 (0V) $\to$ 7404 输出 +5V。
3. 驱动 LED：
   • 7404 的输出端连接到 LED 的负极（经过电阻）。
   • 由于 LED 是连接到 +5V 上的（正极接 +5V），只有当负极电压拉低到 0V 时，电流才能流过 LED 并点亮它。
4. 最终结果： 7404 成功地将 CPU 的逻辑 1 转换成了 LED 所需的 0V 驱动信号，从而使得 CPU 发出 $1$ 时 LED 点亮，发出 $0$ 时 LED 熄灭。

2.10 输入测试程序并进行调试

好的，我将您提供的机器语言测试程序（代码清单 2.1）整理成表格形式。为了清晰展示，我将二进制地址和程序代码转换为更常用的十六进制表示，并保留了原始的二进制值作为参考。

代码清单 2.1：Z80 PIO 测试程序（机器语言）

1. 硬件组装后的启动状态

• 硬件就绪 ≠ 立即工作： 即使微型计算机的硬件（含 $\text{Z80 CPU}$ 和 $\text{Z80 PIO}$）已组装完成并接通电源，它仍不能执行任何操作。
• 根本原因： $\text{CPU}$ 必须要有 软件/程序 才能工作。

2. 编程语言的限制

• 唯一可执行语言： $\text{CPU}$ 只能直接解释执行一种语言，即由二进制数构成的机器语言（原生代码）。
• 高级语言不可用： 在此基础阶段，$\text{BASIC}$、$\text{C}$ 语言或 $\text{Java}$ 等高级语言无法直接使用。
• 程序构成： 程序是指令和数据的集合，以 8 比特（1 字节） 为单位存储在内存中。

3. 程序输入（人工加载机器码）流程

这里描述了将代码清单 2.1 所示的机器语言程序手动输入到内存中的过程：

4. 程序运行与功能

• 启动运行： 所有指令输入完成后，按下重置 $\text{CPU}$ 的按键开关。此时 $\text{DMA}$ 请求开关自动还原（关闭），程序开始执行。
• 程序功能： $\text{CPU}$ 开始执行内存中的测试程序。
• 测试结果： 通过拨动第 3 个指拨开关，可以实时控制连接到 $\text{Z80 PIO}$ 端口上的 $\text{LED}$ 的亮或灭状态。
• 特性： $\text{LED}$ 的状态会持续保持，时刻与指拨开关的状态同步，实现实时的 I/O 控制功能。
  

既然你提供了 TC5517（这是一个经典的 2K x 8 位 SRAM 芯片）的电路符号图，我们就以此为物理蓝图，还原“世”字存储的微观全过程。

存储实例：将“中”字写入 TC5517 (SRAM)

1. 编码转换：从“中”到电平信号

在存储开始前，CPU 已将“中”字转换为二进制序列（UTF-8 编码）。

• 目标数据：首字节 0xE4 (二进制 1110 0100)。
• 引脚对应：数据通过 D0 到 D7 引脚并行输入。
  • 高电平 (1)：D7, D6, D5, D2 引脚。
  • 低电平 (0)：D4, D3, D1, D0 引脚。
• 存储本质：“中”字并不整体存在，它被拆解为 0xE4, 0xB8, 0xAD 分别存储在三个连续地址中。

2. 寻址定位：物理映射逻辑

TC5517 拥有 16,384 个存储位元，划分为 2,048 个字节。为了降低功耗，该芯片采用高位定行的非对称架构：

3. 位宽并联与物理布线细节

选中“第 1 列”在物理层面并非单一动作，而是 8 个子阵列（Sub-arrays） 的同步协作：

• 8 组差分位线：因为 SRAM 单元是交叉耦合结构，每一列物理上包含一对位线（$BL$ 与 $\overline{BL}$）。
• 并联深度：选中“第 1 列”时，芯片同时激活了分布在 8 个子阵列中的 8 对差分位线，分别对应 D0-D7 数据引脚。

4. 存储过程：6T SRAM 的微观动作

SRAM 内部没有电容，数据依靠由 6 个晶体管 (6T) 组成的双稳态触发器锁存。
以写入 D7 位的“1”状态为例：

1. 行选通 (Row Activation)：Wordline 0 变为高电平，开启访问晶体管。
2. 强制翻转 (State Overwrite)：
   • 外部驱动电路将 $Bitline7$ 拉高，同时将 $\overline{Bitline7}$ 拉低。
   • 强大的电位差压过单元内部维持电流，像“跷跷板”一样将内部电路顶向“1”端。
3. 静态锁存 (Static Latching)：
   • 当写使能 ($\overline{WE}$) 瞬间拉低再拉高，Wordline 0 随之关闭。
   • 依靠内部反馈电路，只要 Vcc (24脚) 有电，该状态就永久锁存，无需刷新。

5. 控制信号时序总结

1. $\overline{CE}$ (Chip Enable)：拉低，激活芯片。
2. $\overline{WE}$ (Write Enable)：脉冲拉低，锁定数据。
3. $\overline{RD}$ (Read)：保持高电平，关闭读取路径。

📍 存储轨迹总结表 (地址 0x01 / 数据 0xE4)

第3章：体验一次手工汇编

3.1　从程序员的角度看硬件

在进行手工汇编之前，需要了解以下 7 种核心硬件信息：
CPU 种类、时钟频率、内存地址空间、内存存储大小、I/O 种类、I/O 地址空间、连接的周边设备。

一、中央处理器 (CPU) 信息

1. CPU 种类： Z80 CPU。
2. 机器语言： 适用于 Z80 的机器语言（原生代码），由 0 和 1 构成，CPU 可直接理解和执行。
3. 时钟频率： 2.5 MHz (兆赫兹)。
   • 用于估算指令执行时间，一条指令的时钟周期数取决于其类型。

二、内存信息

1. 地址空间： $0\sim 255$（共 256 个地址）。
2. 存储单位： 每个地址可存储 8 比特（1 字节）的指令或数据。
3. 特性： 内存中所有地址的功能相同，均可用于存储指令和数据。

三、I/O (输入/输出) 信息

1. I/O 芯片： 仅安装了一个 Z80 PIO 芯片。
2. 内部结构： PIO 内部带有 4 个 8 比特寄存器。
3. I/O 地址空间： $0\sim 3$（共 4 个地址）。
4. I/O 特性： I/O 中不同地址（寄存器）对应不同功能，用于控制 PIO 功能或进行数据传输。
5. 寄存器分配与连接：
   • 0 号地址： 端口 A 数据寄存器（连接指拨开关 $\to$ 数据输入）。
   • 1 号地址： 端口 B 数据寄存器（连接 LED $\to$ 数据输出）。
   • 2 号地址： 端口 A 控制寄存器（用于设定 PIO 功能）。
   • 3 号地址： 端口 B 控制寄存器（用于设定 PIO 功能）。

3.2　机器语言和汇编语言

代码清单 3.1，这段机器语言程序的功能可以精简地总结为：
程序读取指拨开关的输入数据，并将其直接、原封不动地输出给 LED。
简单来说，它的作用就是让拨动指拨开关能立即控制对应 LED 的亮或灭，实现输入和输出的直接映射。

代码清单 3.1　点亮 LED 的机器语言程序

机器语言到汇编语言的过渡

这段文字描述了从难以理解的机器语言（纯粹的 0 和 1）到更具可读性的汇编语言的转变。

• 问题所在： 机器语言（0 和 1 的组合）虽然能被 CPU 执行，但对人来说难以理解和记忆其含义。
• 解决方案： 引入汇编语言，它使用类似英语单词的助记符（如 LD, OUT, IN, JP）来代表机器指令，使编程更易读。
• 本质关系： 汇编语言和机器语言实现的功能完全相同；汇编语言是机器语言的符号化表示。
• 汇编语法： 语法非常简单，由标签、操作码（指令）、操作数（指令对象） 三部分并排组成。
• 意义： 理解汇编语言，就相当于理解了机器语言，从而理解了计算机最原始的工作方式。

汇编语言是将机器语言（0 和 1）符号化的编程方式。它使用类似英文的助记符（操作码）。
其语法极为简单，每行只包含三部分：标签、操作码（指令） 和操作数（指令对象）。

代码清单 3.2　汇编语言代码

汇编语言核心概念

1. 汇编语言的三个要素

• 标签 (Label): 作用是给代码对应的内存地址起一个名称（如 LOOP:），用来代替难以记忆的地址，便于跳转和引用。
• 操作码 (Opcode): 表示“做什么”的指令，是指令功能的助记符（如 LD 是 Load 的缩写）。Z80 CPU 有大约 70 条指令，功能主要分为运算、内存 I/O、I/O（对应计算机的输入、运算、输出）。
• 操作数 (Operand): 表示指令执行的对象（“作用到什么上”）。它可以是寄存器、地址或数字。多操作数用逗号分隔；有些指令（如 HALT）不需要操作数。

2. 语法和数据

• 语法结构: 汇编语句类似于英语祈使句。操作码像动词（做什么），操作数像宾语（作用于谁）。
• 数据表示:
  • 十进制数: 直接写数字（如 123）。
  • 十六进制数: 在数字末尾加 H（如 123H）（H 表示 Hexadecimal， 即十六进制数）。

3. I/O 访问机制

• Z80 CPU 利用专门的引脚来区分内存和 I/O 设备的访问。
• 执行内存读写指令（如 LD）时，$\overline{MREQ}$ 引脚变为 $0$，访问内存。
• 执行I/O 读写指令（如 IN, OUT）时，$\overline{IORQ}$ 引脚变为 $0$，访问 I/O 设备。
  

3.3　Z80 CPU 的寄存器结构

CPU、内存与 I/O

• CPU：负责解释和执行程序，进行数据运算。
• 内存：存放程序，程序是指令和数据的集合。
• I/O：临时存放与外部设备进行输入输出的数据。

Z80 CPU 寄存器

• 寄存器是 CPU 内部存储数据的地方，不仅能存储，还能进行运算。
• 大小：
  • 16 比特：IX、IY、SP、PC。
  • 8 比特：A、B、C、D、E、F、H、L 等。
• 主要寄存器用途：
  • A(Accumulator 累加器)：运算核心。
  • F (Flags Register 标志寄存器)：存储运算结果的状态，如进位或比较结果。
  • PC (Program Counter 程序计数器/程序指针)：存储下一条要执行的指令地址，自动更新以驱动程序运行。
  • SP (Stack Pointer栈顶指针)：用于在内存中创建临时数据存储区域（栈）。

汇编语言基础

• 操作数：汇编语言规定，指令的操作数必须是已存储在 CPU 寄存器中的数字，不能直接使用常数。
• 指令示例：
  • LD A, 207：将数字 207 读入到寄存器 A 中。
  • OUT (2), A：将寄存器 A 中的数据写入到地址为 2 的 I/O 端口。
  • IN A, (0)：将地址为 0 的 I/O 端口数据输入到寄存器 A 中。
  • JP LOOP：无条件跳转指令，使程序流程跳转到名为 LOOP 的标签处。

Z80 PIO 编程示例

这个示例程序分为两部分：设定 Z80 PIO 和 与 Z80 PIO 进行输入输出。

1. 设定 Z80 PIO

• 端口 A (输入模式)：用于接收指拨开关的数据。
  • LD A, 207
  • OUT (2), A
  • LD A, 255
  • OUT (2), A
  • 通过向地址 2 的控制寄存器写入 207 和 255，将端口 A 设定为输入模式。
• 端口 B (输出模式)：用于向 LED 输出数据。
  • LD A, 207
  • OUT (3), A
  • LD A, 0
  • OUT (3), A
  • 通过向地址 3 的控制寄存器写入 207 和 0，将端口 B 设定为输出模式。

2. 与 Z80 PIO 进行输入输出 (死循环)

• 程序进入一个死循环 LOOP，将指拨开关的数据读取后输出到 LED。
  • LOOP: IN A, (0)：从端口 A (地址 0) 读取数据到寄存器 A。
  • OUT (1), A：将寄存器 A 的数据输出到端口 B (地址 1)。
  • JP LOOP：跳转回 LOOP 标签处，形成循环。
• 标签 (LOOP:)：用来代替内存地址，方便编程。在设定时需要加冒号，在 JP 指令中使用时不需要。

3.4　追踪程序的运行过程

代码清单 3.3 汇编语言与机器语言的对应关系

汇编语言与机器语言

• 机器语言是 CPU 唯一能直接理解和执行的编程语言。
• 转换关系：用汇编语言编写的程序必须先转换成机器语言才能运行。
• 指令长度：
  • 一条汇编语言指令转换成的机器语言可以由一个或多个字节构成。
  • 机器语言的字节数取决于指令的种类和操作数的个数。

程序执行流程 (PC 寄存器的作用)

程序运行的核心在于 PC (程序指针) 寄存器，它控制了程序的流程。

1. CPU 重置：CPU 自动将程序的起始地址（如 $00000000$）存储到 PC 寄存器中。
2. 读取指令：CPU 从 PC 寄存器指示的内存地址读出机器语言（指令）。
3. 判断长度并读取操作数：CPU 根据读取的第一个字节判断该指令的完整长度（可能是一个字节，也可能是多个字节），并从后续地址读出所有构成该指令的数据（如操作数）。
4. 解释和执行：CPU 汇集完整的机器语言数据，并执行对应的操作（例如：将数值 $207$ 写入寄存器 $\text{A}$）。
5. 更新 PC 寄存器：PC 寄存器的值自动增加读取指令所占用的内存地址数（字节数）。例如，如果指令是 2 字节，PC 值就 $+2$，指向下一条指令的起始地址。
6. 循环执行：CPU 不断重复“读取指令” $\to$ “解释、执行指令” $\to$ “更新 $\text{PC}$ 寄存器的值”这三个操作，程序便持续运行。
7. 跳转指令 ($\text{JP}$)：当执行到跳转指令（如 $\text{JP LOOP}$）时，$\text{PC}$ 寄存器的值不会自动增加，而是被直接设置为标签（$\text{LOOP}$）对应的目标地址（例如 $00010000$），从而实现循环或流程控制。

3.5　尝试手工汇编

手工汇编就是逐行对照 CPU 资料（包含助记符及其对应的机器语言数值），将汇编语言程序手工翻译成机器语言程序的过程。

表 3.2 从助记符到机器语言的转换方法

关键概念：数据存储顺序 (Endianness)

• 大端序 (Big Endian)：
  • 顺序： 数据从高位到低位顺序存储到内存。
  • 记忆： 像阅读习惯一样，高位（大头）在前。
• 小端序 (Little Endian)：
  • 顺序： 数据从低 8 位在前、高 8 位在后（逆序存储）。
  • Z80 特性： Z80 CPU 采用小端序。

代码清单3.3 手工汇编过程总结

核心步骤

1. 指令匹配与替换： 将汇编指令匹配到对应的机器语言模式（如 LD A, num 匹配 00111110 num）。
2. 数值转换： 将十进制的操作数（如 207）转换为 8 比特二进制数（如 11001111）替换模式中的 num。
3. 地址确定：
   • 每条指令的机器码占用多少字节，内存地址就相应增加多少。
   • JP (跳转) 指令的地址操作数需要用 16 比特表示（高 8 位补 0）。
4. 小端序存储（Z80 特有）： 在存储多字节数据（如 16 比特地址）时，采用小端序（低 8 位在前，高 8 位在后）的逆序存储方式。

关键示例

• LD A, 207 $\to$ 00111110 11001111
• OUT (2), A $\to$ 11010011 00000010
• JP LOOP $\to$ 11000011 00010000 00000000 (地址 00000000 00010000 逆序存储)

简而言之： 手工汇编通过查表、将十进制操作数转为二进制并替换到机器码模式中，然后按指令长度递增地址，最后按照 CPU 特有的大小端序规则（此处为小端序）存储多字节数据。

3.6　尝试估算程序的执行时间

利用时钟周期数和CPU 时钟频率来估算汇编程序代码的执行时间。

核心步骤与概念

1. 统计时钟周期数：
   • 查阅指令集资料（如表 3.2），找出每条指令执行所需的时钟周期数。
   • 将程序中所有指令的周期数累加，得到程序段的总周期数。
   • 示例：
     • LOOP 标签前 8 条指令：$7+11+7+11+7+11+7+11=\mathbf{72}$ 个周期。
     • LOOP 标签后 3 条指令：$11+11+10=\mathbf{32}$ 个周期。
2. 计算单个周期时间：
   • 时钟频率： 微型计算机使用 $2.5\text{MHz}$ 晶振，即每秒 $2,500,000$ 个周期。
   • 单个周期时间： $1\text{ 秒}÷2,500,000\text{ 次/秒}=0.0000004\text{ 秒}=\mathbf{0.4}\text{ 微秒}$。
3. 计算程序执行时间：
   • 总周期数 $\times$ 单个周期时间 = 执行时间。
   • 示例：
     • $72\text{ 个周期}\times 0.4\text{ 微秒/周期}=\mathbf{28.8}\text{ 微秒}$。
     • $32\text{ 个周期}\times 0.4\text{ 微秒/周期}=\mathbf{12.8}\text{ 微秒}$ (LOOP 段)。

循环执行频率估算

• 计算频率： $1\text{ 秒}÷\text{LOOP 段执行时间}=\text{每秒执行次数}$
• 示例： $1\text{ 秒}÷12.8\text{ 微秒/次}=\mathbf{78}\mathbf{,}\mathbf{125}\text{ 次/秒}$。

结论： 通过累加指令的时钟周期数并结合 CPU 时钟频率，可以精确估算出程序的执行时间，凸显了计算机惊人的运算速度。

第4章：程序像河水一样流动着

程序是“流动着的”

• 原因： 作为计算机“大脑”的 CPU 在同一时刻只能解释和执行一条指令。
• 程序本质： 程序是由指令和数据按顺序排列而成（如同排在长纸带上）。
• 流程形成： CPU 从头到尾依次解释和执行纸带上的每一条指令时，程序看起来就像沿着纸带 “流动” 起来了。
• 结论： 这种指令顺序执行的现象被称为程序的流程。

• 简而言之： 程序被称为“流动着的”，是因为 CPU 逐条解释和执行程序中按序排列的指令，形成了类似于水流方向的执行路径，这就是程序的流程。

4.1　程序的流程分为三种

顺序执行 (Sequential Execution)

CPU 的执行流程

• CPU 配合时钟信号（由时钟发生器发出），从内存中读出指令，然后依次进行解释和执行。

顺序执行机制：PC 寄存器

• PC (Program Counter 程序计数器) 寄存器： CPU 中的一个关键寄存器，其职责是存储下一条即将执行的指令的内存地址。
• 顺序执行 (Sequential Execution)：
  • 每当 CPU 执行完一条指令，PC 寄存器的值就会自动更新为下一条指令的地址。
  • 程序通常从低地址（小的地址编号）开始，向高地址流动。
  • 示例： 一条 3 字节的指令从地址 10 开始执行后，PC 的值会从 10 自动更新为 10+3=13，指向下一条指令。

条件分支 (Conditional Branch)

• 定义： 流程根据若干个条件的成立与否，产生不同的执行路径，只执行其中一条。
• 比喻： 犹如水流分出了支流。
• 特殊类型： 无条件分支（如泥石流），即不依赖任何条件直接跳转到特定位置，可视为一种特殊的条件分支。

循环 (Loop)

• 定义： 程序的流程在特定范围内反复执行指令，直到满足退出条件。
• 比喻： 犹如水流卷成漩涡。

4.2　用流程图表示程序的流程

1. 流程图的定义与价值

• 定义： 流程图是表示程序流程（Flow）的图表（Chart），用于以无论谁都能明白的方式表示程序逻辑。
• 价值： 它是专业程序员在编写代码前思考程序流程的关键工具。
• 独立性： 流程图不依赖于特定的编程语言。同一个流程图可以转换为 VBScript、C 语言或 Java 等任何语言的程序。
  • 观点： 编程语言只是将流程图上的流程用文字（程序）重现出来。

2. 流程图的基本构成和图示方法

流程图仅需少数基础符号就能表达所有程序逻辑。

1. 顺序执行： 用直线将矩形框依次连接起来。
2. 条件分支： 使用菱形（判断框），根据判断结果引出两条或多条分支流程。
3. 循环 (Loop)： 通过使用菱形（条件判断），将流程指引回前面的处理步骤，形成回路。
   

4. 结论

• 程序员必须学会灵活运用流程图。
• 在思考程序流程时，应首先在头脑中画出流程图。

4.3　表示循环程序块的“帽子”和“短裤”

帽子和短裤

在某些流程图标准（可能常见于信息技术水平考试）中，表示循环结构的一种特殊符号表示法。

1. 循环的特殊符号

• 符号组合： 用一对特殊的符号来表示循环结构的开始和结束。
• 非正式名称： 描述者将这对符号形象地称为 “帽子”形状的符号 和 “短裤”形状的符号。
• 用途： “帽子” 和 “短裤” 符号用于将需要反复执行的处理步骤（即循环体）包围起来。

2. 区分嵌套循环的规则

• 成对出现： “帽子”和“短裤”必须成对出现，并且要通过写上相同的名字（Label/Name）来表示它们属于同一个循环。
• 嵌套： 如果程序中存在循环嵌套（一个循环在另一个循环内部），则必须为每一对“帽子”和“短裤”分别起不同的名字，以明确区分它们属于哪个循环。
• 目的： 确保即使流程图复杂或存在嵌套，也能清晰地识别出哪个“帽子”对应哪个“短裤”，从而确定循环的范围和边界。

核心总结： 某些流程图使用成对的“帽子”和“短裤”符号来界定循环体。为了处理循环嵌套问题，必须在每对符号上标记不同的名称以明确匹配关系。

「程序块」和流程图的「帽子与短裤」符号

1. 硬件层面的循环实现（机器语言/汇编语言）

• 本质： 循环是通过跳转指令（如 JP）实现的。
• 机制： 利用跳转指令将 PC 寄存器（程序计数器）的值设置为之前执行过的指令的内存地址，从而让流程返回并重新执行。
• 结构：
  1. 执行比较指令（判断循环条件）。
  2. 根据比较结果（是否满足条件），执行跳转指令返回到前面的地址。
• 流程图表示： 使用菱形（条件判断）和流程线回指的简单结构（如图 4.5(c)）。

2. 高级语言的循环实现（程序块）

• 目的： 提高编程效率，让程序员不必直接处理跳转地址。
• 机制： 使用 程序块（Code Block） 概念来表示循环体，将需要反复执行的代码集合在一起。
• 流程图符号： 适用于高级语言的流程图使用 帽子和短裤 符号来界定程序块的范围（如图 4.6）。

代码清单 4.2　用高级语言表示循环

' 进行 5 轮比试
For i = 1 To 5  ————— 相当于 “帽子”
    ' 处理步骤
    ...
Next            ————— 相当于 “短裤”

核心总结：

• 硬件/低级语言通过 比较 + 跳转指令 强制 PC 寄存器回跳来实现循环。
• 高级语言通过 程序块（如 VBScript 的 For/Next）来抽象循环逻辑，流程图中的 “帽子和短裤” 符号正是用来表示这种程序块结构。

条件分支与循环在软硬件中的实现总结

1. 硬件层面的实现（汇编/机器语言）

在直接操作硬件的低级语言中，条件分支和循环都通过同一个基本机制实现：跳转指令。

• 机制： 先执行比较指令，再根据比较结果，使用跳转指令设置 PC 寄存器的值。
• 循环： 根据比较结果，跳转到之前执行过的内存地址。
• 条件分支： 根据比较结果，跳转到之后尚未执行的某个内存地址，跳过中间的代码块（如图 4.10 所示）。

2. 高级语言的实现（程序块）

在高级语言中，这些结构被抽象为程序块，提高了可读性和编程效率。

• 循环： 使用 For/Next 等关键字表示的程序块（对应流程图中的“帽子和短裤”）。
• 条件分支： 使用 If/ElseIf/Else/End If 等关键字表示的程序块（如 VBScript 代码清单 4.3）。
  • 流程： 流程根据 If 或 ElseIf 后的条件是否成立，选择执行程序块内的唯一一个区域（区域 1、区域 2 或 区域 3），形成分支。
  • 流程图表示： 使用菱形符号（判断框）表示这种分支逻辑。

代码片段 4.3 用高级语言表示的条件分支

' 判定胜负，显示结果
If use = computer Then
    MsgBox s & "...平局！"    ' 区域 (1) - 平局
ElseIf computer = (user + 1) Mod 3 Then
    MsgBox s & "...玩家获胜！" ' 区域 (2) - 玩家获胜
    wins = wins + 1
Else
    MsgBox s & "...计算机获胜！" ' 区域 (3) - 计算机获胜
End If

核心总结

无论是循环还是条件分支，其在硬件上的本质都是通过跳转指令改变程序流程；但在高级语言中，它们被抽象为易于理解和编写的 For/Next 或 If/ElseIf/End If 等程序块结构。

4.4　结构化程序设计

结构化程序设计与“GoTo 有害论”

1. 结构化程序设计的核心思想

• 提倡者： 戴克斯特拉（Dijkstra）。
• 定义： 一种编程风格，旨在将程序编写得具备结构性和清晰性。
• 实现原则：
  1. 仅使用三种基本流程：顺序执行、条件分支和循环。
  2. 不再使用相当于机器语言跳转指令的语句（如 GoTo）。

2. 为什么弃用跳转指令 (GoTo 有害)

• 危害性： 跳转指令会使程序的流程变得错综复杂、难以追踪，陷入“意大利面条”（Spaghetti Code）的状态（如图 4.11）。
• 高级语言的作用： 虽然硬件（如 CPU）本质上仍通过跳转指令实现流程控制，但高级语言（如 VBScript, BASIC）提供了程序块来抽象这些流程，使得程序员可以避免直接使用有害的 GoTo 语句。
  

3. 结构化流程与程序块

程序块是结构化程序设计的基础：

(1) 旧版本的 Visual Basic 用跳转指令（GoTo 语句）实现错误处理

On Error GoTo ERR_HANDLER
' ...
' 做某些处理
' ...

' ---------------------------------
' , 处理错误的部分
ERR_HANDLER:
MsgBox "出错了！"

(2) Visual Basic .NET 用程序块实现错误处理

Try
' 做某些处理
' ...

Catch e As Exception
' , 处理错误的部分
MsgBox "出错了！"
End Try

4. 软硬件的最终关系

• 高级语言层面： 程序流程由程序块表示，不含 GoTo 等跳转语句。
• 硬件层面： 无论编写多“结构化”的高级代码，当程序被转换为机器语言时，所有的程序块（如 If、For、Try）最终都还是会被编译器转化为跳转指令来指导 CPU 运行。

核心总结

结构化程序设计倡导仅使用顺序、分支、循环这三种程序块结构来编写程序，并废除 GoTo 等跳转指令，以避免代码陷入“意大利面条”式的混乱。尽管硬件最终仍用跳转指令，但高级语言的抽象让程序员能够专注于编写清晰、有条理的代码。

4.5　画流程图来思考算法

1. 算法的定义

• 算法（Algorithm）：解决既定问题的步骤。
• 目的：想让计算机解决问题，就需要将问题的解法转换成程序的流程。
• 实现：想出巧妙的程序流程，就实现了算法。程序的流程图本身就能解释算法。

2. 思考算法的要点（两步走）

1. 从整体上考虑程序的粗略流程。
2. 再考虑程序各个部分的细节流程（将在后续章节介绍）。

3. 程序的整体流程（粗略流程图）

• 固定模式：几乎所有程序从整体上看都遵循一个不变的流程：
  初始化处理→循环处理→收尾处理
• 对应用户行为：这种流程直接对应用户使用程序的方法：
  • 启动程序 → 初始化处理
  • 操作程序 → 循环处理
  • 关闭程序 → 收尾处理

4. 示例（见图 4.12 & 4.13）

• “石头剪刀布游戏”：
  • 初始化处理：初始化变量和随机数（生成器的种子）。
  • 循环处理：用户和计算机进行 5 轮比试。
  • 收尾处理：显示用户的获胜次数。
• “文字处理机”：
  • 初始化处理：加载写到一半的稿件。
  • 循环处理：不断地输入文字。
  • 收尾处理：保存稿件。

5. 建议

• 对于编程受挫的人，建议先勾画反映程序整体流程的粗略流程图。
• 在此基础上慢慢细化流程，得到详细流程图后，再按照流程图编写程序就会轻松。

4.6　特殊的程序流程——中断处理

1. 定义

• 中断处理 (Interrupt)：计算机程序的流程因外部原因突然跳转到程序中的特定地方，这一跳转是通过 CPU 的硬件功能实现的。
• 类比：就像正在处理文件时突然接听电话，需要中断当前工作，处理完后再返回。

2. 中断流程与硬件机制 (以 Z80 CPU 为例)

1. 数据输入 (1)：用户在键盘上按下按键。
2. 中断请求信号 (2)：连接到键盘的 I/O 模块向 CPU 发出中断请求信号（例如通过 Z80 CPU 的 INT/NMI 引脚）。
3. 流程跳转 (3)：CPU 接收信号后，程序的流程突然跳转到特定的中断处理例程/程序 (Handler/Routine)。
4. 数据读入 (4)：CPU 在中断处理程序中从 I/O 设备（键盘）读入数据。

• 核心思想：CPU 不会时刻监控周边设备（如键盘），而是通过中断请求信号来“得知”有事件发生。

注解 A：INT 用于一般中断请求；NMI（非屏蔽中断）用于即使 CPU 屏蔽了中断也必须立即响应的情况。

3. 中断处理的性质

• 中断处理是一种特殊的条件分支，其条件是由硬件发出的请求。

4. 程序员须知

• 无需编写代码：一般用户或应用程序员不需要编写有关中断处理的代码。
• 处理方：处理中断请求的程序内置于计算机的 BIOS（基本输入输出系统）或 操作系统（如 Windows）中。
• 关键点：
  1. 计算机具有硬件上处理中断的能力。
  2. 中断一词的英文是 Interrupt。

4.7　特殊的程序流程——事件驱动

1. 定义与机制

• 事件驱动 (Event Driven)：一种适用于 GUI (图形用户界面) 环境的编程风格（如 Windows 应用程序）。
• 核心机制：可以想象成 应用程序 和 Windows 操作系统 之间的对话。
• 事件 (Event)：用户在应用程序中的操作，如点击鼠标或敲击键盘。
• 流程：
  1. Windows 负责检测事件的发生。
  2. Windows 通过调用应用程序中的特定函数（例如 WndProc()，称为窗口过程）来通知应用程序事件的发生。
  3. 应用程序根据事件的类型做出相应的处理。

2. 代码实现骨架 (以 C 语言/Windows 为例)

• WinMain()：程序启动时被调用的主例程，负责初始化处理，包括将 WndProc() 函数的起始地址告诉 Windows。
• WndProc()：不会被应用程序本身调用，而是由 Windows 操作系统调用。这是实现对话的关键函数。

代码清单 4.5 用C语言编写的Windows 应用程序的骨架

/* 主例程 */
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow){
    ...
}
/* 窗口过程 */
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam){
    ...
}

3. 性质

• 事件驱动也是一种特殊的条件分支，它以来自 Windows 的通知为条件，决定程序的下一步流程。

4. 流程的表示方法

由于事件驱动流程图会涉及大量条件分支（菱形符号），画起来复杂，因此推荐使用以下方式表示：

A. 状态转化图

• 用途：便于表示事件驱动的流程。
• 元素：
  • 矩形：表示程序或窗口的状态名称。
  • 箭头：表示状态转化的方向。
  • 箭头上标注：引起状态转化的原因（事件）。
• 示例：计算器应用可包含“显示计算结果”“显示第一个输入的数”和“显示第二个输入的数”等状态。
  

B. 状态转化表

• 优势：比绘图方便，易于使用表格软件（如 Excel）完成和修改。
• 结构：
  • 行标题：带有编号的状态。
  • 列标题：状态转化的原因（事件）。
  • 单元格内容：目标状态的编号。

第5章：与算法成为好朋友的七个要点

5.1　算法是程序设计的“熟语”

1. 算法的定义与目的

• 程序目的：在计算机上实现现实世界的业务和娱乐活动。
• 算法定义：为了达到某个目的而需要完成的一系列处理步骤（即处理流程）。
  • 示例： 计算加法需要：“输入数值” $\to$ “执行加法运算” $\to$ “展示结果”。
• 程序流程：程序员需要结合计算机特性，用程序来表示现实世界中对问题的处理步骤。

2. 算法的层次

• 算法分为两类流程：
  • 表示程序整体大流程的算法（已在第 4 章讲解）。
  • 表示程序局部小流程的算法（本章重点）。

3. 算法的重要性

• 编程中的“熟语”：学习编程语言就像学习外语。仅仅记住关键词和语法（单词和语法）不足以流利对话。
• 核心作用：算法相当于程序设计中的熟语，能让程序员将自己的想法完整地传达给计算机。

4. 消除对算法的误解

• 不必害怕：算法并非都“令人生畏且难以掌握”。
• 无需死记硬背：不必牢记所有超群学者发明的复杂算法，简单的算法也有很多。
• 鼓励原创：鼓励程序员自己思考原创算法。
• 思考方法：理清现实世界解决问题的步骤，再结合计算机的特性，就能想出算法。思考算法可以是非常有趣的过程。

5.2　要点 1：算法中解决问题的步骤是明确且有限的

JIS（日本工业标准）定义：被明确定义的有限个规则的集合， 用于根据有限的步骤解决问题。 例如在既定的精度下，把求解 sin x 的计算步骤无一遗漏地记录下来的文字

求出 12 和 42 的 最大公约数

1. 最大公约数的求解方法（中学方法）：

• 定义： 最大公约数是两个整数的公共约数中最大的数。
• 步骤（如图 5.1 所示，以 12 和 42 为例）：
  • 将两数写一排，不断寻找能同时整除它们的除数。
  • 将所有这些除数相乘，结果即为最大公约数（$2\times 3=6$）。

2. 对该方法作为“算法”的质疑：

• 结论： 这种方法不能称为算法，因为它步骤不够明确。
• 具体原因（“直觉”因素）：
  • 步骤 1/2（寻找除数）： “用 2 整除 12 和 42”和“用 3 整除 6 和 21”，其中如何找到 2 和 3（寻找能够整除的数字的方法）未明确。
  • 步骤 3（判断终止）： “没有能同时整除 2 和 7 的除数”，其中如何判断这一事实未明确。
  • 有限性： 为什么到此为止无需后续步骤（步骤数有限）的原因也不明确。
• 总结： 解决问题的步骤中若包含人类的“直觉”判断因素，则不是算法，因此不能用程序表示。

5.3　要点 2：计算机不靠直觉而是机械地解决问题

辗转相除法(求解最大公约数的方法)

辗转相除法

$a = 12;
$b = 42;
while ($a != $b) {
    if ($a > $b) {
        $a = $a - $b;
    } elseif ($b > $a) {
        $b = $b - $a;
    }
}
echo '最大公约数为 ' . $a . PHP_EOL; // 最大公约数为 6

5.4　要点 3：了解并应用典型算法

典型算法

因数

在数学中，因数(Factor)也叫1;;约数，是指一个能够1;;整除给定1;;正整数的数。

核心定义

如果整数 $a$ 除以整数 $b$（$b\ne 0$），除得的1;;商正好是1;;整数而没有1;;余数，我们就说 $b$ 是 $a$ 的1;;因数。

公式表示： 若 $a÷b=c$（其中 $a,b,c$ 均为整数），则 $b$ 和 $c$ 都是 $a$ 的因数。

因数的关键特性

1. 成对出现： 因数通常是成对产生的。例如，因为 $3\times 4=12$，所以 3 和 4 都是 12 的因数。
2. 范围固定： 一个数的因数总是==1;;$<=$==它本身。
3. 最小与最大： 任何正整数最小的因数是 1;;1，最大的因数是 1;;它本身。
4. 有限性： 一个数的因数个数是有限的。

举例说明：求 18 的所有因数

我们可以通过寻找乘法对来列出 18 的所有因数：

• $1\times 18=18$
• $2\times 9=18$
• $3\times 6=18$
  因此，18 的因数有：1, 2, 3, 6, 9, 18。

因数与质数、合数的关系

• 质数 (Prime Number)： 只有 1 和它本身两个因数的1;;正整数（如 2, 3, 5, 7）。
• 合数 (Composite Number)： 除了 1 和它本身以外，还有其他因数的数（如 4, 6, 8, 9）。
• 1 的特殊性： 1 既不是质数也不是合数，因为它只有一个因数。

实用技巧：如何快速找因数

从 1 开始依次尝试除以每个自然数，如果能整除，就把除数和商都记下来。
当你尝试的数字开始重复（比如已经找到了 $3\times 6$，下一个尝试的是 $6\times 3$）时，就说明你已经找全了。

求解最小公倍数的算法

LCM(最小公倍数)：Least Common Multiple
GCD(最大公约数)：Greatest Common Divisor

最小公倍数的定义和常规求解方法：

• 定义： 最小公倍数是两个整数的公共倍数（是一个数几倍的数）中最小的那个数。
• 中学方法： 像最大公约数的求解方法一样，中学的 LCM 求解方法也依赖于人类的直觉，不构成严格的算法。

适用于计算机的最小公倍数算法：

• 核心公式/方法： 求解最小公倍数可以通过以下简单方法实现：

（两个整数的乘积除以这两个整数的最大公约数）

• 示例： 求解 12 和 42 的最小公倍数：

（其中 6 是上文求得的 $\text{GCD}(12,42)$）

对该方法的评价：

• 评价： 这种基于 GCD 的方法是一个极其简单的算法，不被算作“典型算法”（例如，在算法辞典中找不到）。

学习建议：

• 重要性： 这个例子说明，首先自己思考算法，再去应用或查找典型算法非常重要。

公式分析

理解公式法 $\text{LCM}(a,b)=\frac{a\times b}{\text{GCD}(a,b)}$ 的核心在于：避免重复计算公共的部分。

1. 核心逻辑：消除“重复”

想象每一个数都是由若干个 “质因数” 组成的。

• $a\times b$ 的含义： 当你把两个数直接相乘时，那些它们共有的因数（即 GCD）被计算了两次。
• $\text{LCM}$ 的目标： 最小公倍数只需要包含这些共有因数一次。
• 为什么要除以 GCD： 为了修正这种“重复计数”，我们需要从乘积中减掉一份多出来的共有部分。

2. 质因数分解的视角（最透彻的理解）

假设我们要找 12 和 18 的最小公倍数：

• $12=2\times 2\times 3$
• $18=2\times 3\times 3$
  它们共同拥有的部分（GCD）是： $2\times 3=6$。
  如果你直接计算 $12\times 18$：

你会发现其中的 $(2\times 3)$ 出现了两次。
而真正的 LCM 只需要把 所有的因数“集齐” 且不重复：

所以公式就变成了：

3. 集合论视角（韦恩图模型）

如果你把数 $a$ 的因数看作集合 $A$，数 $b$ 的因数看作集合 $B$：

• 中间重叠的部分就是 GCD。
• 两个圆圈涵盖的所有因数并集就是 LCM。
  
  根据集合的并集公式：$A\cup B=A+B-(A\cap B)$
  对应到乘法逻辑中，就是：$\text{LCM}=\frac{a\times b}{\text{GCD}}$。

4. 为什么这个方法最快？

在处理大数字时，分解质因数可能非常耗时，但求 GCD（最大公因数） 有一个极其高效的算法——辗转相除法（Euclidean Algorithm）。

1. 用辗转相除法快速算出 GCD。
2. 代入公式即可瞬间得到 LCM。

小技巧： 计算时，先用其中一个大数除以 GCD，再去乘以另一个数。例如计算 $\frac{120\times 45}{15}$，先算 $120÷15=8$，再算 $8\times 45=360$，这样可以避免处理巨大的中间乘积。

5.5　要点 4：利用计算机的处理速度

埃拉托斯特尼筛法

是一种用于把某个范围内的所有素数都筛选出来的算法， 比如筛选 100 以内的所有素数， 其基本思路就是用待判定的数除以比它小的所有正整数。

判定是否是素数的程序

$a = 91;
$s = " 是素数。";
// 循环从 2 到 $a-1
for ($i = 2; $i < $a; $i++) {
    // 检查 $a 是否能被 $i 整除
    if ($a % $i === 0) {
        $s = " 不是素数。";
        // 如果找到一个因数，就退出循环
        break;
    }
}
// 组合并输出结果
echo $a . $s;

求解鸡兔同笼问题的程序

因为鸡和兔子的只数应该都在 0～10 这个范围内， 所以就试着把 0～10 中的每个数依次代入 x 和 y，只要能够找到使这两个方程同时成 立的数值也就求出了答案。 利用计算机的处理速度， 答案一瞬间就出 来了。

// 外层循环遍历鸡的数量
for ($x = 0; $x <= 10; $x++) {
    // 内层循环遍历兔子的数量
    for ($y = 0; $y <= 10; $y++) {
        // 计算鸡和兔子的总数
        $total_animals = $x + $y;

        // 计算鸡和兔子的总脚数
        $total_legs = 2 * $x + 4 * $y;

        // 如果满足两个条件：总数等于 10，总脚数等于 32
        if (($total_animals === 10) && ($total_legs === 32)) {
            // 输出结果
            echo "鸡的数量 = " . $x . "，兔子的数量 = " . $y; // 鸡的数量 = 4，兔子的数量 = 6
        }
    }
}

5.6　要点 5：使用编程技巧提升程序执行速度

素数/质数(Prime Number)

素数和质数是同一个概念，基础教育偏向质数，高等教育偏向素数

概念

素数：是指一个大于 1 的自然数，除了 1 和它本身以外，不能被其他任何自然数整除。
自然数：是 0,1,2,3,… 这些数。它们是整数（没有小数或分数部分）中所有非负的数。

核心观点

• 素数判定耗时： 判定较小的数（如 91）很快，但判定较大的数（如 999999937）会非常耗时（甚至需要 55 分钟），这说明基本的素数判定算法效率不高。
• 优化效果： 稍微加入一些技巧，就能大幅度缩短处理时间。
• 具体技巧： 将原先的算法（用待判定的数 $N$ 除以所有比它小的正整数 $2,3,\dots ,N-1$）改为除以所有比它的 $\frac{1}{2}$ 小的数（即 $2,3,\dots ,\lfloor \frac{N}{2}\rfloor$）。
• 宣称效果： 通过这一点改进，除法运算的处理时间能够缩短 $\frac{1}{2}$。

为什么 $\frac{N}{2}$ 的优化是正确的？

如果 $N$ 是合数（非素数），它一定可以被分解为 $N=A\times B$。

• 因数$A|B$必须满足条件 $2<=A|B<N$，假设$B=2$，则$A=\frac{N}{2}$。
• 因此只需要检查 $A=2,3,\dots ,\lfloor \frac{N}{2}\rfloor$ 即可。

更优算法：$\sqrt{N}$

如果 $N$ 是合数（非素数），它一定可以被分解为 $N=A\times B$，其中 $A$ 和 $B$ 都是大于 1 的整数。
原理如下：
在乘积 $N=A\times B$ 中，$A$ 和 $B$ 不可能同时大于 $\sqrt{N}$。

1. 如果 $A>\sqrt{N}$ 且 $B>\sqrt{N}$，那么 $A\times B>\sqrt{N}\times \sqrt{N}=N$，这与前提矛盾。
2. 因此，任何合数 $N$ 必有一个因数小于或等于 $\sqrt{N}$。

效果对比

• 文中的 $\frac{N}{2}$ 优化：约 $5\times {10}^8$ 次运算。
• 标准的 $\sqrt{N}$ 优化：$\sqrt{N}\approx 31622$ 次运算。

哨兵

指的是一种含有特殊值的数据，可用于标识数据的结尾等。

字符串的末尾用 0 表示，链表的末尾用－1 表示，像这种特殊的数据就是哨兵。 在本章中， 我们将展示如何在“线性搜索”算法中灵活地应用哨兵。
 
首先看看不使用哨兵的方法。 从第一个箱子开始依次检查每个箱 子中的纸条。 每检查完一个纸条， 还要再检查箱子的编号（用变量 N 表示），并进一步确认编号是否已超过最后一个编号了。这个过程用流 程图表示后如图 5.6 所示。

图 5.6 所示的过程，虽然看起来似乎没什么问题，但是实际上含有 不必要的处理——每回都要检查箱子的编号有没有到 100。

通过放入哨兵， 就一定能找到要找的数据了。 找到要找的数据后， 如果该箱子的编号还没有到 101 就意味着找到了实际的数据；如果该箱子的编号是 101，则意味着找到的是哨兵，而没有找到实际的数据。

5.7　要点 6：找出数字间的规律

所有的信息都可以用数字表示——这是计算机的特性之一。 因此 为了构造算法， 经常会利用到存在于数字间的规律。

• 如果变量 A 和 B 相等就是“平局”
• 如果用 B＋1 除以 3 得到的余数与变量 A 相等就是“玩家 B获胜”
• 其余的情况都是“玩家 A 获胜”

$a = 1; // 假设玩家A出布
$b = 0; // 假设玩家B出石头

if ($a === $b) {
    echo "平局";
} elseif ($a === ($b + 1) % 3) {
    echo "玩家 A 获胜";
} else {
    echo "玩家 B 获胜";
}

5.8　要点 7：先在纸上考虑算法

在纸上画完或写完流程以后， 再把具体的数据代入以跟踪流程的 处理， 确认是否能得到预期的结果。

曾经有一本被誉为凡是立志成为程序员的人都应该去读的名著， 那就是 Niklaus Wirth 的 Algorithms + Data Structures = Programs

第6章：与数据结构成为好朋友的七个要点

6.1 要点1：了解內存和变量的关系

变量和地址的基础概念

计算机所处理的数据都存储在了被称为内存的IC（IntegratedCircuit，集成电路）中。在单片机或现代计算机体系结构中，内存存储的基本单位（寻址最小单位）通常被设计为 8 bit（1 byte）。
为了区分各个单元，每个单元都被分配了一个编号，这个编号被称为“地址”。如果一台个人计算机装配有64M字节的内存，那么就会有从0到64M（M=100万）这么多个地址。

• 字节（Byte）：内存的基本可寻址单位是字节（$8$ 位）。每个字节都有一个唯一的地址。
• 地址：一个地址（通常是一个整数）指向一个单字节的内存空间。

变量名与值的内存归宿

1. 物理层 (Memory IC)

• 变量名：不存在。它在编译时已消失，被替换为引脚上的电平信号（地址）。
• 值：存在。以二进制电荷形式锁存在 6T (SRAM) 或 1T1C (DRAM) 单元内。

2. 逻辑层 (Compiler/OS)

• 映射关系：编译器负责维护 a $\to$ Address 的对应关系。
• 存储代价：
  • 静态语言 (C/C++)：0 字节（变量名不占空间）。
  • 动态语言 (Python)：需额外内存维护变量名与值的映射字典。

多字节变量的存储方式

软件层面：数据类型溢出 (Overflow)

如果你在程序定义时强行将一个大于 255（$2^8-1$）的数值赋给一个 char 或 uint8_t 类型的变量，会发生截断。

• 物理表现：高位丢失，只保留低 8 位。
• 示例：存入十进制 300（二进制 1 0010 1100），内存中只会留下 0010 1100（即十进制 44）。

硬件与逻辑层：多字节存储 (Multi-byte Storage)

当一个变量（如 int, long, float, double 或结构体等）占据超过一个字节的空间时（例如，一个 int 在多数系统中是 $4$ 个字节）：

1. 连续存储：这个变量的所有字节会连续地存放在内存中相邻的地址上。
2. 首地址（Lowest Address）：该变量的地址（即指针所存储的值）是它所占据的第一个字节的地址（即地址值最小的那个字节）。

示例：一个 4 字节的 int 变量

假设在一个 32 位系统中，一个 int 变量 i 占据 $4$ 个字节，它的值为 $0x12345678$（十六进制表示），并且它的起始a地址是 $0x1000$。

因为 $2^4=16$，所以 1 位 16 进制数正好对应 4 位 2 进制数

字节序（Endianness）- 存储顺序的关键

对于多字节变量，还有一个非常重要的概念决定了它的字节是如何排列在内存中的，那就是字节序（Endianness）。字节序分为两种：

a. 大端序 (Big-Endian)