它通常是指计算机可以理解的低级编程语言。此语言包含一组计算机处理器可以直接理解的命令。机器语言是由计算机的中央处理器 （CPU） 执行的命令的直接表达，通常由二进制数表示。

二进制数是一种仅使用两位数字表示的数字系统：0 和 1。该系统经常用于计算机和数字电子设备等电子系统。

数字系统是一种通过按一定顺序排列数学中使用的符号和规则来表示数字的方法。最常用的数字系统是十进制（第 10 个）数字系统、二进制（第 2 个）数字系统、八进制（第 8 个）数字系统和十六进制（第 16 个）数字系统。

十进制（第 10 位）数字系统：

基本数字系统包括从 0 到 9 的十位数字。

数字表示为 10 的倍数。

例如：3874 = （3 * 1⁰³） + （8 * 1⁰²） + （7 * 1⁰¹） + （4 * 1⁰⁰）

如果你想做数学计算，你可以使用一些在线工具。

为了理解机器语言，我们需要理解数字系统。

 

机器用二进制数说话。

为了理解二进制数，让我们根据十进制数系统来研究几个例子：

| Decimal | Binary (4-bit)|
|---------|--------|
|   0     |  0000  |
|   1     |  0001  |
|   2     |  0010  |
|   3     |  0011  |
|   4     |  0100  |
|   5     |  0101  |
|   6     |  0110  |
|   7     |  0111  |
|   8     |  1000  |
|   9     |  1001  |
|  10     |  1010  |
|  11     |  1011  |
|  12     |  1100  |
|  13     |  1101  |
|  14     |  1110  |
|  15     |  1111  |

术语“十进制”用于指属于十进制数字系统的数字。十进制是日常生活中经常使用的数字系统。

 

为了能够表示从 0 到 15 的数字，我们可以在二进制数系统中仅使用 0 和 1 来表示它。4 位二进制代码系统可以表示 16 种不同的组合，每个位有两种不同的状态（0 或 1），我们可以表示 ²⁴ = 16 个数字。

四位二进制数系统包含四个位，每个位的值可以为 0 或 1。每位代表一位小数。下面是 4 位二进制数的示例：

1000

（1 * ²³） + （0 * ²²） + （0 * ²¹） + （0 * ²⁰） = 8 + 0 + 0 + 0 = 8

因此，二进制数“1000”对应于十进制系统中的 8。

取总和，这个 4 位二进制数表示为 8 位小数。因此，二进制数“1000”相当于十进制系统中的 8。

二进制数“1111”相当于十进制的 15。

好吧，为了表示更大的数字，它已扩展如下。

| Decimal | Binary (8-bit) |
|---------|----------------|
|   0     |      00000000  |
|   1     |      00000001  |
|   2     |      00000010  |
|   3     |      00000011  |
|   4     |      00000100  |
|   5     |      00000101  |
|   6     |      00000110  |
|   7     |      00000111  |
|   8     |      00001000  |
|   9     |      00001001  |
|  10     |      00001010  |
|  11     |      00001011  |
|  12     |      00001100  |
|  13     |      00001101  |
|  14     |      00001110  |
|  15     |      00001111  |
|  ...    |      ...       |
|  255    |      11111111  |

8 位二进制代码系统可以表示 ²⁸ = 256 种不同的组合。

二进制数“11101000”相当于十进制的 232。

但是，如果我们需要更多数字，会发生什么？

| Decimal | Binary (16-bit)        |
|---------|------------------------|
|   0     |      0000000000000000  |
|   1     |      0000000000000001  |
|   2     |      0000000000000010  |
|   3     |      0000000000000011  |
|   4     |      0000000000000100  |
|   5     |      0000000000000101  |
|   6     |      0000000000000110  |
|   7     |      0000000000000111  |
|   8     |      0000000000001000  |
|   9     |      0000000000001001  |
|  10     |      0000000000001010  |
|  11     |      0000000000001011  |
|  12     |      0000000000001100  |
|  13     |      0000000000001101  |
|  14     |      0000000000001110  |
|  15     |      0000000000001111  |
|  ...    |          ...           |
|  65535  |      1111111111111111  |

数字 65535 在二进制数系统中定义为 1111111111111111。
具有 8 位和 16 位，代码可以在许多机器上运行和操作。

然而，在当今世界，要求总是在增加。如果你想表示更大的数字，那么是的，你需要增加位数。每个位提供的组合数量是其两倍，因此需要使用更多位来表示更大的数字。

在前面的示例中，我们使用了 16 位，并得到了 ²¹⁶ （65536） 个不同的组合。如果要表示超出这些数字的范围，可以添加更多位。例如，您可以使用 32 位获得 ²³² 不同的组合，这允许您表示更大的数字。

下面是一个使用 32 位二进制代码系统表示较大数字的示例：

| Decimal     | Binary (32-bit)                                                    |
|-------------|--------------------------------------------------------------------|
|  4294967296 | 0000000000000001000000000000000000000000000000000000000000000000   |
|  4294967297 | 0000000000000001000000000000000000000000000000000000000000000001   |
|  4294967298 | 0000000000000001000000000000000000000000000000000000000000000010   |
|  4294967299 | 0000000000000001000000000000000000000000000000000000000000000011   |
|  4294967300 | 0000000000000001000000000000000000000000000000000000000000000100   |
|  ...        | ...                                                                |

此表表示从 4294967296 开始的增量数字，其中包含 32 位二进制数。您可以添加更多位来表示更大的数字。

从理论上讲，您可以在二进制数中使用的位数是无限的。但是，在实践中，许多计算机和系统可以支持它达到一定限制。

这些限制通常取决于硬件和软件的特定功能和设计。

32 位和 64 位系统：大多数现代计算机使用 32 位或 64 位体系结构。这决定了一次可以处理的位数。 32 位系统通常使用 32 位二进制数，而 64 位系统使用 64 位二进制数。

处理器资源：处理器通常具有特定的时钟速度和处理能力。这会影响一次可以处理的位数。

内存限制：计算机可能有内存限制。例如，计算机的 RAM 容量可以决定可以同时处理的数据量。

编程语言和库：某些编程语言或库被限制为一定数量的位。例如，一种语言的“int”数据类型通常具有特定的位长度。

文件系统：计算机文件系统可能会对文件大小和文件名施加限制。这些限制可能会影响文件中可以存储的位数。

显卡：特别是图形处理单元 （GPU），可能被限制在特定的位深度。这会影响颜色深度和图像质量。

