汇编语言编程实践：标志操作与数组处理

1、编写一个程序，为一周的所有天数定义符号常量。创建一个数组变量，使用这些符号作为初始值。

以下是一个示例汇编程序，为一周各天定义符号常量，并创建一个数组变量使用这些符号作为初始值：

.MODEL SMALL
.STACK 100H
.DATA
; 定义一周各天的符号常量
SUNDAY = 1
MONDAY = 2
TUESDAY = 3
WEDNESDAY = 4
THURSDAY = 5
FRIDAY = 6
SATURDAY = 7

; 创建数组变量，使用符号常量作为初始值
week_days DB SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY

.CODE
MAIN PROC
    MOV AX, @DATA
    MOV DS, AX
    ; 在此可以添加代码来使用或显示数组中的值
    MOV AH, 4CH
    INT 21H
MAIN ENDP

END MAIN

这个示例使用了 x86 汇编语言，定义了一周各天的符号常量，并创建了一个字节数组

week_days

，使用这些符号常量作为初始值。

2、编写一个程序，为几个字符串字面量（引号之间的字符）定义符号名称，并在变量定义中使用每个符号名称。

以下是满足要求的代码示例：

Sample TEXTEQU <"This is a string">

，

MyString BYTE Sample

。该示例中，首先使用

TEXTEQU

为字符串字面量

"This is a string"

定义了符号名称

Sample

，然后在变量

MyString

的定义中使用了这个符号名称。

3、编写一个程序，使用加法和减法来设置和清除进位标志（Carry flag）。在每条指令之后，插入

call DumpRegs

语句以显示寄存器和标志。使用注释解释每条指令如何（以及为什么）影响进位标志。

以下是一个示例程序（使用 MASM 语法）来实现该需求：

.MODEL SMALL
.STACK 100H
.DATA
.CODE
MAIN PROC
    MOV AX, @DATA
    MOV DS, AX

    ; 设置进位标志：较大无符号整数减较小无符号整数
    MOV AL, 00H       ; AL = 0
    SUB AL, 01H       ; AL = FFh, CF = 1，因为从较小数 0 减去较大数 1
    CALL DumpRegs     ; 显示寄存器和标志

    ; 清除进位标志：较小无符号整数加另一个数，结果不溢出
    MOV AL, 00H       ; AL = 0
    ADD AL, 01H       ; AL = 01h, CF = 0，结果能正常存储在 AL 中
    CALL DumpRegs     ; 显示寄存器和标志

    MOV AH, 4CH
    INT 21H
MAIN ENDP
END MAIN

在这个程序中，首先使用

SUB

指令从较小的无符号整数

0

减去较大的无符号整数

1

，这会设置进位标志。然后使用

ADD

指令将

0

和

1

相加，结果能正常存储在

AL

寄存器中，因此进位标志被清除。每次操作后，调用

DumpRegs

来显示寄存器和标志。

4、编写一个简短的程序，证明INC和DEC指令不会影响进位标志（Carry flag）。

以下是一个简单的汇编程序示例，可证明

INC

和

DEC

指令不会影响进位标志：

.MODEL SMALL
.STACK 100H
.DATA

.CODE
MAIN PROC
    MOV AX, @DATA
    MOV DS, AX

    ; 设置进位标志
    STC
    MOV AL, 0FFH      ; AL = 255
    INC AL            ; AL = 0, 执行INC指令
    JC CARRY_SET      ; 若进位标志被设置，跳转到CARRY_SET
    JMP NO_CARRY      ; 若进位标志未被设置，跳转到NO_CARRY

CARRY_SET:
    MOV AH, 02H
    MOV DL, '1'
    INT 21H           ; 输出 '1' 表示进位标志被设置
    JMP CONTINUE

NO_CARRY:
    MOV AH, 02H
    MOV DL, '0'
    INT 21H           ; 输出 '0' 表示进位标志未被设置

