王爽汇编语言第三版第10章 call 和 ret 指令以及子程序设计

一时失言乱红尘 2024-04-18 19:44 3阅读 0赞

# 第10章 call 和 ret 指令 #

## 10.1 ret 和 reft 指令 ##

call 和 ret 指令都是转移指令，他们都修改 IP，或同事修改 CS 和 IP 。他们经常被共同来实现子程序的设计。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70][]

## 10.2 call 指令 和 **根据位移 **转移的call指令 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 1][]

## 段间转移 的 call 指令 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 2][]

## 转移地址 在 寄存器 中 的 call 指令 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 3][]

## 转移地址在内存 中 的 call 指令 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 6][]

## 10.7 call 和 ret 的配合使用 来 **实现子程序** ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 7][]

### 子程序 框架 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 8][]

## 10.8 乘法指令 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 9][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 10][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 11][]

## 10.12 寄存器的冲突问题 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 12][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 13][]

# 实验 10 解析 #

王爽《汇编语言》(第三版)实验10解析：[https://www.cnblogs.com/nojacky/p/9523904.html][https_www.cnblogs.com_nojacky_p_9523904.html]

## 1. 显示字符串 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 14][]

示例代码：

assume cs:code
    
    datasg segment
        db 'welcome to masm!', 0
    datasg ends
    
    code segment
    
        start:  
            mov dh, 8
            mov dl, 3
            mov cl, 2
            mov ax, datasg
            mov ds, ax
            mov si, 0
            call show_str
            mov ax, 4c00h
            int 21h
                
        show_str:   
            push dx                
            push cx        
            push si     ; 保护子程序寄存器中用到的寄存器
                        ; 由于主程序的限定
                        ; 这里由CPU自动为我们分配栈空间
                        
            
            mov di, 0    ; 显示缓存区中的偏移量
            mov bl, dh   
            dec bl       ; bl-1才是真正的行，因为行号从0开始计数
            mov al, 160  
            mul bl       ; 每行160字节 用 行数*每行偏移量 得到目标行的偏移量
            mov bx, ax   ; mul bl之后，乘积存储在ax中，这里要转存入bx中
            mov al, 2    ; 列的偏移量为2，两个字节代表一列！！！
            mul dl       ; 与行偏移量同理
            add bl, al   ; 将列偏移量与行偏移量相加，得到指定位置的偏移量。
            
            mov ax, 0b800h
            mov es, ax   ; 指定显示缓存区的内存位置
            
            mov al, cl   ; 由于后面jcxz语句的判断要用到cx，所以我们要将
                         ; cl(颜色)先存下来。
        s:     
            mov ch, 0
            mov cl, ds:[si]     ; 首先将当前指向字符串的某个字符存入cx中
            jcxz ok             ; 如果cx为0，则转移到ok标号执行相应代码
            mov es:[bx+di],cl   ; 将字符传入低地址
            mov es:[bx+di+1],al ; 将颜色传入高地址
            add di, 2    ; 列偏移量为2
            inc si       ; 字符串的偏移量为1
            loop s       ; 不为0,继续复制
        
        ok:     
            pop dx      
            pop cx
            pop si      ; 还原寄存器变量
            ret         ; 结束子程序调用
    code ends
        
    end start

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 15][]

示例代码 2：

data segment
            db 'Welcome to masm!',0
    data ends
    
    code segment
            assume cs:code,ds:data
    start:
            mov dh,1              ;dh装行号(范围:1--25)
            mov dl,1              ;dl装列号(范围:1--80)[注:每超过80等于行号自动加1]
            mov cl,0cah           ;cl中存放颜色属性(0cah为红底高亮闪烁绿色属性)
            mov ax,data
            mov ds,ax
            mov si,0
            call show_str
            mov ax,4c00h
            int 21h  
    
    show_str:   ;显示字符串的子程序[定义开始]
            push cx
            push si
            mov al,0A0h
            dec dh          ;行号在显存中下标从0开始,所以减1
            mul dh
            mov bx,ax
            mov al,2
            mul dl
            sub ax,2       ;列号在显存中下标从0开始,又因为偶字节存放字符,所以减2
            add bx,ax      ;此时bx中存放的是行与列号的偏移地址
            mov ax,0B800h
            mov es,ax      ;es中存放的是显存的第0页(共0--7页)的起始的段地址
            mov di,0
            mov al,cl
            mov ch,0
    s:      mov cl,ds:[si]
            jcxz ok
            mov es:[bx+di],cl       ;偶地址存放字符
            mov es:[bx+di+1],al     ;奇地址存放字符的颜色属性
            inc si
            add di,2
            jmp short s
    ok:     pop si
            pop cx
            ret    ;显示字符串的子程序[定义结束]
    code ends
    
    end start