也就是说，使用 64 位二进制数系统，您可以表示 ²⁶⁴ 不同的组合。这足以表示非常大的数字，对于许多应用程序和系统来说，这通常绰绰有余。

但是，特别是在理论或特殊用途计算中，可以使用更大的位长度。例如，128、256 或更大的位长度可用于密码学和其他专用计算领域。

较大的位长度可以提供多种优势，尤其是在用于加密和其他专用计算时。

如果你想研究一些关于这个主题的理论：数学：数论和编程语言。
https://medium.com/@azmisahin/mathematics-number-theory-and-programming-languages-48bab154ac94

以下是可能首选较大位长度的一些原因：

安全性：较大的位长度通常会导致更安全的加密。特别是在密码学领域，较大的密钥长度可以更能抵抗暴力攻击。因为密钥长度越大，潜在加密密钥的数量就越多。

范围越宽：位长度越大，可以表示的值范围越大。这在处理大数字的计算或需要非常高精度的情况下尤为重要。

密码阻力：密码算法的安全性依赖于数学问题的难度。较大的位长度会使一些数学问题的求解更加复杂，从而增加算法的加密阻力。

混淆和复杂性：在某些特殊用途的计算中，可以使用更大的位长度执行更复杂和更复杂的计算。这涵盖了某些应用程序中需要更高级别的安全性或复杂性的情况。

总误差减少：较大的位长度有助于减少总误差，尤其是在精确计算中。这在科学计算和数值分析中尤为重要。

但是，使用更大的位长度也有缺点，尤其是需要更多的内存和处理能力。因此，应根据特定应用程序的需要、安全要求和系统资源来选择要使用的位长度。

 

机器语言中的节奏电压：计算机基本语言的基础力量

为了理解机器语言，有必要了解十进制系统、二进制系统。为了能够与机器的基本电子元件进行通信，二进制数系统被用作计算机的基本通信语言，因为它与电子电路中的高（1）和低（0）电压电平直接相关。因此，计算机中的所有数据和进程基本上都运行在二进制系统上。

假设我们的计算机语言中只有两个词：“光明”和“黑暗”。使用二进制数系统，计算机在这两个词之间进行通信。

1：《光》

0：“黑暗”

如果计算机显示“1100”（浅、亮、暗、暗），则表示计算机打开了两次灯，然后将其关闭。

计算机的基本组件使用二进制代码来处理和存储数据。处理器 （CPU） 以二进制格式接收和处理命令和数据。内存 （RAM） 临时存储二进制代码和数据。存储单元（硬盘、SSD）使用二进制代码进行长期数据保留。

程序、软件、图像、视频、文本文档和所有其他类型的数据都由计算机上的二进制代码表示。例如，文本文档中的每个字母都表示为二进制数（字符代码，如 ASCII 或 Unicode）。照片或视频文件还包含像素或颜色值的二进制表示形式。

计算机按顺序处理数据和命令。通常，它按顺序遵循程序中的命令。例如，如果他想控制一盏灯，程序可能是：

打开灯。

稍等片刻。

关掉灯。

这些命令按顺序运行。但是，在某些情况下，处理器可以同时执行多个任务（在多核处理器中）。处理器通过在很短的时间内处理每条指令来执行程序的所需行为。

计算机可以非常快速地处理命令和数据，因此顺序处理通常非常快。但是，处理命令所需的确切时间取决于计算机的速度、要完成的工作的复杂性以及其他因素。

让我们考虑两台不同的计算机：一台是具有较低性能处理器和有限内存容量 （A） 的计算机，另一台是具有高性能处理器和大内存容量 （B） 的计算机。

计算机 A：

处理器速度：2.0 GHz（低性能）

内存容量： 4 GB RAM

存储：256 GB SSD

计算机 B：

处理器速度：4.0 GHz（高性能）

内存容量： 16 GB RAM

Depolama：1 TB 固态硬盘

基于处理器速度的样品处理时间：

简单的数学运算：

示例：让我们进行 5,000,000 次简单的加法。

计算机 A （2.0 GHz）：处理时间 =（5,000,000 次操作）/（2.0 GHz）= 2.5 秒

计算机 B （4.0 GHz）：处理时间 =（5,000,000 次操作）/（4.0 GHz）= 1.25 秒

数据排序：

示例：让我们对 100,000 个数字进行排序。

计算机 A （2.0 GHz）：处理时间 = （100,000 个号码） / （2.0 GHz） = 0.05 秒

计算机 B （4.0 GHz）：处理时间 = （100,000 个号码） / （4.0 GHz） = 0.025 秒

这些示例说明了处理器速度对性能的影响。具有较高处理器速度的计算机可以更快地执行相同的操作。然而，这只是一个因素;内存、存储和其他硬件功能也会影响整体性能。处理时间可能因计算机结构、操作系统、应用程序优化和其他因素而异。

高 （1） 和低 （0） 电压电平在设计用于执行计算机操作的电子电路中起着重要作用。处理器速度主要取决于这些电压电平快速变化的能力以及计算机处理命令和数据的能力。

处理器内部的晶体管是处理电信号的基本组件。这些晶体管使用值 1 和 0 执行逻辑运算，它们表示高电压和低电压电平。

影响电压电平的关键因素：

高频操作：处理器的速度通常以频率表示。在高频下运行的处理器支持更快的电压变化。也就是说，以更高频率运行的处理器可以更快地切换信号，从而实现更快的操作。

技术进步：电子电路技术在不断发展和改进。更小的晶体管尺寸和更先进的材料可实现更快的电压变化。因此，新一代处理器通常速度更快。

缓存内存和总线宽度：处理器的高速缓存和总线宽度会影响处理器与其他组件之间的数据传输速率。更大的总线和更大的高速缓存使处理器能够更快地访问数据。

并行处理功能：某些处理器具有并行处理功能。这是指同时执行许多操作的能力。并行处理可以通过同时执行某些操作来提高处理速度。

热管理：良好的热管理对于防止处理器过热非常重要。因为过热会对晶体管的性能产生不利影响。

机器语言是表示直接提供给计算机处理器的命令的级别。在此级别，高 （1） 和低 （0） 电压级别构成了计算机的基本语言。处理器通过快速更改这些电压电平来执行逻辑和算术运算。因此，机器语言基于频率、电压和电气变化。

 

计算机可以将二进制系统中的数据转换为其他数字系统。特别是在编程中，经常使用十六进制和八进制系统。

我们想理解计算机所说的这个二进制数：11101000。现在让我们将这个数字转换为十六进制数。

让我们将这四个位中的每一个作为一个组，找到相应的十六进制数字：