CONTINUE:
    MOV AL, 0
    DEC AL            ; AL = 255, 执行DEC指令
    JC CARRY_SET2     ; 若进位标志被设置，跳转到CARRY_SET2
    JMP NO_CARRY2     ; 若进位标志未被设置，跳转到NO_CARRY2

CARRY_SET2:
    MOV AH, 02H
    MOV DL, '1'
    INT 21H           ; 输出 '1' 表示进位标志被设置
    JMP EXIT

NO_CARRY2:
    MOV AH, 02H
    MOV DL, '0'
    INT 21H           ; 输出 '0' 表示进位标志未被设置

EXIT:
    MOV AH, 4CH
    INT 21H           ; 程序结束

MAIN ENDP
END MAIN

这个程序先设置进位标志，然后执行

INC

指令，检查进位标志是否受影响；接着执行

DEC

指令，再次检查进位标志。若两次检查都显示进位标志未被改变，就证明了

INC

和

DEC

指令不会影响进位标志。

5、编写一个程序，使用加法和减法来设置和清除零标志（Zero flag）和符号标志（Sign flag）。在每条加法或减法指令之后，插入用于显示寄存器和标志的语句以显示寄存器和标志。使用注释解释每条指令如何（以及为什么）影响零标志和符号标志。

以下是一个满足要求的汇编程序示例：

.MODEL SMALL
.STACK 100H
.DATA
.CODE
MAIN PROC
    MOV AX, @DATA
    MOV DS, AX

    ; 设置零标志
    MOV AL, 5
    SUB AL, 5 ; AL = 5 - 5 = 0，设置零标志
    CALL DumpRegs ; 显示寄存器和标志

    ; 注释：因为两个相等的值相减结果为0，所以零标志被设置

    ; 清除零标志
    ADD AL, 1 ; AL = 0 + 1 = 1，清除零标志
    CALL DumpRegs ; 显示寄存器和标志

    ; 注释：因为结果不为0，所以零标志被清除

    ; 设置符号标志
    MOV AL, 127
    ADD AL, 1 ; AL = 127 + 1 = -128（有符号数溢出），设置符号标志
    CALL DumpRegs ; 显示寄存器和标志

    ; 注释：结果为负数，最高有效位被设置，所以符号标志被设置

    ; 清除符号标志
    ADD AL, 128 ; AL = -128 + 128 = 0，清除符号标志
    CALL DumpRegs ; 显示寄存器和标志

    ; 注释：结果为非负数，最高有效位为0，所以符号标志被清除

    MOV AH, 4CH
    INT 21H
MAIN ENDP
END MAIN

这个程序通过加法和减法操作来设置和清除零标志和符号标志，并在每次操作后使用

call DumpRegs

显示寄存器和标志。同时，在代码中添加了注释解释每个操作如何影响标志。

6、编写一个程序，使用加法和减法来设置和清除溢出标志。在每条加法或减法指令之后，插入一条用于显示寄存器和标志的语句。使用注释解释每条指令如何（以及为何）影响溢出标志。包含一条同时设置进位标志和溢出标志的

ADD

指令。

以下是一个满足要求的汇编程序示例：

TITLE Addition and Subtraction (AddSubOverflow.asm)
INCLUDE Irvine32.inc

.DATA

.CODE
main PROC
    ; 设置溢出标志
    ; 最大的有符号字节值是 +127，加 1 会导致溢出
    mov al, +127
    add al, 1       ; 此时 OF 应该被设置为 1，因为两个正数相加得到负数
    call DumpRegs   ; 注释：两个正数相加得到负数，发生了有符号溢出，所以 OF 被设置

    ; 清除溢出标志
    ; 一个正数和一个负数相加不会发生溢出
    mov al, +100
    add al, -50     ; 此时 OF 应该被清除为 0
    call DumpRegs   ; 注释：正数和负数相加不会发生溢出，所以 OF 被清除

    ; 同时设置进位标志和溢出标志
    ; 对于 8 位操作数，最大无符号值是 255，加 1 会设置 CF
    ; 对于有符号数，也会发生溢出
    mov al, 255
    add al, 1       ; 此时 CF 和 OF 都应该被设置
    call DumpRegs   ; 注释：无符号数相加超过最大值设置 CF，有符号数相加得到负数设置 OF

    exit