## 2. 解决除法溢出的问题 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 16][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 17][]

示例代码：

assume cs:code,ss:stack
    
    stack segment
            dw 8 dup(0)
    stack ends
    
    code segment
    start:
            mov ax, stack
            mov ss, ax
            mov sp, 10h
            mov ax, 4240h
            mov dx, 0fh
            mov cx, 0ah      
            call divdw
            mov ax, 4c00h
            int 21h
             
    divdw:  ;子程序定义开始
            push ax
            mov ax, dx
            mov dx, 0
            div cx
            mov bx, ax
            pop ax
            div cx
            mov cx, dx
            mov dx, bx
            ret   ;子程序定义结束
    code ends
    
    end start

测试1：   
计算：1000000/10(F4240H/0AH) 商：100000(186A0H) 余数：0   
调试结果：

![这里写图片描述][70]

测试2：   
计算：1000020/11(F4254H/0BH) 商：90910(1631EH) 余数：10(0AH)   
调试结果：

![这里写图片描述][70 1]

## 3. 数值显示 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 18][]

示例代码：

assume cs:code,ds:data
    
    
    data segment
        db 10 dup (0)
    data ends
    
    code segment
    start:
            mov ax,12666
            mov bx,data
            mov ds,bx
            mov si,0
            call dtoc 
            mov dh,8
            mov dl,3
            mov cl,0cah
            call show_str
            mov ax,4c00h
            int 21h
    dtoc:  ;数值显示的子程序定义
            push dx
            push cx
            push ax
            push si
            push bx
            mov bx,0
    s1:     mov cx,10d
            mov dx,0
            div cx        
            mov cx,ax
            jcxz s2
            add dx,30h
            push dx
            inc bx
            jmp short s1
    s2:     add dx,30h
            push dx
            inc bx     ;再进行一次栈操作(补充当"商为零而余数不为零"时的情况)
            mov cx,bx
            mov si,0
    s3:     pop ax
            mov [si],al
            inc si
            loop s3
    okay:   pop bx
            pop si
            pop ax
            pop cx
            pop dx
            ret   ;数值显示的子程序定义结束
    show_str:  ;显示字符串的子程序已经在第一题中说明，在此不再赘述。
            push bx
            push cx
            push si
            mov al,0A0h
            dec dh
            mul dh
            mov bx,ax
            mov al,2
            mul dl
            sub ax,2
            add bx,ax
            mov ax,0B800h
            mov es,ax
            mov di,0
            mov al,cl
            mov ch,0
    s:      mov cl,ds:[si]
            jcxz ok
            mov es:[bx+di],cl
            mov es:[bx+di+1],al
            inc si
            add di,2
            jmp short s
    ok:     pop si
            pop cx
            pop bx
            ret
    code ends
    end start

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 19][]

详解版：