二进制数 1110 对应于十六进制系统中的字母“E”。

二进制数 1000 对应于十六进制系统中的数字“8”。

结果，计算机的二进制数“11101000”在十六进制系统中表示为“E8”。

这样，通过翻译计算机的二进制语言，我们可以更轻松地与他们进行交流！

例如，这些值彼此相等。

（垃圾桶）1110 1000 = （十二月） 232 = （十六进制） E8 = （十月） 350

BIN（二进制）：

• 11101000属于二进制数系统。
• 这个二进制数有 8 位数字，每个数字可以采用“0”或“1”。
• 11101000 相当于十进制系统中的 232。

十六进制（十六进制系统）：

• E8 属于十六进制数字系统。
• 在十六进制系统中，数字由 10 位代表数字 0-9 的数字和 6 个字母组成，这些字母由字母 A、B、C、D、E、F 表示。
• E8 相当于十进制系统中的 232。

DEC（十进制）：

• 232属于十进制数系统。
• 在十进制系统中，数字由 10 位数字组成，代表数字 0-9。

OCT（八进制）：

• 350 属于八进制数字系统。
• 在八进制系统中，数字由 8 位数字组成，代表数字 0-7。
• 350 相当于十进制系统中的 232。

即数字BIN 11101000用二进制表示，数字十六进制E8用十六进制表示，数字DEC 232用十进制表示，数字OCT 350用八进制表示。这些不同的数字系统用于各个领域，例如计算机科学、编程和数值运算。

 

机器语言 ： 二进制运算中的文本显示

已经为这些代码的表达建立了一系列标准，这些代码在全球范围内用二进制代码进行处理或记录。

ASCII（美国信息交换标准代码）和 Unicode 是将字符与数值相匹配的字符编码系统。但是，这两个系统之间存在显着差异。

ASCII（美国信息交换标准代码）：

• ASCII 是使用最广泛的字符编码系统。
• 它最初是在 1960 年代开发的，最初描述了一个 7 位字符集。这个 7 位系统共有 128 个不同的字符。
• 它包含基本的拉丁字母 （A-Z）、数字 （0-9）、标点符号和一些控制字符。
• 在现代用法中，ASCII 通常用作 8 位（ASCII 扩展），总共表示 256 个不同的字符。但是，基本字符集仍包含前 128 个字符。

统一码：

• Unicode 是为了支持更广泛的字符集而开发的。它最初被设计为 16 位（2 字节），代表 65,536 个不同的字符。
• Unicode 包含世界各地所有语言的字符和符号。这具有广泛的范围，包括亚洲、阿拉伯语、印地语、基里尔语和更多语言的字符。
• Unicode 还包括 32 位（4 字节）扩展格式，这意味着可以表示数百万个字符。
• 有几种可用的 Unicode 字符编码格式，例如 UTF-8、UTF-16 和 UTF-32。

通常，Unicode 通常用于现代应用程序，因为这样可以更好地支持世界各地的各种语言和符号。UTF-8 是 Unicode 使用最广泛的编码格式，已被许多网页、文本文件和编程语言采用为标准。

ASCII （英语）

+------------------+---------------+----------------+
| Binary (ASCII)   | ASCII (8-bit)  |  Karakter     |
+------------------+----------------+---------------+
|      01000001    |    65          |    'A'        |
|      01100001    |    97          |    'a'        |
|      00110000    |    48          |    '0'        |
|      00100100    |    36          |    '$'        |
|      01000000    |    64          |    '@'        |
|      00001010    |    10          |   'n'        |
+------------------+----------------+---------------+

UNICODE编码

+------------------+------------------+------------------+
| Binary (Unicode) | Unicode (16-bit) | Karakter         |
+------------------+------------------+------------------+
| 0100000100000001 |      U+0041      |       'A'        |
| 0110000101100001 |      U+0061      |       'a'        |
| 0011000000000000 |      U+0030      |       '0'        |
| 0010010000000100 |      U+0024      |       '$'        |
| 0100000001000000 |      U+0040      |       '@'        |
| 0000000000001010 |      U+000A      |      'n'        |
+------------------+------------------+------------------+

在 ASCII 中，字符表示为 7 位或 8 位，而 Unicode 字符通常以 16 位（基本多语言平面 — BMP）或更高的位长度表示。在 Unicode 中，字符使用前缀“U+”和十六进制数字系统表示。例如，字母“A”在 ASCII 中对应于 65，而在 Unicode 中，它表示为 U+0041。

例如，让我们用二进制表示来表示文本“Hello， World！”：

H: 01001000
e: 01100101
l: 01101100
l: 01101100
o: 01101111
,: 00101100
(space): 00100000
W: 01010111
o: 01101111
r: 01110010
l: 01101100
d: 01100100
!: 00100001

这种二进制表示是通过将每个字符的 ASCII 值转换为二进制数字系统来实现的。但是，手动对大量文本执行此操作是一个非常耗时的过程，会增加出错的可能性。因此，使用编程语言或工具通常更有效。

用十六进制表示法表示此文本是一种相当普遍的做法。每个字符的 ASCII 值以十六进制格式表示为两位数字。例如，让我们用十六进制表示来表示文本“Hello， World！”：

H: 48
e: 65
l: 6C
l: 6C
o: 6F
,: 2C
(space): 20
W: 57
o: 6F
r: 72
l: 6C
d: 64
!: 21

每个字符的 ASCII 值将转换为十六进制格式的两位数字。例如，由于字母“H”在 ASCII 中是 72，因此十六进制表示形式为 48。

这种十六进制表示通常用于数据表示、编程和低级计算。通过组合两位数的十六进制数字，我们可以用十六进制表示来表达文本。

下面是“Hello， World！”的简单示例，其中偏移量和文本采用十六进制表示形式：

Offset (hex)    Hexadecimal                                Text
0000            48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21     Hello, World!

• 偏移量（十六进制）：每个字符的起始地址或位置以十六进制表示。
• 十六进制：每个字符的 ASCII 值以两位数十六进制格式显示。
• 文本：显示字符的文本表示形式。

例如，字母“H”（ASCII 72）表示为偏移量 0000，十六进制表示形式为 48，文本表示形式表示为“H”。

这种类型的表示（十六进制表示）特别用于内存转储、文件分析和低级数据浏览以及机器语言编码。

 

机器语言是计算机可以直接理解的最基本的语言。

但是，人们很难直接使用二进制代码，并且很有可能犯错误。因此，经常使用一个人可以理解的语言。