main ENDP
END main

这个程序首先使用

add al, 1

对

al

寄存器中存储的最大有符号字节值

+127

进行加法操作，导致有符号溢出，从而设置溢出标志。然后，通过一个正数和一个负数相加来清除溢出标志，因为不同符号的数相加不会发生溢出。最后，使用

add al, 1

对

al

寄存器中存储的最大无符号字节值

255

进行加法操作，同时设置进位标志和溢出标志。在每条加法指令之后，使用

call DumpRegs

显示寄存器和标志。

7、在程序中定义以下变量：data Uarray WORD 1000h, 2000h, 3000h, 4000h；Sarray SWORD -1,-2,-3,-4。编写使用直接偏移寻址的指令，将Uarray中的四个值移动到EAX、EBX、ECX和EDX寄存器。调用显示寄存器值的语句后，应显示以下寄存器值：EAX = 00001000，EBX = 00002000，ECX = 00003000，EDX = 00004000。接着，编写使用直接偏移寻址的指令，将Sarray中的四个值移动到EAX、EBX、ECX和EDX寄存器。再次调用显示寄存器值的语句后，应显示以下寄存器值：EAX = FFFFFFFF，EBX = FFFFFFFE，ECX = FFFFFFFD，EDX = FFFFFFFC。

以下是实现上述功能的代码：

.MODEL SMALL
.STACK 100H
.DATA
Uarray WORD 1000h, 2000h, 3000h, 4000h
Sarray SWORD -1,-2,-3,-4
.CODE
MAIN PROC
    MOV AX, @DATA
    MOV DS, AX

    ; 移动Uarray的值到寄存器
    MOV EAX, 0
    MOV EBX, 0
    MOV ECX, 0
    MOV EDX, 0
    MOV AX, Uarray
    MOV EAX, AX
    MOV AX, Uarray + 2
    MOV EBX, AX
    MOV AX, Uarray + 4
    MOV ECX, AX
    MOV AX, Uarray + 6
    MOV EDX, AX
    CALL DumpRegs

    ; 移动Sarray的值到寄存器
    MOV EAX, 0
    MOV EBX, 0
    MOV ECX, 0
    MOV EDX, 0
    MOV AX, Sarray
    MOVSX EAX, AX
    MOV AX, Sarray + 2
    MOVSX EBX, AX
    MOV AX, Sarray + 4
    MOVSX ECX, AX
    MOV AX, Sarray + 6
    MOVSX EDX, AX
    CALL DumpRegs

    MOV AH, 4CH
    INT 21H
MAIN ENDP
END MAIN

上述代码首先将Uarray中的值使用直接偏移寻址移动到EAX、EBX、ECX和EDX寄存器，然后调用DumpRegs显示寄存器值。接着，将Sarray中的值使用直接偏移寻址并结合MOVSX指令（用于符号扩展）移动到EAX、EBX、ECX和EDX寄存器，再次调用DumpRegs显示寄存器值。

8、编写一个程序来实现以下算术表达式：EAX = – val2 + 7 * val3 + val1。使用以下数据定义：val1 为有符号双字，值为 8；val2 为有符号双字，值为 – 15；val3 为有符号双字，值为 20。在每条指令旁边的注释中，写出 EAX 的十六进制值。在程序末尾插入一条 call DumpRegs 语句。

以下是实现该算术表达式的汇编程序示例：

.386
.model flat, stdcall
option casemap:none

include IrvineIrvine32.inc
includelib IrvineIrvine32.lib
includelib C:masm32libkernel32.lib
includelib C:masm32libuser32.lib