源地址：[https://blog.csdn.net/include\_heqile/article/details/80602772][https_blog.csdn.net_include_heqile_article_details_80602772]

assume cs:code
    
        data segment
            dw 123, 12666, 1, 8, 3, 38
        data ends
    
        ascii segment
            db 100 dup(0)
            ;ascii码值，一个字节即可存储
        ascii ends
    
        div segment
            dw 16 dup(0)
            ;除法溢出计算需要使用该数据段来临时保存结果
        div ends
    
        code segment
        start:      mov bx, data
                    mov ds, bx
                    ;ds段寄存器用来存放待处理的数据
                    mov si, 0
                    call dtoc
    
                    mov cx, 6
                    mov ax, 0
                    mov dh, 8
        show:       push cx
                    mov dl, 3
                    mov cl, 2
                    call show_str
                    pop cx
                    ;我们需要更改行号来避免覆盖
                    inc dh
                    loop show
                    mov ax, 4c00h
                    int 21h 
    
        dtoc:       ;该子程序用于将数值型的数字转换为字符串
                    ;十进制数值转换为ASCII码值，转换关系为：ascii=10进制+30H
                    ;要想将一个十进制的整数拆分成一个一个的数值，那我们需要让这个数
                    ;除以10，然后将得到的结果依次入栈，除完之后再依次出栈，即可得到由高位到低位
                    ;的所有数值，之后将这些值加上30H，即得到其对应的ASCII码值，然后将这些
                    ;ASCII码值存放到一个数据段中，调用show_str函数，来在屏幕上显示这些数值
                    ;为了存储转换后的ASCII码值，我们需要新开辟一个数据段
                    push ax
                    push bx
                    push cx
                    push dx
                    push ds
                    push si
                    push es
    
                    mov ax, ascii
                    mov es, ax
                    ;使用es段寄存器来存储转换后的ascii码值
                    mov di, 0
                    ;存储ASCII数据时用来指向ascii段中的每个内存单元 
                    mov cx, 6
        loop_zone:  push cx
                    ;因为内层循环会更改cx的值，所以我们需要使用栈结构来保存cx的值
                    mov dx, 0
                    ;记录十进制数据的位数
                    mov ax, ds:[si]
                    ;ax存放被除数
        split:      push dx
                    ;下面要用到dx寄存器，因此我们先保存dx
                    mov cx, 0ah
                    ;cx存放除数 
                    mov dx, 0
                    ;dx作为被除数高16位，置0
                    div cx
                    ;32/16的除法运算，商存储在ax中，余数存储在dx中
                    mov cx, dx
                    ;call divdw
                    ;其实用不着调用divdw，这个除法溢出问题不是真正的除法溢出问题
                    ;我们只需要将被除数凑成32位的，除数当做16位的即可
                    ;此程序返回运算后的商和余数，分别保存在ax和cx中
    
                    ;如果被除数大于2550，al是无法存放商的，会造成溢出，因此，我们需要调用本实验中第二个函数
                    ;专门用于解决除法溢出问题的函数，虽然程序2解决的是32/16的除法运算的溢出问题，但是对于16/8位的
                    ;除法运算也是完全适用的
    
                    ;由于入栈时只能使用字型数据，所以我们压入的是ax，此时需要将
                    ;无关数据，也就是al置0
                    pop dx
                    ;取出dx更改前的值
                    push cx
                    ;余数入栈
                    inc dx
                    ;当循环终止的时候可以进行弹栈存储操作了，但是我们需要一个标记，来标识我们需要
                    ;弹出多少次，我们使用dx来进行存储
                    mov cx, ax
                    add cx, dx
                    ;ax中的值在下一次运算中一定会用到，dx中的值也有可能会用到（当被除数很大时）
                    ;此时可以临时保存数据的只有cx了，因此我们直接将运算结果放到cx中
                    ;一举两得
                    jcxz ok1
                    ;处理过程是需要循环的，循环结束的条件是商==0 
                    ;我们只需要将执行jcxz指令即可，当cx的值位0的时候，它会自动跳转到ok1循环的
                    jmp short split 
    
        ok1:        pop ax
                    add al, 30h
                    mov byte ptr es:[di], al
                    inc di
                    dec dx
                    mov cx, dx
                    jcxz last
                    jmp short ok1
    
        last:       ;最后一步，在数据的ASCII数据形式的最后加上一个0
                    mov ah, 0
                    mov byte ptr es:[di], ah 
                    inc di
                    ;从split到ok1到最后一步是对data段中第一个数据的处理
                    ;这个过程需要进行循环操作
                    ;在这个循环中，di，bx是放在循环外的
                    pop cx
                    add si, 2
                    loop loop_zone
    
                    pop es
                    pop si
                    pop ds
                    pop dx
                    pop bx
                    pop cx
                    pop ax
                    ret
    
        divdw:      push ds
                    push dx
                    push cx
                    push ax 
    
                    mov ax, div
                    mov ds, ax
                    mov dx, 0
                    ;由于本程序中被除数是16位，但是divdw是32/16，所以我们需要将被除数的高位补16个0，也就是将dx置0
                    mov ax, dx
                    mov dx, 0
                    div cx
                    ;ax存放商，dx存放余数
                    ;根据公式，使用被除数高位除以除数得到的商×65536
                    ;*65536等价于在低位加16个0，因此操作就会变得非常简单
                    ;使用被除数高位除以除数得到的余数×65536+被除数的低位，再将得到的结果除以除数
                    ;两者的结果相加，即可得到32位/16位的无溢出结果
                    push dx
                    ;使用栈临时保存余数
                    mov dx, ax
                    mov ax, 0
                    mov ds:[0], ax
                    mov ds:[2], dx
                    pop dx
                    ;弹出余数，作为右操作数中被除数的高16位
                    pop bx
                    ;得到被除数的低16位
                    push bx
                    ;恢复栈顶数据，避免对主程序造成干扰
                    ;add ax, bx
                    ;将右操作数[]中的左操作数的低16位和被除数的低16位相加
                    ;但是右操作数[]中的左操作数的低16位一定是全0的，因此我们可以省略这一步
                    ;直接执行mov ax, bx
                    mov ax, bx
                    div cx
                    ;ax存放商，dx存放余数
                    ;由于左操作数的低16位一定是全0，所以不必与其相加，直接将
                    ;右操作数的低16位存储到ds:[0]内存单元即可
                    mov ds:[0], ax
                    ;商的低16位放到ds:[0]单元中
                    mov ds:[4], dx  
                    ;余数放到ds:[4]单元中
                    ;ds:[2]中一直保存的都是商的高16位，且没有被更改过，因此无须任何操作
    
                    pop ax
                    pop cx
                    pop dx
                    mov ax, ds:[0]
                    ;ax保存商的低16位
                    mov dx, ds:[2]
                    ;dx保存商的高16位
                    mov cx, ds:[4]
                    ;cx保存余数  
                    pop ds
                    ;之所以要在pop ds之前将数据转移，是因为子程序divdw调用前，ds已经被使用
                    ;指向的是其他的段，如果不在pop之前转移数据，那么div段的数据就无法获取了
                    ret
    
        show_str:   push bx
                    push cx
                    push dx
                    push ds
                    push es
                    push di
                    push ax
                    push si
                    ;根据上节中的框架，为了不让子程序干扰主程序中寄存器的值，将所有子程序会用到的寄存器进行压栈
    
                    mov di, ax
                    mov ax, 0b800h
                    mov es, ax
                    ;颜色区的段地址
                    mov ax, ascii
                    mov ds, ax
                    ;待输出的ASCII码值数据段
                    mov al, 160 
                    mul dh
                    ;每行占160个字节，乘以行数
                    push ax
                    ;将行计算的结果存储到栈中
                    mov al, 2
                    mul dl
                    ;每列占2个字节，乘以列数
                    pop bx
                    ;将上次运算的结果（160×行数）的值转移到bx中
                    add bx, ax  ;此时的ax值为（2×列数）
                    ;将两者相加，最终结果保存到bx中
                    mov dl, cl
                    ;因为下面的跳转指令jcxz需要用到cx寄存器，故需要将cl的值先保存在dl中
    
        change:     mov cl, ds:[di]
                    mov ch, 0 
                    inc di
                    ;我们需要记录下di的值，下一轮循环还会用到它
                    ;这样一来，我们就需要调整入栈和出栈寄存器的位置了
                    ;我们在pop di之前pop ax，然后使用ax来保存di的值
                    jcxz ok2
                    mov ch, dl 
                    mov es:[bx+si], cx
                    add si, 2
                    jmp short change
    
        ok2:        pop si
                    pop ax
                    mov ax, di
                    pop di
                    pop es
                    pop ds
                    pop dx
                    pop cx
                    pop bx 
                    ret
        code ends
        end start

![这里写图片描述][70 2]

示例代码 2：

assume cs:code,ds:data
    
    data segment
    	db 10 dup(0)
    data ends
    
    code segment
    start:
    	mov ax,12666
    	mov bx,data
    	mov ds,bx
    	mov si,0
    	
    	call dtoc
    
    	mov dh,8
    	mov dl,3
    	mov cl,02h
    	
    	call show_str
    	
    	mov ax,4c00H
    	int 21H
    	
    dtoc:
    	push dx
    	push cx
    	push ax
    	push si
    	push bx
    	mov bx,0	;bx在子程序中用来存放位数,用栈来临时存放修改后的字符
    	
    dtoc00:
    	mov cx,10d	;d表示十进制
    	mov dx,0
    	div cx		;除以10
    	mov cx,ax	;得到的商赋给cx
    	
    	jcxz dtoc01		;当前商为0则调到s2
    	
    	add dx,30H	;将余数加上30H得到相应的ASCII码
    	push dx
    	
    	inc bx
    	
    	jmp short dtoc00
    	
    dtoc01:				;当商为0时,余数为个位
    	add dx,30H
    	push dx
    	
    	inc bx		;再进行一次栈操作(补充当商为0而余数不为0时的情况)
    	
    	mov cx,bx 
    	mov si,0
    	
    dtoc02:				;s3实现将栈中的数据依次出栈放到制定内存中
    	pop ax
    	
    	mov [si],al
    	inc si
    	
    	loop dtoc02
    	
    dtoc03:
    	pop bx
    	pop si
    	pop ax
    	pop cx
    	pop dx
    	
    	ret
    	
    show_str:	;显示字符串的子程序(定义开始)
    	push cx
    	push si
    	
    	mov al,0a0H	;每行为160字节 a0H=160
    	
    	dec dh	;行号在显存中下标从0开始,所以减1
    	mul dh	;相当于从(n-1)*0a0H个Byte单元开始
    	
    	mov bx,ax	;定位好的位置偏移地址存放在bx里面(行)
    	
    	mov al,2	;每个字符占两个字节
    	mul dl	;定位列,结果ax存放的是定位好的列的位置
    	sub ax,2	;列号在显存中下标从0开始,又因为偶字节存放字符,所以减2
    	
    	add bx,ax	;此时bx存放的是行与列的偏移地址
    	
    	mov ax,0b800H
    	mov es,ax
    	
    	mov di,0	;指向显存的偏移地址
    	
    	mov al,cl	;cl是存放颜色的参数,这时候al存放颜色了
    	
    	mov ch,0	;下边cx存放的是每次准备处理的字符
    	
    show_str00:
    	mov cl,ds:[si]	;ds:[si]指向'Weclome to masm!'
    	
    	jcxz show_str01
    	
    	mov es:[bx+di],cl	;偶数地址存放字符
    	mov es:[bx+di+1],al	;奇数地址存放颜色属性
    	
    	inc si
    	
    	add di,2
    	jmp short show_str00 
    	
    show_str01:
    	pop si
    	pop cx
    	
    	ret
    	
    
    code ends
    end start

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/a881062fe97d4eafb4f5378375dc7e41.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ae764136abd74dafbd41a8334b993e98.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/d9043c01eb12446ca4a80a44ad32726a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/84a24a7eb0ab46788afe7e9cd3df410e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/fd23a4a16fb64461ae931512b3be4259.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/5e91a0f70deb40088ac551cc29346c4f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/49d63eb6343242b3975a698bd0b5db91.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ddec84b07c0f44788c94e211e45e2e55.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/b87e46684c814b9183fb66366160e9bc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/4227d4e47f1a49049432d3a470e4907c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/c785766ab7ad4cc79157124dfadc88a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/9c5faa129d894401a3a93bbbaf29d45f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/10b7a11658bb4da895f54375cf4d8de8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/a82ea071f30a4722acbfbb720c522e4e.png
[https_www.cnblogs.com_nojacky_p_9523904.html]: https://www.cnblogs.com/nojacky/p/9523904.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 14]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/e4d9073b26c742bebfe81ec81f46fba8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 15]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/f9cdfe99fc7f4585a379d4ee136fde3b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/b136f4ea7b384a9199f39d8fe9d46ac2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 17]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/88f1c5342b544d5fa238fa5820d0619e.png
[70]: https://img-blog.csdn.net/20180901091937189?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpbmdfeGlhb2xlaTE5ODgxMDA5/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 1]: https://img-blog.csdn.net/2018090109221620?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpbmdfeGlhb2xlaTE5ODgxMDA5/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 18]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/9d3b8c0b2fb445c7a0ff84af4392b54d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 19]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/31b677b8bf5c4f4b9fa100b9bf3280e0.png
[https_blog.csdn.net_include_heqile_article_details_80602772]: https://blog.csdn.net/include_heqile/article/details/80602772
[70 2]: https://img-blog.csdn.net/20180608115455104?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2luY2x1ZGVfaGVxaWxl/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70