让我们通过一个例子来考虑我们所拥有的：我们知道我们可以将一个数字转换为二进制系统，例如，数字 232 对应于二进制系统中的 11101000。同时，我们可以在十六进制系统中将 232 表示为 E8。

现在，我们想给这个二进制数一个含义。如果我们考虑一个具有“电话呼叫”逻辑的函数，我们可以将这种情况表达如下：通过说 E8，我们将计算机称为“电话呼叫”。

但是，更具体地说，指定我们将呼叫的地址很重要。例如，当我们说“电话呼叫 8”时，我们在地址 8 处调用函数。在这种情况下，我们可以将 E8 08 视为二进制的 11101000 00001000。

因此，我们与计算机有了一种更具体的汇编语言通信语言：如果我们进一步缩短和标准化它，我们可以说“CALL 08”。

用于以人们可以理解的语言与计算机进行通信的语言的名称是程序集。

汇编语言是一种低级编程语言，它使用与每种机器语言中的命令相对应的更有意义的符号表达式编写。这些符号表达式使汇编语言更易于理解和编写。然后，用汇编语言编写的编码通过编译器或汇编程序转换为机器语言。

 

理解汇编语言的基本概念
汇编语言中的指令集特定于处理器体系结构，每个处理器都有不同的指令集。为了了解处理器架构，了解内存结构非常重要。

我们将在这里描述的内容将与英特尔在 1978 年制造的 16 位 8086 微处理器兼容。该微处理器是一系列处理器，构成了 x86 架构的基础，并与 8088 一起在 IBM PC 和兼容的计算机系统中得到广泛应用。
https://www.intel.com/content/www/us/en/history/virtual-vault/articles/the-8086-and-the-ibm-pc.html

以下是 8086 的主要功能：

总线：通过 16 位总线运行。这支持在单个时钟脉冲中传输 16 位数据，这意味着与以前的 8 位微处理器相比，数据处理能力更高。

寻址容量：它的寻址容量高达 1 MB。这允许比以前的微处理器更广泛的内存访问。

段偏移结构：使用段偏移结构管理内存访问。此结构将内存地址分为两个部分：段和偏移。这使得内存访问更加灵活。

指令集：8086 的指令集包含一组命令，这些命令构成了 x86 架构的基础。该指令集类似于今天基于 x86 体系结构的计算机系统中使用的基本指令集。

命令临时存储在特定的内存区域中，并按特定顺序进行处理。这就是为什么在开始检查命令之前检查内存结构是合适的。

什么是内存，它是如何工作的？

内存是计算机用来存储数据和程序的组件。

RAM（随机存取存储器）：是一个通用术语，是指计算机系统中使用的各种随机存取存储器。这涵盖了不同类型的存储器，包括 DRAM 和 SRAM。RAM 被称为计算机的工作内存，它存储操作系统和正在运行的应用程序临时使用的数据。

SSD（固态硬盘）：它是计算机系统中使用的存储设备。它基本上使用闪存技术，没有活动部件。SSD 通常具有更快的数据访问速度，可以取代计算机系统中的硬盘驱动器。SSD 中使用的内存技术称为 NAND 闪存。

SRAM由晶体管阵列创建。每个晶体管存储一位数据。SRAM读取和写入数据的速度非常快，因此被处理器用作主存储器。

英特尔的3101 SRAM在内存技术的发展中发挥了重要作用，并构成了现代计算机的基础。
https://www.intel.com/content/www/us/en/history/virtual-vault/articles/intels-first-product-3101.html

另一方面，DRAM（动态随机存取存储器）比SRAM更便宜、更密集。DRAM使用电容器来存储数据。电容器用于存储电荷，因此必须不断补充DRAM以保护数据。DRAM比SRAM慢，但它也常用于主存储器。

内存寻址中使用的两个重要概念是：段和偏移。

段：它是内存的逻辑分区。每个段都有一个起始地址和一个大小。段用于简化内存寻址，并将不同程序的内存区域彼此分离。

抵消：它是给定内存位置与段开头的距离。偏移量用于访问段中的特定内存位置。

说：

• 计算机的内存大小为 100 KB。
• 该内存分为 4 个 25 KB 段。
• 每个段都有一个起始地址和一个大小。

分段机：

Segment     Starting Address    Size
+----------+-----------------+---------------+
Segment 0   0x00000             25 KB
Segment 1   0x04000             25 KB
Segment 2   0x08000             25 KB
Segment 3   0x0C000             25 KB

抵消：

它是特定内存位置与每个段开头的距离。例如：

• 偏移值 10 用于访问段 0 的第 10 个字节。
• 要访问段 2000 的第 2000 个字节，请使用 2000 的偏移值。

内存寻址：

段值和偏移值一起用于访问内存位置。例如：

• 要访问段 1 的字节 1500：
• 区段值 1（选择区段 1）
• 偏移值 1500（选择距离段 1 开头 1500 字节的位置）

计算：

为了计算内存地址，段和偏移值相加：

内存地址 = 段 * 段大小 + 偏移量

例：

要访问第 2 段的第 2000 个字节：

内存地址 = 2 * 25 KB + 2000 = 0x0A000

通过这种方式，我们通过使用段和偏移来简化内存寻址，并将不同程序的内存区域彼此分开。

 

汇编语言的命令

让我们继续考虑二进制系统中的“CALL 08”示例。我们可以通过“操作码”和“操作数”的概念来查看计算机可以理解的语言中此指令的表达式。

操作码和操作数是计算机体系结构和编程语言中经常使用的两个术语。这些基本上描述了处理器 （CPU） 的工作原理以及它如何处理数据。

操作码：

• 您可以将操作码视为机器语言命令的一部分，它决定了它的作用。
• 此代码告诉处理器要执行的操作。
• 例如，聚合、提取操作或将数据从一个位置传输到另一个位置的过程。
• 操作码通常表示为数字代码或符号值。
• 每个处理器都有自己的一组操作码，这意味着不同的处理器使用不同的操作码。

操作数：

• 操作数指定操作码将对其进行操作的数据或数据的位置。
• 在一部歌剧或多部歌剧中可能需要操作码。
• 例如，聚合操作可能需要两个操作数（要求和的数字），而数据传输操作可能需要两个操作数，一个源和一个目标。
• 操作数可以用不同的方式表示，例如数字、变量名称、内存地址等。

例：

让我们考虑汇编语言中的命令。在此命令中：ADD AX, BX

• 操作码： — 告诉处理器它需要执行两个数字相加的操作。ADD
• 操作数：和 — 是处理器将在加法过程中使用的两个数字的寄存器名称。AXBX