.data
val1 SDWORD 8
val2 SDWORD -15
val3 SDWORD 20

.code
main PROC
    ; EAX = -val2
    mov eax, val2      ; EAX = -15 (0xFFFFFFF1)
    neg eax            ; EAX = 15 (0x0000000F)

    ; EAX = 7 * val3
    mov ebx, 7         ; EBX = 7 (0x00000007)
    mov ecx, val3      ; ECX = 20 (0x00000014)
    imul ebx, ecx      ; EBX = 7 * 20 = 140 (0x0000008C)
    add eax, ebx       ; EAX = 15 + 140 = 155 (0x0000009B)

    ; EAX = EAX + val1
    add eax, val1      ; EAX = 155 + 8 = 163 (0x000000A3)

    ; 调用 DumpRegs 显示寄存器内容
    call DumpRegs

    exit
main ENDP
END main

该程序首先将

-val2

的值存入

EAX

，然后计算

7 * val3

的值并累加到

EAX

中，最后加上

val1

的值。最后调用

DumpRegs

过程显示寄存器的内容。

9、编写一个程序，使用带有间接寻址的 LOOP 指令将字符串从源字符串复制到目标字符串，并在复制过程中反转字符顺序。源字符串 source 为 “This is the source string”.0，目标字符串 target 初始化为与源字符串大小相同且每个字符为 ‘#’ 的字符串。在循环结束后显示目标字符串的十六进制内容。如果程序运行正确，将显示以下十六进制字节序列：67 6E 69 7A 74 73 20 65 63 72 75 6F 73 20 65 68 74 20 73 69 20 73 69 68 54

以下是实现该功能的汇编程序示例：

TITLE Copy String Backwards
INCLUDE Irvine32.inc

.data
source  BYTE "This is the source string",0
target  BYTE SIZEOF source DUP('#')

.code
main PROC
    mov esi, OFFSET source + SIZEOF source - 1 ; 指向源字符串末尾
    mov edi, OFFSET target                    ; 指向目标字符串开头
    mov ecx, SIZEOF source                    ; 循环计数器

L1:
    mov al, [esi]       ; 从源字符串取字符
    mov [edi], al       ; 存入目标字符串
    dec esi             ; 源字符串指针前移
    inc edi             ; 目标字符串指针后移
    loop L1             ; 循环直到复制完所有字符

    ; 显示目标字符串的十六进制内容
    mov esi, OFFSET target  ; 变量偏移量
    mov ebx, 1              ; 字节格式
    mov ecx, SIZEOF target  ; 计数器
    call DumpMem

    exit
main ENDP
END main

该程序首先将源字符串的指针指向末尾，目标字符串的指针指向开头。然后使用

LOOP

指令循环，每次从源字符串末尾取一个字符存入目标字符串开头，同时移动指针。最后使用

DumpMem

过程显示目标字符串的十六进制内容。

10、编写一个程序，使用循环以四种不同颜色显示相同的字符串。需要有设置文本颜色的过程。可以选择任何颜色，但更改前景色可能最简单。

以下是一个满足需求的汇编程序示例：

TITLE Display String in Four Colors
INCLUDE Irvine32.inc

.data
message BYTE 'Hello, World!', 0
colors DWORD lightGray + (black * 16), yellow + (blue * 16), red + (black * 16), green + (black * 16)

.code
main PROC
    mov ecx, 4              ; 循环次数，四种颜色
    mov esi, 0              ; 颜色数组索引

L1:
    mov eax, [colors + esi]
    call SetTextColor       ; 设置文本颜色
    mov edx, OFFSET message
    call WriteString        ; 显示字符串
    call Crlf               ; 换行
    add esi, 4              ; 移动到下一个颜色
    loop L1

    ; 恢复默认颜色
    mov eax, lightGray + (black * 16)
    call SetTextColor
    call Clrscr

    exit
main ENDP
END main

这个程序定义了一个字符串

message

