汇编代码初始化数组

1471 字

7 分钟

汇编代码初始化数组

2025-12-30

笔记

/

stcg

/

汇编

初始化数组（存储在RAM中）#

方法1：使用DS在RAM中预留空间#

1
ORG 30H            ; 从30H开始分配RAM变量
2

3
; 未初始化的数组（预留空间）
4
BUFFER:      DS    16      ; 预留16字节的缓冲区
5
TEMP_ARRAY:  DS    8       ; 预留8字节的温度数组
6
RESULTS:     DS    32      ; 预留32字节的结果数组
7

8
; 混合定义
9
DATA_AREA:
10
VAR1:        DS    1       ; 单个字节变量
11
ARRAY1:      DS    10      ; 10字节数组
12
VAR2:        DS    1       ; 另一个变量

方法2：运行时初始化数组#

1
; 初始化RAM数组的函数
2
INIT_ARRAYS:
3
    ; 初始化BUFFER数组为0
4
    MOV R0, #BUFFER       ; 数组起始地址
5
    MOV R2, #16           ; 数组长度
6
    CLR A                 ; A = 0
7
INIT_LOOP1:
8
    MOV @R0, A            ; 清零数组元素
9
    INC R0
10
    DJNZ R2, INIT_LOOP1
11

12
    ; 初始化TEMP_ARRAY为特定值
13
    MOV R0, #TEMP_ARRAY
14
    MOV @R0, #20          ; TEMP_ARRAY[0] = 20
15
    INC R0
16
    MOV @R0, #25          ; TEMP_ARRAY[1] = 25
17
    INC R0
18
    MOV @R0, #30          ; TEMP_ARRAY[2] = 30
19
    ; ... 继续初始化
20

21
    RET

访问常数变量和数组#

1. 访问ROM中的常数（使用MOVC）#

1
; 读取SINE_TABLE中的第3个元素
2
READ_SINE_VALUE:
3
    MOV DPTR, #SINE_TABLE   ; 设置表基址
4
    MOV A, #2               ; 索引2（第3个元素）
5
    MOVC A, @A+DPTR         ; A = SINE_TABLE[2] = 25
6
    RET
7

8
; 读取字符串中的字符
9
READ_MESSAGE_CHAR:
10
    MOV DPTR, #MESSAGE      ; 字符串地址
11
    MOV R2, #0              ; 字符索引
12
READ_LOOP:
13
    MOV A, R2               ; 索引到A
14
    MOVC A, @A+DPTR         ; 读取字符
15
    JZ END_OF_STRING        ; 如果是0，字符串结束
16
    ; 处理字符...
17
    INC R2                  ; 下一个字符
18
    SJMP READ_LOOP
19
END_OF_STRING:
20
    RET

2. 访问RAM中的数组#

1
; 通过索引访问数组元素
2
ACCESS_ARRAY_ELEMENT:
3
    ; 参数：R7 = 数组索引
4
    ; 返回：A = 数组元素
5

6
    MOV A, R7              ; 索引到A
7
    ADD A, #BUFFER         ; 计算实际地址
8
    MOV R0, A              ; R0指向数组元素
9
    MOV A, @R0             ; 读取数组元素
10
    RET
11

12
; 遍历数组（求数组元素之和）
13
SUM_ARRAY:
14
    MOV R0, #BUFFER        ; 数组起始地址
15
    MOV R2, #16            ; 数组长度
16
    CLR A                  ; 累加器清零
17
    CLR B                  ; 进位清零
18
SUM_LOOP:
19
    ADD A, @R0             ; 累加数组元素
20
    JNC NO_CARRY
21
    INC B                  ; 处理进位
22
NO_CARRY:
23
    INC R0                 ; 下一个元素
24
    DJNZ R2, SUM_LOOP
25

26
    ; 结果：A=低8位，B=高8位（进位）
27
    RET

3. 多维数组访问#

1
; 二维数组（3x4矩阵）
2
MATRIX_ROWS   EQU    3
3
MATRIX_COLS   EQU    4
4
MATRIX_SIZE   EQU    MATRIX_ROWS * MATRIX_COLS
5

6
MATRIX: DS MATRIX_SIZE     ; 3x4矩阵
7

8
; 访问MATRIX[row][col]
9
; 参数：R6 = 行号(0-2), R7 = 列号(0-3)
10
; 返回：A = MATRIX[row][col]
11
ACCESS_MATRIX:
12
    MOV A, R6              ; 行号
13
    MOV B, #MATRIX_COLS    ; 每行4列
14
    MUL AB                 ; A = 行号 * 4
15
    ADD A, R7              ; + 列号
16
    ADD A, #MATRIX         ; + 矩阵基址
17
    MOV R0, A              ; R0指向矩阵元素
18
    MOV A, @R0             ; 读取元素
19
    RET

结构体类型的数据组织#

1. 定义数据结构#

1
; 定义学生记录结构
2
STUDENT_SIZE EQU 4
3
STUDENT_AGE   EQU 0     ; 偏移0：年龄
4
STUDENT_GRADE EQU 1     ; 偏移1：成绩
5
STUDENT_ID_H  EQU 2     ; 偏移2：ID高字节
6
STUDENT_ID_L  EQU 3     ; 偏移3：ID低字节
7

8
; 学生数组（3个学生）
9
STUDENTS: DS STUDENT_SIZE * 3
10