简要：

• 操作码告诉您该怎么做。
• 操作数告诉您要处理的内容。

 

汇编语言中最常用的命令

数据迁移命令：

• MOV：它用于将数据从源移动到目标。
• 推：它用于将值推送到堆栈上。
• 流行：它用于从堆栈中减去一个值。
• 草地：它用于将内存位置的地址加载到寄存器中。
• XCHG：用于相互交换两条数据。

算术运算命令：

• ADD：用于将两个数字相加。
• SUB：用于减去两个数字。
• MUL：用于将两个数字相乘。
• DIV：用于除以两个数字。
• 公司。：它用于将数字递增一。
• 12 月：它用于将一个数字减少一个。

逻辑操作命令：

• AND：用于在两个位之间执行 AND 运算。
• OR：用于在两个位之间执行OR操作。
• 异或：它用于在两个位之间执行异或运算。
• 注意：它用于获得虱子的反面。

比较命令：

• CMP：用于比较两个值。
• 测试：它用于测试值的位。

循环命令：

• JMP：它用于跳转到代码块。
• 流行性乙型脑炎：用于在两个值相等时跳转到代码块。
• JNE：用于在两个值不相等时跳转到代码块。
• 刘：它用于在一个值小于另一个值时跳转到代码块。
• JG：如果一个值大于另一个值，则用于跳转到代码块。
• 圈：它用于重复一定次数的循环。

子例程命令：

• 叫：它用于调用子例程。
• 回绝：它用于从子例程返回。

BIOS 中断服务：包括 x86 体系结构的一组编号中断。这些中断用于执行基本的输入/输出操作、视频控制、键盘输入、磁盘访问和许多其他硬件功能。

以下是一些重要的 BIOS 中断服务及其编号：

INT 10h — 视频控制：

• AH=00h： 视频 Modunu Ayarla
• AH=02h：清除屏幕
• AH=09h：将文本打印到屏幕
• AH=0Ah： Pozisyonunu Ayarla 光标
• …

INT 13h — 磁盘操作：

• AH=02h：读取扇区
• AH=03h：扇区夏季
• …

INT 16h — 键盘操作：

• AH=00h：键盘键等待
• AH=01h：扩展键盘键等待
• …

INT 15h — 系统操作：

• AH=4Fh：获取内存映射
• AH=4Eh：安装程序
• …

INT 21h — DOS 操作：

• AH=09h：将文本打印到屏幕
• AH=25h：调用程序
• …

这些只是几个例子，还有许多其他的BIOS黑客。每个 INT 编号都可以具有执行特定功能的子函数。中断编号和 AH（用于解析目的的寄存器）值的组合用于调用特定的 BIOS 服务。还有许多通用的 INT 服务没有特定的中断服务，例如 INT 10h、INT 13h 等。BIOS 中断服务的确切列表可能因计算机硬件和 BIOS 版本而异。因此，查阅每台计算机的 BIOS 文档通常是最可靠的方法。

它只是汇编语言中所有命令的一小部分。为了更详细地理解汇编语言，您应该检查原始文档并了解详细信息。

x86 汇编语言中的指令集由 Intel 和 AMD 等处理器制造商指定。基本上，x86 架构是英特尔在 1970 年代开发的一系列微处理器。这种架构是随着时间的推移而发展起来的，并且出现了各种版本。

x86 汇编语言中的指令集是 Intel 和 AMD 制定并不断更新的标准。每个处理器制造商都基于 x86 架构制作自己的微处理器设计，这些设计包含自己的特殊指令集。但是，基本的 x86 指令集通常相似。

在指定这些指令集时，处理器制造商专注于提高处理器性能、添加新功能和确保兼容性等目标。随着 x86 架构被广泛采用并受到广泛用户的欢迎，x86 汇编语言中的指令集已成为广泛的标准。

要学习 x86 汇编中的指令集，您可以使用 Intel 和 AMD 官方文档、书籍和在线资源等资源。例如，“英特尔® 64 和 IA-32 架构软件开发人员手册”详细描述了 x86 汇编语言的指令集。

® 英特尔 64 位和 IA-32 架构开发人员指南
https://software.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-vol-1-manual.pdf

AMD64 架构程序员指南第 1 卷：应用程序编程
https://www.amd.com/content/dam/amd/en/documents/processor-tech-docs/programmer-references/24592.pdf

 

示例和工具

这里描述的是理解机器语言的简要内容。下面您将看到用汇编语言编写的不同样式的代码。

section .data
 hello:     db 'Hello, World!',10    ; 'Hello, World!' plus a linefeed character
 helloLen:  equ $-hello             ; Length of the 'Hello world!' stringsection .text
 global _start_start:
 mov eax,4            ; The system call for write (sys_write)
 mov ebx,1            ; File descriptor 1 - standard output
 mov ecx,hello        ; Put the offset of hello in ecx
 mov edx,helloLen     ; helloLen is a constant, so we don't need to say
                      ;  mov edx,[helloLen] to get it's actual value
 int 80h              ; Call the kernel
 mov eax,1            ; The system call for exit (sys_exit)
 mov ebx,0            ; Exit with return "code" of 0 (no error)
 int 80h;

此汇编代码通过 Linux 系统调用实现一个简单的“Hello， World！”程序。

mov eax, 4：为其寄存器分配值 4，该寄存器表示sys_write系统调用。eax

mov ebx, 1：为其寄存器分配值 1，该寄存器表示标准输出 （stdout）。ebx

mov ecx, hello：寄存器，表示要打印的文本。ecxhello

mov edx, helloLen：寄存器，表示要打印的文本的长度。edxhelloLen

int 0x80：这将禁用使用 32 位 Linux 系统上使用的旧系统调用接口对内核的控制，并执行系统调用。

mov eax, 1：为其寄存器分配值 1，该寄存器表示sys_exit系统调用。eax

mov ebx, 0：为其寄存器赋值 0，表示程序已成功结束。ebx

int 0x80：通过再次禁用对内核的检查来执行sys_exit系统调用。

 

; a simple hello masm sample
;EXPECT-stdout: "hello masm"

.586
DATA SEGMENT USE16
 MESG DB 'hello masm',0AH,'$'
DATA ENDS
CODE SEGMENT USE16
      ASSUME CS:CODE,DS:DATA
 BEG: MOV    AX,DATA
      MOV    DS, AX
      MOV    CX,8
 LAST:MOV    AH,9
      MOV    DX, OFFSET MESG
      INT    21H
      LOOP   LAST
      MOV    AH,4CH
      INT    21H             ;BACK TO DOS