和一个包含四种颜色的数组

colors

。使用

ecx

作为循环计数器，

esi

作为颜色数组的索引。在每次循环中，从

colors

数组中取出一个颜色值，调用

SetTextColor

过程设置文本颜色，然后显示字符串并换行。循环结束后，恢复默认颜色并清屏。

11、编写一个程序，生成并显示50个介于 -20 和 +20 之间的随机整数。

以下是一个满足需求的汇编语言程序示例：

TITLE Random Integers between -20 and +20
.INCLUDE Irvine32.inc

main PROC
    call Randomize        ; 初始化随机数生成器
    mov ecx, 50           ; 循环50次
L1:
    mov eax, 41           ; 范围是0 - 40
    call RandomRange      ; 生成随机数
    sub eax, 20           ; 调整范围到 -20 到 +20
    call WriteInt         ; 显示有符号十进制数
    mov al, 9             ; 水平制表符
    call WriteChar        ; 写入制表符
    loop L1
    call Crlf             ; 换行
    exit
main ENDP
END main

该程序首先调用

Randomize

初始化随机数生成器，然后通过

RandomRange

生成0 – 40的随机数，再减去20将范围调整到 -20 到 +20，最后使用

WriteInt

显示随机数，循环50次完成需求。

12、编写一个程序，在 100 个随机屏幕位置显示单个字符，每次显示使用 100 毫秒的时间延迟。提示：使用 GetMaxXY 过程来确定控制台窗口的当前大小。

程序编写步骤

要编写此程序，可遵循以下步骤：

使用

GetMaxXY

过程获取控制台窗口的当前大小，以确定随机位置的范围。

使用随机数生成器生成 100 组随机的屏幕坐标（X, Y），确保这些坐标在控制台窗口的有效范围内。

使用

Gotoxy

过程将光标定位到随机生成的屏幕位置。

显示单个字符。

实现 100 毫秒的时间延迟。

重复步骤 2 – 5，直到显示了 100 个字符。

伪代码示例

; 获取控制台窗口大小
call GetMaxXY
mov max_cols, dl
mov max_rows, dh

; 循环 100 次
for i = 0 to 99 

    ; 生成随机的 X 和 Y 坐标
    generate_random_x(max_cols)
    generate_random_y(max_rows)

    ; 定位光标到随机位置
    mov dh, random_y
    mov dl, random_x
    call Gotoxy

    ; 显示单个字符
    display_single_character()

    ; 延迟 100 毫秒
    call GetMseconds
    mov start_time, eax

delay_loop:
    call GetMseconds
    sub eax, start_time
    cmp eax, 100
    jl delay_loop

end for

在实际的汇编语言编程中，需要根据具体的汇编器和库函数进行相应的调整。

13、编写一个程序，以所有可能的前景色和背景色组合显示单个字符（16×16 = 256 种组合）。颜色编号从 0 到 15，因此可以使用嵌套循环来生成所有可能的组合。

可使用嵌套循环实现该程序。外层循环控制背景色（0 – 15），内层循环控制前景色（0 – 15）。在每次循环中，将背景色乘以 16 并加上前景色得到颜色值，然后使用相关函数设置文本颜色并显示单个字符。在 Irvine 库环境中，代码如下：

; 假设已经包含必要的头文件
.data
charToDisplay BYTE 'A', 0   ; 要显示的字符

.code
main PROC
    mov ecx, 16             ; 外层循环，控制背景色
outer_loop:
    push ecx                ; 保存外层循环计数器
    mov ecx, 16             ; 内层循环，控制前景色
inner_loop:
    mov eax, ecx            ; 前景色
    add eax, ebx * 16       ; 计算颜色值，ebx 为背景色
    call SetTextColor       ; 设置文本颜色
    mov al, charToDisplay   ; 要显示的字符
    call WriteChar          ; 显示字符
    loop inner_loop
    pop ecx                 ; 恢复外层循环计数器
    inc ebx                 ; 背景色加 1
    loop outer_loop
    call WaitMsg            ; 等待用户按键
    exit