11
; 常量学生数据（ROM中的模板）
12
STUDENT_TEMPLATE:
13
    DB 18, 85, 0, 1      ; 学生1：18岁，成绩85，ID=0001
14
    DB 19, 90, 0, 2      ; 学生2：19岁，成绩90，ID=0002
15
    DB 20, 78, 0, 3      ; 学生3：20岁，成绩78，ID=0003

2. 访问结构体数组#

1
; 获取第n个学生的成绩
2
; 参数：R7 = 学生索引(0-2)
3
; 返回：A = 成绩
4
GET_STUDENT_GRADE:
5
    MOV A, R7              ; 学生索引
6
    MOV B, #STUDENT_SIZE   ; 每个学生大小
7
    MUL AB                 ; A = 索引 * 4
8
    ADD A, #STUDENTS       ; + 基址
9
    ADD A, #STUDENT_GRADE  ; + 成绩偏移
10
    MOV R0, A              ; R0指向成绩字段
11
    MOV A, @R0             ; 读取成绩
12
    RET
13

14
; 初始化学生数组
15
INIT_STUDENTS:
16
    MOV DPTR, #STUDENT_TEMPLATE
17
    MOV R0, #STUDENTS      ; RAM目标地址
18
    MOV R2, #3             ; 3个学生
19
INIT_STU_LOOP1:
20
    MOV R3, #STUDENT_SIZE  ; 每个学生4字节
21
INIT_STU_LOOP2:
22
    CLR A
23
    MOVC A, @A+DPTR        ; 从ROM读取
24
    MOV @R0, A             ; 写入RAM
25
    INC DPTR
26
    INC R0
27
    DJNZ R3, INIT_STU_LOOP2
28
    DJNZ R2, INIT_STU_LOOP1
29
    RET

高级技巧：使用宏和标号#

1. 定义带类型的数组访问宏#

1
; 定义数组访问宏
2
ARRAY_GET MACRO ARRAY_NAME, INDEX, DEST
3
    MOV A, INDEX
4
    ADD A, #ARRAY_NAME
5
    MOV R0, A
6
    MOV DEST, @R0
7
    ENDM
8

9
ARRAY_SET MACRO ARRAY_NAME, INDEX, SRC
10
    MOV A, INDEX
11
    ADD A, #ARRAY_NAME
12
    MOV R0, A
13
    MOV @R0, SRC
14
    ENDM
15

16
; 使用宏
17
    MOV R1, #2            ; 索引2
18
    ARRAY_GET BUFFER, R1, A    ; A = BUFFER[2]
19

20
    MOV R1, #3
21
    MOV R2, #0FFH
22
    ARRAY_SET BUFFER, R1, R2   ; BUFFER[3] = 0FFH

2. 使用标号计算数组大小#

1
; 自动计算数组大小
2
CONST_ARRAY_START:
3
    DB 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
4
CONST_ARRAY_END:
5

6
CONST_ARRAY_SIZE EQU CONST_ARRAY_END - CONST_ARRAY_START
7

8
; 编译时会计算：CONST_ARRAY_SIZE = 10

完整示例程序#

1
; 定义常数
2
ORG 1000H
3
PI:          DB    22, 7          ; π ≈ 22/7
4
DAYS_IN_MONTH:
5
    DB 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
6

7
; 定义RAM变量
8
ORG 30H
9
TEMPERATURES: DS   24      ; 24小时温度数据
10
DAILY_MAX:    DS   1       ; 日最高温度
11
DAILY_MIN:    DS   1       ; 日最低温度
12

13
; 主程序
14
ORG 0000H
15
    MOV SP, #60H
16

17
    ; 初始化温度数组为20°C
18
    CALL INIT_TEMP_ARRAY
19

20
    ; 读取下午2点的温度（索引14）
21
    MOV R7, #14
22
    CALL GET_TEMPERATURE   ; A = TEMPERATURES[14]
23

24
    ; 查找最高温度
25
    CALL FIND_MAX_TEMP     ; A = 最高温度
26
    MOV DAILY_MAX, A
27

28
    ; 使用常数表：获取7月的天数
29
    MOV DPTR, #DAYS_IN_MONTH
30
    MOV A, #6              ; 7月是第7个月，索引6
31
    MOVC A, @A+DPTR        ; A = 31
32

33
    SJMP $
34

35
; 初始化温度数组
36
INIT_TEMP_ARRAY:
37
    MOV R0, #TEMPERATURES
38
    MOV R2, #24
39
    MOV R3, #20            ; 初始温度20°C
40
INIT_TEMP_LOOP:
41
    MOV @R0, R3
42
    INC R0
43
    DJNZ R2, INIT_TEMP_LOOP
44
    RET
45

46
; 获取温度值
47
GET_TEMPERATURE:      ; R7 = 小时(0-23)
48
    MOV A, R7
49
    ADD A, #TEMPERATURES
50
    MOV R0, A
51
    MOV A, @R0
52
    RET
53

54
; 查找最高温度
55
FIND_MAX_TEMP:
56
    MOV R0, #TEMPERATURES
57
    MOV R2, #24
58
    CLR A                ; A = 0（当前最大值）
59
FIND_MAX_LOOP:
60
    MOV B, @R0
61
    CJNE A, B, COMPARE
62
COMPARE:
63
    JNC NOT_HIGHER       ; 如果A >= B，跳过
64
    MOV A, B             ; 更新最大值
65
NOT_HIGHER:
66
    INC R0
67
    DJNZ R2, FIND_MAX_LOOP
68
    RET