CODE ENDS
END  BEG

.586：这表示程序使用 x86 架构（英特尔的 8086 及更高版本型号）。

DATA SEGMENT USE16：定义数据段并使用 16 位寻址模式。

MESG DB 'hello masm',0AH,'$'：定义一个名为 MESG 的数据数组，其内容为 “hello masm”，以换行符 （0AH） 和 null 字符 （'$'） 结尾。

DATA ENDS：指定数据段的末尾。

CODE SEGMENT USE16：定义代码段并使用 16 位寻址模式。

ASSUME CS:CODE, DS:DATA：指定汇编语言中使用的段寄存器指向哪些段。

BEG:：这是程序的开始。

MOV AX, DATA：将数据段的起始地址复制到 AX 寄存器。

MOV DS, AX：使用 AX 的内容更新 DS（数据段）寄存器，该 AX 的内容指向数据段。

MOV CX, 8：将值 8 分配给 CX 寄存器，使循环运行 8 次。

LAST:：这是循环的开始。

MOV AH, 9：将值 9 分配给 AH 寄存器，该寄存器表示系统对屏幕打印的调用。

MOV DX, OFFSET MESG：将 MESG 数组的起始地址复制到 DX 寄存器中，该寄存器指定要打印的文本。

INT 21H：21H系统调用用于打印。

LOOP LAST：将 CX 寄存器中的值减少 1，如果不等于零，则返回标签，从而提供一定次数的重复打印。LAST

MOV AH, 4CH：将值 4CH 分配给 AH 寄存器，这是程序对 DOS 的回退系统调用。

INT 21H：21H系统调用允许程序返回DOS。

CODE ENDS：指定代码段的末尾。

END BEG：表示程序结束。标记表示程序的起点。BEG

可以使用 MASM 编译器或类似的编译器编译此程序，并将其创建为可执行文件。运行时，屏幕上会打印8次文字“hello masm”。

 

section .data
    msg db "Hello world!", 0ahsection .text
    global _start_start:
    mov rax, 1
    mov rdi, 1
    mov rsi, msg
    mov rdx, 13
    syscall
    mov rax, 60
    mov rdi, 0
    syscall

这个汇编程序是一个简单的“Hello， World！”程序，编写用于在 Linux x86_64体系结构中运行。此程序的功能是使用系统调用（syscall）将文本打印到标准输出，然后终止程序。

数据部分 （.data）：

msg db "Hello world!", 0ah：包含文本“Hello world！”的数据被定义（），并以跳行字符（0ah）结尾。msg

代码部分（部分 .text）：

global _start：指定程序的启动标签。

_start:：标记程序的起点。

mov rax, 1：为其寄存器赋值 1;这表示 WRITE 系统调用。rax

mov rdi, 1：为其寄存器赋值 1;这表示标准输出文件句柄。rdi

mov rsi, msg：将标签的地址分配给寄存器;这表示要打印的文本。rsimsg

mov rdx, 13：为其寄存器赋值 13;这表示要打印的文本的长度。rdx

syscall：写入执行系统调用，这意味着文本“Hello， World！”被打印到标准输出。

mov rax, 60：为其寄存器赋值 60;这表示对 Exit 的系统调用。rax

mov rdi, 0：为其寄存器赋值 0;这表示程序已成功结束。rdi

syscall：执行退出系统调用，终止程序。

该程序使用 64 位寄存器的 Linux 系统调用，因为它运行在x86_64体系结构上。编译并运行此代码时，文本“Hello world！”将打印在标准输出（通常在终端屏幕上）上。

 

; Program to show use of interrupts
; Also, Hello World program !
hello: DB "Hello World" ; store string
; actual entry point of the program, must be present
start:
MOV AH, 0x13            ; move BIOS interrupt number in AH
MOV CX, 11              ; move length of string in cx
MOV BX, 0               ; mov 0 to bx, so we can move it to es
MOV ES, BX              ; move segment start of string to es, 0
MOV BP, OFFSET hello    ; move start offset of string in bp
MOV DL, 0               ; start writing from col 0
int 0x10                ; BIOS interrupt

此汇编程序旨在使用在 x86 体系结构上运行的计算机的 BIOS（基本输入/输出系统）中断将“Hello World”打印到屏幕上。以下是该计划的详细信息：

hello: DB "Hello World"：数组在 Data 部分中定义，包含字符串“Hello World”。hello

start:：指示程序入口点的标签。程序从这里开始。

MOV AH, 0x13：将0x13值分配给寄存器。这是与视频服务相关的BIOS的截止技巧。AH

MOV CX, 11：将值 11 分配给寄存器。这是要打印的字符串的长度。CX

MOV BX, 0：为寄存器分配值 0。BX

MOV ES, BX：该值分配给寄存器。这会将字符串的段开头移动到 。ESBXES

MOV BP, OFFSET hello：将标签的偏移值分配给寄存器。这会将字符串的起始地址移动到 。BPhelloBP

MOV DL, 0：为寄存器分配值 0。这将指定要开始打印到屏幕的列。DL

int 0x10：这是调用 BIOS 视频服务的中断命令。根据寄存器中的值，执行各种视频服务。在这里，0x13指定的视频服务执行“字符串打印到屏幕”。AH

此程序使用 BIOS 中断将“Hello World”打印到屏幕上。但是，此类操作通常在现代操作系统中通过更高级的图形库或系统调用完成。BIOS 中断通常用于较低级别和系统相关的编程。

 

main:
        MOV #1, R2      ; int a = 1
        MOV #5, R3      ; int b = 5
        CMP R3, R2      ; a - b
        JN label2
        JMP label1label1: MOV #-1, R6
        JMP printlabel2:  MOV #1, R6
        JMP printprint:  INT 10h
        INT 30h         ; Break line
        JMP main

此汇编语言中的代码实现一个简单的类似 C 的表达式，并将结果打印到屏幕上。代码含义如下：

在这里，它比较命令和 ，然后使用 （Jump if Not less） 命令转到，如果它很小，则转到 ，如果不是，则转到 。然后，在屏幕上使用标签进行打印，并使用 添加换行符。最后，回到开头，程序在无限循环中运行。CMP R3, R2abJNalabel2label1printINT 10hINT 30hJMP main

 

在线工具

在线平台和模拟工具：可以在各种在线平台上学习和练习汇编语言。

https://onecompiler.com/assembly https://dosasm.github.io/dosrun/
https://mycompiler.io/new/asm-x86_64
https://yjdoc2.github.io/8086-emulator-web
https://thiagodnf.github.io/assembly-playground/
https://www.onlinegdb.com/

 