main ENDP
END main

此代码仅为示例，实际使用时需根据具体的汇编环境和库函数进行调整。

14、编写一个汇编程序，要求使用常量选择数组大小，将常量 ARRAY_SIZE 定义为 20，数组定义为 array DWORD ARRAY_SIZE DUP(?)。编写一个新过程，提示用户输入要处理的整数数量。将该值传递给 PromptForIntegers 过程。如果用户输入的值大于 ARRAY_SIZE，则显示错误消息并停止对数组的进一步处理。设计程序时要确保更改 ARRAY_SIZE 能自动更新错误消息。

以下是实现该功能的大致思路和示例代码框架：

首先定义常量

ARRAY_SIZE

为 20 并声明数组。

编写新过程提示用户输入要处理的整数数量，将该值传递给

PromptForIntegers

过程。

若输入值大于

ARRAY_SIZE

，显示错误信息并停止处理。

为使更改

ARRAY_SIZE

能自动更新错误消息，可在错误消息中使用该常量。

示例代码框架如下：

; 定义常量
ARRAY_SIZE = 20

; 声明数组
array DWORD ARRAY_SIZE DUP(?)

; 提示用户输入整数数量的新过程
PromptForCount PROC
    ; 提示用户输入要处理的整数数量
    ; 读取用户输入到某个寄存器，如 EBX
    ; 检查输入值是否大于 ARRAY_SIZE
    cmp EBX, ARRAY_SIZE
    jg ErrorHandler
    ; 若不大于，将值传递给 PromptForIntegers 过程
    mov ECX, EBX
    call PromptForIntegers
    ret
PromptForCount ENDP

; 错误处理过程
ErrorHandler PROC
    ; 显示错误消息，消息中使用 ARRAY_SIZE
    mov EDX, OFFSET errorMsg
    call WriteString
    ; 停止程序
    jmp ExitProgram
    ret
ErrorHandler ENDP

; 错误消息
errorMsg BYTE 'The array cannot be larger than ', 0

; 其他原有的过程和主程序部分...

此代码框架展示了如何实现需求，实际编写时需根据具体汇编环境和使用的库函数完善代码。

15、使用块结构的IF和.WHILE指令，用汇编语言实现以下C++代码。假设所有变量都是32位有符号整数：int array[] = {10,60,20,33,72,89,45,65,72,18};int sample = 50;int ArraySize = sizeof array / sizeof sample;int index = 0;int sum = 0;while( index < ArraySize ) { if( array[index] <= sample ) { sum += array[index]; index++; }}可选：绘制代码的流程图。

以下是使用汇编语言实现上述C++代码的示例，使用了块结构的

IF

和

.WHILE

指令：

.MODEL SMALL
.STACK 100H
.DATA
    array DWORD 10,60,20,33,72,89,45,65,72,18
    sample DWORD 50
    ArraySize EQU ($ - array) / TYPE array
    index DWORD 0
    sum DWORD 0
.CODE
MAIN PROC
    MOV AX, @DATA
    MOV DS, AX

    .WHILE index < ArraySize
        MOV EAX, index
        MOV EBX, TYPE array
        MUL EBX
        MOV EBX, EAX
        MOV EAX, [array + EBX]

        .IF EAX <= sample
            ADD sum, EAX
            INC index
        .ENDIF
    .ENDW

    MOV AH, 4CH
    INT 21H
MAIN ENDP
END MAIN

关于绘制流程图，可按照以下逻辑绘制：

开始。

初始化变量：数组、样本值、数组大小、索引和总和。

进入循环（判断索引是否小于数组大小）。

若满足循环条件，获取当前索引对应的数组元素。

判断该元素是否小于等于样本值。

若满足条件，将该元素累加到总和，并增加索引。

回到循环开始处继续判断。

若不满足循环条件，结束程序。