资源

通用平台可用于汇编语言中使用的命令。其中最常用的是：

1. 英特尔®开发者专区：

该平台由英特尔开发，包括许多资源和教程，用于开始使用汇编语言进行编程。该平台还设有论坛和在线社区。
https://software.intel.com/

2. AMD 开发者中心：

该平台由 AMD 开发，包含许多资源和教程，用于开始使用 AMD 处理器的汇编语言进行编程。该平台还设有论坛和在线社区。
https://www.amd.com/en/developer.html

3. 纳斯姆：

Netwide Assembler （NASM） 是一个汇编程序，可以在许多操作系统上运行，例如 Windows、Linux 和 macOS。NASM 支持多种处理器架构，例如 x86、x64 和 ARM。
https://www.nasm.us/xdoc/2.16.01/html/nasmdoc0.html

4. FASM：

平面汇编程序 （FASM） 是一个汇编程序，可以在许多操作系统上运行，例如 Windows、Linux 和 macOS。FASM 支持多种处理器架构，例如 x86、x64 和 ARM。
https://flatassembler.net/docs.php

5.气体：

GNU 汇编程序 （GAS） 是 GNU 编译器集合 （GCC） 附带的汇编程序。它支持多种处理器架构，例如 GAS、x86、x64 和 ARM。
https://ftp.gnu.org/old-gnu/Manuals/gas-2.9.1/html_node/as_toc.html

这些平台可用于了解汇编语言中使用的命令、查找示例代码以及从其他程序员那里获得帮助。

在深入研究任何主题时，参考文件和官方来源尤为重要。特定于处理器和操作系统的文档将指导您完成学习过程。

 

如果您对机器代码更感兴趣，请继续。

 

你想编写自己的操作系统吗？

让我们做一些有趣的事情。

用机器语言编写的程序是重要的系统软件，例如引导记录（引导加载程序）或操作系统的内核，它们通常在计算机启动时执行。这种类型的软件用于启动和指导计算机的基本功能。

引导加载程序在计算机的启动过程中起着重要作用，它是一种软件或小程序，通过启动计算机的处理器并安装操作系统使计算机可供使用。

引导加载程序通常是用 Assembly 或 C 等语言编写的，这是一种低级语言。大多数引导加载程序由一段非常短的代码组成，因为它们必须足够小以适合存储单元。

引导加载程序通常是用低级语言编写的，因为这些语言允许在计算机的硬件级别进行更直接的控制。

示例计算机语言引导加载程序代码

; Machine.asm
; https://github.com/azmisahin/azmisahin-os-boot-loader-machine
org 0x7c00
    xor ax, ax                  ;   ax  :   0
    mov ds, ax                  ;   ds  :   0
    jmp Initalize               ;   Go Initalize
    
;   Define
Define:
    message db  'Machine', 13, 10, 0    ;   Initalize
Initalize:
    call Screen                 ;   Scrreen Initalize
    call Welcome                ;   Welcome Intalize;   Main
Main:  
    call Keypress
    
    jmp Main  
    
;   Scrreen Initalize
Screen:
    mov ah, 06h                 ;   Scroll up function.
    xor al, al                  ;   Clear entire screen.
    xor cx,cx                   ;   Upper left corner CH=row, CL=column
    mov dx, 184fh               ;   lower right corner DH=row, DL=column
    mov bh,1eh                  ;   Yellow On Blue
    int 10h                     ;
    ret      ;   Welcome Initalize
Welcome:
    mov si, message             ;   Set Source Index Message
    call Bios_Print    
    ret
    
;   Print Function
Bios_Print:
    lodsb                       ;   Load Memory Byte [ AL ]
    or al, al                   ;
    jz Call_Done                ;
    mov ah, 0x0E                ;
    int 0x10                    ;
    jmp Bios_Print              ;;   Progress Done Signal
Call_Done:
    ret;   Keypres
Keypress:
    mov ah, 1                   ;   
    int 16h                     ;
    jz Keypress                 ;
    mov ah, 0                   ;
    int 16h                     ;
    call    Keypress_Control    ;
    ret                         ;
    
;   Keypres Control Sub Function
    Keypress_Control:
    call Keypress_Escape    
    call Keypress_Print
    ret;   Keypress_Escape
    Keypress_Escape:
    cmp al, 1bh                 ;   Escape    
    jz Exit                     ;   Exit
    ret                         ;   ;   Keypress_Enter
    Keypress_Enter:
    ;cmp al, 1C0Dh       ;   Enter    
                                ;   Nothing progress
    ret                         ;  
            
;   Keypres Print Sub Function
    Keypress_Print:
    mov ah, 0eh                 ;   Key Write
    int 10h
    ret   
    
;   Page_Down Sub Function
    Page_Down:
    add dh, 1                   ;   Page Position
    mov ah, 02h                 ;   Page Change
    int 10h  
    ret      ;   Exit                      
Exit:
    ret;   Zero
db 0;   Sector Done
db 0x55
db 0xAA

org 0x7c00：此指令指定代码从0x7c00内存地址开始。这是引导加载程序代码的典型起始地址。

xor ax、ax/mov ds、ax/jmp 初始化：在本节中，（累加器）记录器被重置，（数据段）记录器被分配一个零，然后跳转到其标签。axdsInitalize

消息 （） 在 Define： 标记下定义。此消息包含将打印在屏幕上的文本。Definemessage

Initalize： 标签允许启动屏幕和欢迎消息。Initalize

main： 标签表示主循环。函数被调用，然后通过返回标签来连续运行。MainKeypressMain

屏幕：清洁（使用）屏幕的功能。int 10h

欢迎：在屏幕上打印欢迎消息的功能。

Bios_Print：从内存中读取字节并将此字节打印到屏幕的函数。

Call_Done：操作完成后返回的函数。

按键：控制键盘输入的功能。

Keypress_Control：调用控制键盘输入的子函数的函数。

Keypress_Escape / Keypress_Enter / Keypress_Print / Page_Down：

对特定键盘输入做出反应的函数。

退出：终止程序的函数。

零：重置内存区域的指令。

Sector Done：引导加载程序成功完成时发送到视频卡的自定义签名。

此代码是具有简单用户界面（与键盘交互）并在屏幕上打印消息的引导加载程序的示例。

汇编语言代码的机器语言翻译将如下所示。

31 C0 8E D8 EB 0A 4D 61 63 68 69 6E 65 0D 0A 00 E8 08 00 E8 13 00 E8 23 00 EB FB B4 06 30 C0 31 C9 BA 4F 18 B7 1E CD 10 C3 BE 06 7C E8 01 00 C3 AC 08 C0 74 06 B4 0E CD 10 EB F5 C3 B4 01 CD 16 74 FA B4 00 CD 16 E8 01 00 C3 E8 04 00 E8 07 00 C3 3C 1B 74 0F C3 C3 B4 0E CD 10 C3 80 C6 01 B4 02 CD 10 C3 C3 00 55 AA

此机器代码表示在 x86 处理器上运行的引导加载程序的示例。每个机器代码的长度为 1 个字节，因为 x86 体系结构通常是面向字节的体系结构。因此，每个两位数代表一个字节。

代码块总共包含 48 条机器代码。在本例中，总字节数为：

总字节数=每个命令的字节数×命令总数=1 字节×48=48 字节总字节数=每个命令的字节数×命令总数=1字节×48=48字节

在此示例中，总字节数为 48。此外，这个 48 字节的引导加载程序代码通常表示一个扇区，在 x86 体系结构中，磁盘扇区可以是 512 字节。因此，考虑到这个 48 字节的代码是真实磁盘扇区的片段，我们可以说这个扇区表示 512 字节的空间。

这种类型的引导加载程序代码通常安装在计算机的第一个扇区，即所谓的主引导记录 （MBR）。MBR 是计算机的启动扇区，包含引导加载程序代码。MBR 是卷开头的前 512 个字节，引导加载程序代码位于该卷中。

 

编译汇编代码

若要为使用 x86 汇编语言编写且具有 BIOS 的计算机编译并运行简单的引导加载程序代码，可以执行以下步骤：

保存代码：将代码复制到文本文件中，例如，命名并使用扩展名保存。Machine.asm.asm

编译代码：可以使用NASM（Netwide Assembler）等编译器来编译代码。打开终端并运行以下命令：

nasm -f bin Machine.asm -o Machine.bin

此命令指示 NASM 将代码编译为二进制文件（平面 bin 格式）。Machine.asm-f binMachine.bin

如果您想在真正的 PC 上测试它。
创建可启动磁盘：可以使用以下工具创建可启动磁盘：例如，在类 Unix 系统上，可以运行以下命令：dd

dd if=Machine.bin of=/dev/sdX bs=512 seek=0 count=1

/dev/sdX替换为驱动程序提供相应的设备标识符。

从磁盘启动：将 USB（如果仍在使用软盘，则为软盘）启动到本机，然后重新启动本机。确保 BIOS 设置为从驱动器启动。

运行代码：如果所有配置都正确，计算机将从驱动器启动并运行代码。

注意：此代码是一个简单的引导加载程序，不执行任何重要操作。它会清除屏幕，打印消息，并等待按下按键。退出条件是按 Escape 键 （）。0x1B

请注意，运行自定义引导加载程序代码会让您直接访问系统，尤其是在实际硬件上。在开发引导加载程序时，要小心并负责任地使用它。

 

在虚拟环境中运行机器代码

对于使用 x86 汇编语言编写并具有 BIOS 的计算机，您可能希望在虚拟环境中测试简单的引导加载程序代码。

如果要在虚拟机环境中进行测试，可以使用虚拟机仿真器。
https://www.vmware.com/products/workstation-player.html

您可以将之前创建的二进制文件作为文件显示到虚拟设备。

例如：将 https://github.com/azmisahin/azmisahin-os-boot-loader-machine/blob/master/bin/machine.bin 启动加载程序代码定义为软盘文件。并启动虚拟机。

下面是引导加载程序代码的实时工作屏幕截图。

 

 

此代码只是启动计算机，不执行任何重要操作。它会清除屏幕，打印消息，并等待按下按键。退出条件是按 Escape 键 （）。0x1B

 

我们可以用不同的语言编写引导加载程序代码吗？

Bootloader 软件可以用汇编语言编写，因为它在计算机的起点运行，并且由于内存限制，通常非常小。

核心代码通常使用 C 或 C++ 等语言开发。

下面是一个简单的 C 程序，其灵感来自引导加载程序代码。

#include <stdio.h>#define MESSAGE "Machinen"void ClearScreen(void)
{
    // Code for screen initialization (clear screen, set colors)
    printf("�33c");    // Clear screen using escape sequence
    printf("x1B[33m"); // Set yellow text color
}void PrintMessage(void)
{
    printf("%s", MESSAGE);
}char GetKeyPress(void)
{
    char ch;
    scanf(" %c", &ch); //Get user's input
    return ch;
}int main(void)
{
    while (1)
    {
        ClearScreen();            // clear screen
        PrintMessage();           // Print the message to the screen
        char key = GetKeyPress(); // Get user's input
        if (key == 'q')
        {
            break;                 // End the loop by pressing the 'q' key
        }
    }
    return 0;
}

该程序使用 、 和 等函数ClearScreen PrintMessage GetKeyPress

• ClearScreen：使用转义数组清除屏幕，并使用转义数组调整黄色文本颜色。�33cprintf("x1B[33m")
• PrintMessage：打印屏幕上指示的消息。printf("%s", MESSAGE)
• GetKeyPress：接受用户的输入并返回字符。scanf(" %c", &ch)

在 main 函数中，这些函数在循环中调用。在用户按下“q”键之前，程序会清除屏幕、打印消息并检索用户的输入。如果用户按“q”键，程序将结束循环并结束。main

您可以在 https://www.onlinegdb.com/ 在线测试此代码。

尽管 C 语言是一种低级语言，但它提供的硬件级控制不如汇编语言。

但是，由于 C 语言是一种通用语言，因此它可以处理广泛的应用程序，从小型和独特的应用程序（如引导加载程序软件）到更大和更复杂的系统软件。

由于引导加载程序软件通常在有限的内存和资源下工作，因此在此类应用程序中经常使用 C 语言。

由于引导加载程序软件是管理计算机启动过程的关键组件，因此通常用快速的低级语言编写它。但是，现代引导加载程序有时使用混合方法，使用汇编语言和 C 语言。

机器语言可以直接理解这一事实具有能够与计算机硬件非常接近地工作的优势。然而，经常使用更高级别的编程语言，因为编写机器语言对人类来说是一个复杂且容易出错的过程。这些语言允许人们编写更易于理解和可读的代码;然后，这些代码由编译器或解释器翻译成机器语言，并由计算机处理。

 

原文始发于微信公众号（安全狗的自我修养）：机器语言