arm汇编之冒泡排序
汇编--BubbleSort(冒泡排序)
一、实验目的1. 掌握循环程序的设计方法；2. 了解循环结构在程序中的重要作用起泡排序程序。
二、实验原理及基本技术路线图（方框原理图）循环结构分DO_WHILE和DO_UNTIL两种，无论使用哪种循环结构，循环程序一般应包括以下几部分：①循环初始化。
它包括设置循环次数的初始值、地址指针的初始设置等。
②循环体。
这是循环工作的主体，包括要重复执行的操作，以及循环的修改部分。
修改部分包括地址指针的修改、循环控制条件的修改等。
③循环控制部分。
它是控制循环的关键，判断循环条件满足与否。
特别要注意循环入口和循环次数的正确设置、地址指针及循环控制条件的修改等。
否则会得不到期望的结果。
以下为冒泡算法的流程图：三、所用仪器、材料（设备名称、型号、规格等）1. 操作系统平台：Windows Server 20032. 汇编环境：Microsoft MASM 5.03. 文本编辑器：记事本四、实验方法、步骤1. 将MASM5.0的文件置于C:\assembly\目录下；2. 将masm.exe和link.exe所在目录（C:\assembly\MASM5）添加到Path环境变量中；3.在C:\assembly\下新建一个bubble.asm文件，打开bubble.asm，输入汇编程序代码；4. 运行一个命令行窗口，将当前目录切换到C:\assembly\，然后输入命令：masm bubble.asm [Enter]，来汇编程序，根据汇编结果查看程序代码是否有语法错误，如有，则更正保存后重新汇编，直至没有错误为止，此时会生成bubble.obj文件；5. 输入命令：link bubble.obj [Enter]，观察输出结果，如果没有错误，则生成bubble.exe；6. 输入命令：debug bubble.exe [Enter]，调试程序，并记录运行过程；7. 完成实验报告。
五、实验过程原始记录(数据、图表、计算等)1. 将C:\assembly\MASM5目录添加到Path环境变量中：2. 新建名为bubble.asm的文件，输入汇编程序代码：程序源码：STACKSG SEGMENT STACK 'S'DW 64 DUP('ST')STACKSG ENDSDATA SEGMENTARY DW 5,7,1,4,3,6,9,8,2 ;数组,流程图中为ACT EQU ($-ARY)/2 ;元素个数DATA ENDSCODE SEGMENTASSUME CS:CODE, DS:DATA, SS:STACKSG MAIN PROC FARMOV AX,DATAMOV DS,AXMOV DI,CT-1 ;初始化外循环次数LOP1: MOV CX,DI ;置内循环次数MOV BX,0 ;置地址指针LOP2: MOV AX,ARY[BX]CMP AX,ARY[BX+2] ;两数比较JGE CONT ;次序正确转XCHG AX,ARY[BX+2] ;次序不正确互换位置MOV ARY[BX],AXCONT: ADD BX,2 ;修改地址指针LOOP LOP2 ;内循环控制DEC DI ;修改外循环次数JNZ LOP1 ;外循环控制MOV AX,4C00HINT 21HMAIN ENDPCODE ENDSEND MAIN3. 汇编源程序：4. 连接生成可执行文件：5.调试程序：（1）初始化外循环次数(DI)=0008H（2）置内循环次数和地址指针（3）第一趟第一次比较，因为5＜7，故互换位置，进行下一次比较（5）修改地址指针，继续内循环（6）第一趟第二次比较，因为5＞1，故直接更改地址指针，进行下一次比较（7）第一趟第三次比较，因为1＜4，故互换位置，进行下一次比较（8）第一趟第四次比较，因为1＜3，故互换位置，进行下一次比较（9）第一趟第五次比较，因为1＜6，故互换位置，进行下一次比较（10）第一趟第六次比较，因为1＜9，故互换位置，进行下一次比较（11）第一趟第七次比较，因为1＜8，故互换位置，进行下一次比较（12）第一趟第八次比较，因为1＜2，故互换位置（13）第一趟循环结束，最小数1被交换至数组的最后位置（14）第二趟循环结束，次小数2被交换至数组的倒数第二个位置（15）第三趟循环结束，数字3归位（16）第四趟循环结束，数字4归位（17）第五趟循环结束，数字5归位（19）第七趟循环结束，数字7归位（20）第八趟循环结束，数字8归位（22）排序结束，程序退出六、实验结果、分析和结论（误差分析与数据处理、成果总结等。
ARM汇编实验报告
《嵌入式系统原理与应用B》课程实验报告ARM汇编语言编程与调试要求完成的主要实验1、给出的数据中寻找最大、最小数问题2、两种求和运算的编程与调试3、第四章作业第9题4、排序冒泡程序的调试与总结5、第四章作业第11题说明：标注完成的实验，未完成的给予说明专业名称：通信工程班级：1510班学生姓名：石龙飞学号（8位）：03151307指导教师：刘钊远给出的数据中寻找最大、最小数问题一、实验目的1、学习汇编软件的安装、使用，熟悉汇编环境。
2、学会使用汇编软件，如何新建一个工程，如何书写源代码，如何进行链接、编译，以及如何调试。
3、尝试一些简单的指令，学会用汇编指令写一些简单的程序。
二、实验内容编写一个汇编程序，要求在给定的一组数中找到最大数和最小数。
三、实验主要步骤1、首先建立一个工程2、再新建.s的源文件，添加到工程中3、编写源代码，这里主要是实现在一组数中寻找最大数和最小数，最后将找到的两个数放到相应的寄存器中。
4、进行链接编译，看看有没有语法的错误，如果有错误编译器会提示错误的类型以及在哪里出错。
5、进行debug调试，查找代码中的逻辑错误，若无逻辑错误，可在debug界面查看运行结果，其最需要的关注的几个地方是菜单栏的一组运行按钮、源码执行的步骤以及断点、左边的寄存器状态、下方的存储器状态，将这些综合起来，就可以很明确的回到程序如何运行，运行结果如何。
四、实验代码五、实验总结与分析1、实验结果分析其中用红色方框框起来的是最后程序运行的结果，也就是在R3中保存了最小数在R2中保存了最大数，完成了实验要求。
2、在用汇编语言编程之前首先要看看有没有汇编软件ADS、没有的话需要安装，Windows XP安装起来比较简单，只需要点击setup，一直点击写一部就可以，但是如果是Windows 7或者更高版本的话就需要在setup的属性里点击兼容Windows XP，运行时以管理员身份运行才能正确进行安装。
ARMC语言调用汇编函数实现冒泡排序
ARMC语⾔调⽤汇编函数实现冒泡排序使⽤冒泡排序将指定数组排序后输出排序函数使⽤汇编语⾔编写，C语⾔调⽤汇编语⾔在控制台显⽰排序前后的结果⼀、问题分析本程序的关键是如何使⽤汇编语⾔实现冒泡排序算法。
可以仿照C语⾔的代码流程，分步骤写出汇编的代码。
⾸先要写出最内层的代码部分，也就是数据交换的汇编代码，数据交换可以使⽤str数据装载指令实现。
之后要考虑内层循环的代码，可以通过cmp指令控制循环次数。
最后是编写最外层的循环代码，也是使⽤cmp指令，来控制整个排序的次数。
⼆、代码编写2.1 C语⾔代码#include <stdio.h>extern void sort(char* num, int count);int main(){char number[10] = {'a', 'c', 'b', 'e', 'd', 'f', 'h', 'g', 'j', 'i'};printf("Before: %s\n", number);sort(number, 10);printf("After: %s\n", number);return 0;}C语⾔中⽐较重要的是，⾸先要声明外部函数sort，也就是由汇编代码实现的函数。
其代码流程为：初始化1个10字节的char类型的数组在控制台输出初始化的数据调⽤汇编函数进⾏排序显⽰排序后的结果2.2 汇编代码area sort, code, readonlyglobal sortstartmov r2, #-1 ; r2->i, i=-1sub r8, r1, #1 ; r1->countloopcmp r2, r8 ; 控制外层循环bge stopadd r2,r2, #1 ; i=i+1mov r3, #-1 ; r3=j, j=-1loop0add r3, r3, #1 ; j=j+1add r4, r3, #1 ; r4=j+1sub r7, r8, r2 ; 控制内层循环cmp r3, r7bge loopldrb r5, [r0, r3] ; r5=a[j]ldrb r6, [r0, r4] ; r6=a[j+1]cmp r5, r6 ; ⽐较 a[j] 和 a[j+1]blt loop0swapstrb r5, [r0, r4] ; 交换 a[j] 和 a[j+1]strb r6, [r0, r3]b loop0stopend汇编语⾔代码是仿照的C语⾔的冒泡排序流程实现的，其⼤致流程为：⾸先初始化R2，R2⽤来控制外层循环的次数。
史上最牛最完整的汇编语言冒泡排序程序
;题目：编制一个完整的汇编语言程序，从键盘上读入若干个（可以超过十个）十进制数（正数），排序后在屏幕上输出。
;采用冒泡法排序，综合运用子程序和宏汇编，使程序模块化。
;程序代码M_DIRECT MACRO STRING ;定义一个宏，调用09 号DoS功能在屏幕上显示一个字符串MoV DX,oFFSETAH,O921H STRINGMoVINTENDMDATA SEGMENTDIR1 DB 'count of numbers tosort:$ ' ;提示输入要排序的数据的个数DIR2 DB 'please input sorting numbers:$ '; 提示输入要排序的数据DIR3 DB 'sorting result:$ ' ;在屏幕上提示排好续的数据DIR4 DB '*************************$ 'DIR5 DB 'please choose u(up)ord(down):$ 'DIR6 DB 'input error$ 'CoUNT=1OOWTEMP DW ?ARRAY DW CoUNT DUP(?) ;用来保存输入的数据CRLF DB 13,1O, '$ ' ;实现回车换行的功能,13→ODH,回车；10→OAH,换行LENDW;保存实际输入的数据的个数DATA ENDSCoDE SEGMENTMAIN PRoC FARASSUME CS:CoDE,DS:DATASTART:PUSH DSSUBAX,AXPUSH ;置AX 为OAXMOVAX,DATA ;将数据段的地址送到DX 中MOV DS,AXREAD: M_DIRECT DIR1 ; 宏调用，在屏幕上提示输入要输入的数据的个数CALLP_GETNEW ；调用子程序P-GETNEW输入要输入的数据的个数MOV CX,AXMOV LEN,AXLEA BX,ARRAYMOVAH,09; 调用09 号功能，实现回车换行LEA DX,CRLFINT21H ;屏幕提示输入要排序的数据M_DIRECT DIR2GETNUMBER: CALL P_GETNEW ; 输入数据并保存到ARRA 丫中MOV [BX],AXADD BX ,2LOOP GETNUMBERCX,LENSORT:; 排序程序部分MOV DEC CXMOV AH,09HLEA DX,CRLFINT21HM_DIRECT DIR5COMPARE:MOV AH,01HINT21HCMP AL,'U' ;判断是升序排序还是降序排序JZJMP;排序完后跳转到输出程序部分UP；输入的字符是U 或U 跳转到升序排序程序CMP AL, 'u'JZUPCMP'D'；输入的字符是D 或d 跳转到降叙排序程序JZ DOWNCMPAL, 'd'JZDOWNUP:DI,CX; 升序排序程序MOVBX,0 LOOP1:MOVAX,ARRAY[BX]CMPAX,ARRAY[BX+2]JNGECONTINUE1XCHG AX,ARRAY[BX+2]MOVARRAY[BX],AXCONTINUE1: ADDBX,2LOOP LOOP1MOVCX,DILOOPUPJMPOUTPUT; 排序完后跳转到输出程序部分DOWN:DI,CX;降序排序程序MOVBX,0 LOOP2:MOVAX,ARRAY[BX]CMPAX,ARRAY[BX+2]JGECONTINUE2XCHG AX,ARRAY[BX+2]MOVARRAY[BX],AXAL,MOVMOVCONTINUE2:ADDBX,2LOOP LOOP2 MOV CX,DILOOP DOWNOUTPUTOUTPUT: MOV AH,09 ;回车换行LEA DX,CRLFINT 21HM_DIRECT DIR3CX,LENMOV;为输出程序设置好入口参数MOV BX,OFFSET ARRAYWRITE: MOV AX,[BX] 输出排好序的数据WTEMP,AXMOV;将入口参数存放到共享变量中CALL P_OUTPUTADD MOV DL,20H 开MOVINTLOOPBX,2; 显示空格，将两个输出的数据分AH,02H21HWRITEAH,09 AH,09MOVLEA DX,CRLFINT 21HM_DIRECTMOVLEA DX,CRLFINT 21HLOOP READRET;隔离两次输入排序输出的作用DIR4;实现循环输入数据并排序输出MAIN ENDP;从键盘上输入一个数据的子程序P_GETNEW PROCPUSH BX ; 出口参数：AX=补码表示的二进制数PUSH DXXORBX,BX ；BX 保存结果XORCX,CX;CX 为正负标志， 0为正， -1 为负MOVAH,1；输入一个字符INT21HCMPAL, '+'； 是“ +”，继续输入字符JZREAD1CMPAL, '-'； 是“—，设置 -1 标志JNZREAD2MOVCX,-1READ1:MOV AH,1； 继续输入字符INT21HREAD2:CMPAL, '0'；不是 0~9 之间的字符，则输入数据结束JBREAD3CMPAL, '9'JAREAD3SUBAL,30H；是 0~9之间的字符，则转换为二进制数;利用移位指令，实现数值乘10: BX^BX*10SHLBX,1MOVDX,BXSHLBX,1SHLBX,1ADDBX,DXMOVAH,0ADDBX,AX； 已输入数值乘 10 后，与新输入的数值相加JMPREAD1； 继续输入字符READ3:CMP CX,0 ； 是负数，进行求补JZ READ4NEGBXREAD4:MOVAX,BX ； 设置出口参数POP DX;说明：负数用“-”引导，数据范围是 +32767~-32768PUSH CXPOP CXPOP BXRETP_GETNEW ENDP;子程序返回;用冒泡法排序的子程序（从大到小）;P_SORT PROC;RET;子程序返回;P_SORT ENDP;数据输出子程序P_OUTPUT PROCWTEMPWRITE1:值）WRITE2: 推退出标志WRITE3:PUSH AX ;入口参数：共享变量PUSH BXPUSH DXMOV AX,WTEMP ;取出显示的数据TEST AX,AX ;判断数据是零、正书还是负数JNZ WRITE1MOV DL, '0' ;是‘ 0'，显示‘ 0'后退出MOV AH,2INT 21HJMP WRITE5WRITE2 ; 是负数，显示“ -”MOV BX,AX ;AX 数据暂存于BXMOV DL, '-'MOV AH,2INT 21HMOV AX,BXNEG AX ;数据求补（绝对BX,10PUSH BX ;10 压入堆栈，做为AX,0 ;数据（商）为零，转向显示JZ WRITE4SUB DX,DX ;扩展被除数DX.AX JNSMOVCMP∏码后高位压入堆栈WRITE4: 弹出堆栈出WRITE5:DIVADDPUSHJMPPOP DXCMPJEMOVINTJMPPOP DXPOPPOPBXDL,30HDXWRITE3DL,10WRITE5AH,2 21HWRITE4MOVP_OUTPUTMOVINTRETENDPBXAXDL,20HAH,02H21HCODE ENDSEND START; 数据除以10;余数（0~9）转换为ASC;数据各位先低位;数据各位先高位后低位;是结束标志10，则退;进行显示;子程序返回。
1冒泡排序的ARM汇编程序
1冒泡排序的ARM汇编程序ORG 09B0HQUE：MOV R3，#50H QUE1：MOV A，R3 MOV R0，AMOV R7，#0AHCLR 00HMOV A，@R0Q12：INC R0MOV R2，ACLR CMOV 22H，@R0CJNE A，22H，Q13 SETB CQ13：MOV A，R2JC Q11SETB 00HXCH A，@R0DEC R0XCH A，@R0INC R0Q11：MOV A，@R0 DJNZ R7，Q12JB 00H，QUE1SJMP $END2 ARM汇编希尔排序法对10个带符号数进行排序Code:void shell(int src[],int l,int r){int ih;r++;for(ih=1;ih<(r-l)/9;ih=ih*3+1);//eax,ih//ebx,il//ecx,ir//edx,cmps_asm{push eaxpush ebxpush ecxpush edxpush esipush edi;貌似这堆进栈用处不大哎mov edi,srcmov eax,dword ptr [ih]LIH:cmp eax,0jna EXIHmov ebx,eaxdec ebxLLH:cmp ebx,dword ptr [r]jnb EXLLHmov ecx,ebxmov edx,dword ptr [edi+ecx*4]LCMP:mov esi,eaxdec esicmp ecx,esijna EXCMPpush ecxsub ecx,eaxcmp edx,dword ptr [edi+ecx*4] pop ecxjnb EXCMPpush ebxpush ecxsub ecx,eaxmov ebx,dword ptr [edi+ecx*4] pop ecxmov dword ptr [edi+ecx*4],ebx pop ebxsub ecx,eaxjmp LCMPEXCMP:mov dword ptr [edi+ecx*4],edx inc ebxjmp LLHEXLLH:push ecxmov ecx,3push edxcdqidiv ecxpop edxpop ecxjmp LIHEXIH:pop edipop esipop edxpop ecxpop ebxpop eax}}351单片机C语言对流水灯编程,用定时中断做#include<reg52.h>define uchar unsigned charuchar m=0,i=0;void main(){ TMOD|=0x01; //定时器0工作方式为1TH0=(65536-50000)/256; //装初值TL0=(65536-50000)%256; EA=1; //开总中断ET0=1; //开定时器中断TR0=1; //开启定时器while(1); //等待中断}void timer0() interrupt 1{TH0=(65536-50000)/256;TL0=(65536-50000)%256; m++ ;if(m==5) //12M晶振定时5*50MS=250MS{m=0;P1=~(0X01<<i);//P1接8个LEDif(++i==8) i=0;}}4单片机编程C语言和汇编都可以。
arm汇编之冒泡排序
arm汇编之冒泡排序开始在ADS里面写程序后，发现自己之前对于X86汇编的学习完全归还给了我的老师门。
最直接的便是要写一个从小到大的冒泡排序。
冒泡排序的思想我想就不用赘述了。
以前c语言遍的应该很多了。
算法不成问题，可是数据结构知道是数组，可是数组在arm汇编里面该在怎么定义了？其实，还真感觉又要从零开始了。
X86的汇编已经完全归还给了我敬爱的微机原理老师。
网上看到了一个广为流传的冒泡排序，既然写不出来，那就先学习它的精髓，说不定还能为我所用了。
代码详细的看了看。
具体翻译如下：AREA Sort,CODE,READONLY ：首先用AREA伪代码加上CODE，表明下面引出的将是一个代码段，ENTRY 和END成对出现，说明他们之间的代码是程序的主体ENTRY：表示代码的开始Start MOV r4,#0 ：将0赋值给r4LDR r6,=src ：在使用LDR时，当格式是LDR r0,=0x022248，则第二个参数表示地址，即0x022248，同样的，当src变量代表一个数组时，需要r0寄存器指向src 则需要这样赋值：LDR r0,=src 当格式是LDR r0,[r2]，则第二个参数表示寄存器，我的理解是符号表示取内容，r2本身表示一个寄存器地址，取内容候将其存取r0这个寄存器中跳转到LDR R0,[R1]将存储器地址为R1的字数据读入寄存器R0 LDRR0,[R1,#8]将存储器地址为R1+8的字数据读入寄存器R0，并将新地址R1+8写入R1，此句是将数据src的首地址赋值给R6ADD r6,r6,#len：R6为数组的最后一个数组元素的地址。
数组这时是连续分配的。
Outer LDR r1,=src：将src地址即数组元素首地址赋值给R1Inner LDR r2,[r1] ：将存储器地址为r1的字数据读入r2 LDR r3,[r1,#4]：将存储器地址为R1+4的字数据读入R3 CMP r2,r3 ：比较R2,R3STRGT r3,[r1]：若大于，则将R3中的字数据写入以R1为地址的存储器中STRGT r2,[r1,#4]：若大于，则将R2中的字数据写入以R1+4为地址的存储器中ADD r1,r1,#4：R1+4赋值给R1 CMP r1,r6：R1与R6比较BLT Inner：若是有符号数小于，即R1<R6，则跳转到Inner行执行ADD r4,r4,#4：R4+4赋值给R4 CMP r4,#len：R4与len比较SUBLE r6,r6,#4 ：若有符号数小于或等于，则R6-4赋值给R6 BLE Outer ：若有符号数小于或等于，则跳转到OuterStop MOV r0,#0x18 ， stop一段是用来是程序退出的，第一个语句“MOV r0，#0x18”将r0赋值为0x18，这个立即数对应于宏angel_SWIreason_ReportException。
汇编语言-冒泡排序(绝对给力)
DATAS SEGMENTBUF DW 20 DUP(0);此处输入数据段代码N DB 010dMES2 DB'Please input ten numbers(number less than 100):','$' MES3 DB'The digital after sorted:','$'a dw 0DATAS ENDSSTACKS SEGMENTSTACK DW 200 DUP(0);此处输入堆栈段代码STACKS ENDSCODES SEGMENT;此处为代码段ASSUME CS:CODES,DS:DATAS,SS:STACKSSTART:MOV AX,DATASMOV DS,AXmov ax,stacksmov ss,axmov sp,200lea dx,mes2;显示输入请用户输入数组mov ah,09int 21hcall crlxor ax,axmov ax,010dmov n,alxor cx,cxmov cl,almov bx,0input1:call decibinpush dxcall crlpop dxmov buf[bx],dxadd bx,02hloop input1;*********************冒泡排序xor cx,cxmov cl,ndec clLOOP1:mov dx,cxmov bx,0LOOP2:mov ax,buf[bx]cmp ax,buf[bx+2]jge loop3xchg ax,buf[bx+2]mov buf[bx],axLOOP3:add bx,2dec cxjne loop2mov cx,dxloop loop1lea dx,mes3mov ah,9int 21hcall crlmov cl,nmov si,0OUTPUT1:mov ax,buf[si]call bindexmov dl,2chmov ah,02hint 21hadd si,02hdec cljnz output1mov ah,4chint 21hBINDEX PROC NEAR;2->10输出push aPX:mov bx,10dxor dx,dxdiv bxadd dx,30hpush dxcmp ax,0jnz pxSHOW:pop dxcmp dx,ajz exitmov ah,02hint 21hjmp showexit:retBINDEX ENDPDECIBIN PROC NEAR;进制之间的转换mov dx,0push cxnewchar:mov ah,01hint 21hsub al,30hjl exit1cmp al,9djg exit1cbwxchg ax,dxmov cl,10dmul clxchg ax,dxadd dx,axjmp newcharexit1:pop cxretDECIBIN ENDPCRL PROC NEAR;*********换行回车函数mov dl,0dhmov ah,02hint 21hmov dl,0ahmov ah,02hint 21hretCRL endpCODES ENDSEND START。
ARM汇编-冒泡排序-实验报告
实验要求实现字符串冒泡排序。
实验过程首先在内存中定义字符串，使用的方法是AREA SORTDATA,DATA,READWRITEstr DCB "9847210356"len DCD 10DCB表示在内存中开辟一个byte的空间。
DCD则表示开辟一个word的空间采用两层循环来进行冒泡排序。
第一层循环首先把r1初始化为字符串首地址，把r5初始化为0，r5代表内循环执行次数。
然后把r4 减1，因为最后的一个字符已经排好序了。
如果r4 = 0, 代表排序已经完成，调到结束代码。
loop0MOV r1,r0 ;r1 is the start address of stringSUBS r4,r4,#1 ;r4 is the last index, the counterCMP r4,#0BEQ endMOV r5,#0第二层循环就是从左往右对字符进行交换，每次把r1和r5的值都增加1。
当r5=r4的时候就跳出循环，到达外层循环。
;in every loop, s value of contiguous two bytes from the start to start+r4;using r1 as the address,increment in every inner loop;using r2,r3 to load the two bytes then compare; if r3 is smaller than r2,;then store the val in s placeloopLDRB r2,[r1]LDRB r3,[r1,#1]CMP r2,r3STRGTB r2,[r1,#1]STRGTB r3,[r1]ADD r1,r1,#1ADD r5,r5,#1CMP r5,r4BNE loop;if reaches the end, branch to outer loopB loop0为了让字符从小到大排列，在CMP r2,r3后，连续使用STRGT(Store Greater Than)，如果r2>r3, 就分别把他们存进对方的地址实现交换。
汇编语言冒泡法排序
汇编语言冒泡法排序汇编语言中的冒泡排序算法如下：```assemblysection .dataarray db 5, 1, 4, 2, 8 ; 待排序的数组size equ $-array ; 数组的大小section .textglobal _start_start:mov ecx, size ; 初始化循环计数器为数组大小outer_loop:xor eax, eax ; 清零标志寄存器，用于判断是否有交换发生mov edi, 1 ; 初始化内层循环计数器为1inner_loop:movsx ebx, byte [array + edi - 1] ; 将当前元素加载到寄存器ebxcmp bl, byte [array + edi] ; 比较当前元素和下一个元素jg swap ; 如果当前元素大于下一个元素，则交换它们inc edi ; 内层循环计数器加1 loop inner_loop ; 继续内层循环cmp eax, 0 ; 判断标志寄存器是否为0jne outer_loop ; 如果有交换发生，则继续外层循环exit:mov eax, 1 ; 系统调用号1代表退出程序xor ebx, ebx ; 退出状态码为0int 0x80 ; 调用系统调用swap:mov dl, byte [array + edi] ; 将下一个元素加载到寄存器dlmov byte [array + edi], bl ; 将当前元素赋值给下一个元素mov byte [array + edi - 1], dl ; 将下一个元素赋值给当前元素mov eax, 1 ; 设置标志寄存器为非零，表示有交换发生jmp inner_loop ; 继续内层循环```这段汇编代码使用了两层循环，外层循环控制整个排序过程，内层循环用于比较相邻的两个元素并交换它们。
内层循环每次都会比较当前元素和下一个元素，如果当前元素大于下一个元素，则交换它们。
汇编语言冒泡排序
DATAS SEGMENTKEYBUFFER DB 100DB ?DB 100 DUP(?)A DB 100 DUP(?)X DB ?TEMP DB ?STRING1 DB 'PLEASE INPUT 10 NUMBERS : ',0DH,0AH, '$' DATAS ENDSSTACKS SEGMENT STACK 'STACK'DW 100H DUP(?)TOP LABEL WORDSTACKS ENDSCODES SEGMENTASSUME CS:CODES,DS:DATAS,SS:STACKS,ES:DATAS START:MOV AX,DATASMOV DS,AXMOV ES,AXMOV AX,STACKSMOV SS,AXLEA SP,TOPLEA DX,STRING1MOV AH,09HINT 21HLEA DX,KEYBUFFERMOV AH,0AHINT 21HMOV CX,0AHMOV DI,0LEA SI ,KEYBUFFER+2JMP LOOP1NEXT1:INC SILOOP1:MOV TEMP,10;MOV X,0MOV DL,[SI]CMP DL,20HJE NEXT1SUB DL,'0'MOV AL,DL ;十位放到ALMOV DL,[SI+1] ;个位放到DLCMP DL,20HJE NEXTCMP DL,0DHJE NEXT;MOV X,AL ;个位放入X;MUL TEMP ;个位乘1 ;MOV X,AX;MOV AL,10 ;;TEMP*10;MUL TEMP;MOV TEMP,AL ;;MUL TEMP;MOV AL,DL;MUL TEMPADD AL,DLNEXT:MOV A[DI],ALINC DIINC SI;MOV DL,X;INC SI;POP CXLOOP LOOP1MOV CX,10LOP1:MOV SI,0MOV AL,A[SI]MOV BL,10HDIV BLMOV DL,30HADD AL,DLMOV AH,02HINT 21HADD AH,DLMOV X,AHMOV AH,02HINT 21HINC SILOOP LOP1;MOV CX ,9;MOV SI,0;LOOP4:;PUSH CX;LOOP3:;MOV AL,A[SI];CMP AL,A[SI+1];JB CONTINUE;MOV BL,A[SI+1];XCHG AL,A[SI+1];MOV A[SI],BL;CONTINUE:;INC SI;LOOP LOOP3;POP CX;;MOV SI,0;LOOP LOOP4;;LEA DX,AMOV AH,9INT 21HMOV AH,4CHINT 21H CODES ENDSEND START。
汇编语言汇编语言实现ifwhilefor以及编写冒泡排序
汇编语言汇编语言实现ifwhilefor以及编写冒泡排序在计算机科学中，汇编语言是一种底层编程语言，它直接与计算机的硬件交互。
在汇编语言中，我们可以利用条件语句（if）、循环语句（while、for）以及排序算法（冒泡排序）来实现各种功能。
本文将介绍汇编语言中如何使用这些关键字来编写相应功能的代码，并且以冒泡排序算法为例进行详细说明。
一、if语句实现if语句在汇编语言中通常使用条件判断指令来实现。
下面是一个示例代码，演示如何使用if语句判断两个数的大小关系：```section .datanum1 db 10num2 db 20result db 0section .textglobal _start_start:mov al, byte[num1]mov bl, byte[num2]cmp al, bl ; 比较num1和num2的值jg greater ; 如果num1 > num2，则跳转到greater标签处jl less ; 如果num1 < num2，则跳转到less标签处jmp equal ; 如果num1 = num2，则跳转到equal标签处greater:mov byte[result], 1jmp doneless:mov byte[result], -1jmp doneequal:mov byte[result], 0jmp donedone:; 其他操作，比如打印结果或进行下一步操作```在上述代码中，我们将两个数分别存在`num1`和`num2`变量中，用`cmp`指令进行比较，根据比较结果使用`jmp`指令跳转到相应的标签位置。
通过这样的比较和跳转操作，我们可以实现基本的if语句功能。
二、while语句实现while语句在汇编语言中可以通过使用条件循环指令来实现。
下面是一个示例代码，演示如何使用while语句计算1到10的和：```section .datasum dw 0counter dw 1section .textglobal _start_start:mov cx, 10 ; 设置循环次数mov ax, 1 ; 设置计数器初始值loop_start:add word[sum], ax ; 将计数器的值加到sum中inc ax ; 计数器自增1loop loop_start ; 循环开始; 其他操作，比如打印结果或进行下一步操作```在上述代码中，我们将循环次数存储在`cx`寄存器中，将计数器的初始值存储在`ax`寄存器中。
arm汇编算法
ARM汇编语言是一种基于ARM架构的低级编程语言，广泛用于嵌入式系统和底层软件开发。
通过直接操作硬件资源，它能够高效地实现各种算法，从简单的数据处理到复杂的加密解密算法。
下面我将介绍一个使用ARM汇编语言实现的经典算法——冒泡排序。
冒泡排序是一种简单的排序算法，通过反复交换相邻的未排序元素，使得最大（或最小）的元素像气泡一样逐渐“浮”到数列的一端。
在ARM汇编语言中，我们可以使用循环结构和条件语句来实现这一算法。
首先，我们需要定义待排序的数据数组和相关的变量。
然后，使用嵌套的循环结构，外层循环控制排序的轮数，内层循环负责两两比较并交换元素。
通过比较相邻元素的大小，如果顺序不对则交换它们的位置。
这个过程会一直重复，直到整个数组变得有序。
在ARM汇编语言中，我们可以使用寄存器来存储待比较的元素，使用条件语句来判断它们的大小关系，然后使用数据交换指令来交换它们的位置。
通过这种方式，我们可以高效地实现冒泡排序算法，并且对硬件资源的占用也非常有限。
需要注意的是，由于ARM汇编语言是一种低级语言，编程时需要仔细考虑内存访问、寄存器分配和指令流水线等因素，以确保程序的正确性和高效性。
此外，为了提高算法的效率，还可以使用一些优化技巧，如减少不必要的比较次数和利用已排序的子序列等。
总的来说，ARM汇编语言在算法实现方面具有很强的灵活性和高效性。
通过使用适当的数据结构和算法技巧，我们可以编写出高效且可靠的程序来满足各种实际需求。
实验1-ARM基础编程仿真(Keil)
5、ARM汇编实现冒泡算法（选做） 冒泡排序参考流程-----较小的数值排放到后面
24
5、ARM汇编实现冒泡算法（选做）
冒泡排序法原理：
这种方法的基本思想：是将待排序的元素看作是竖着排列的 “气泡”，较大的元素比较重，从而要往下沉。在冒泡排序算法 中我们要对这个“气泡”序列处理若干遍。所谓一遍处理，就是 自上向下检查一遍这个序列，并时刻注意两个相邻的元素的顺序 是否正确。如果发现两个相邻元素的顺序不对，即“轻”的元素 在下面，就交换它们的位置。显然，处理一遍之后，“最重”的 元素就沉到了最低位置；处理二遍之后，“次重”的元素就沉到 了次低位置。在作第二遍处理时，由于最低位置上的元素已是 “最重”元素，所以不必检查。一般地，第i遍处理时，不必检 查第i低位置以下的元素，因为经过前面i-1遍的处理，它们已正 确地排好序。
25
5、ARM汇编实现冒泡算法（选做）
实验步骤： 1、建立新工程，加入实验1.5文件夹中的maopao.s。 2、补充完成源代码中缺失的部分，实现冒泡排序功能。 3、运行Debug进行调试
实验一 ARM基础编程实验
1
一、实验目的与实验环境
实验目的
1.熟悉并掌握常用ARM汇编指令 2.熟悉并掌握“C＋汇编”混合编程技术 3.熟练使用ARM软件开发调试工具Keil
实验环境
1. 硬件：PC 机 2. 软件：Windows操作系统，Keil软件
2
二、实验内容
1. 学习使用Keil开发工具 2. 实现累加运算功能（汇编编程，必做） 3. 实现字符串拷贝功能（C＋汇编，必做） 4. 实现求和运算功能（C＋汇编，必做） 5. 实现冒泡排序算法（汇编编程，选做）
16
2、用汇编语言实现1+2+...+N的累加（必做）
汇编实现冒泡排序的方法示例
汇编实现冒泡排序的⽅法⽰例冒泡排序算法的运作如下：（从后往前）1.⽐较相邻的元素。
如果第⼀个⽐第⼆个⼤，就交换他们两个。
2.对每⼀对相邻元素作同样的⼯作，从开始第⼀对到结尾的最后⼀对。
在这⼀点，最后的元素应该会是最⼤的数。
3.针对所有的元素重复以上的步骤，除了最后⼀个。
4.持续每次对越来越少的元素重复上⾯的步骤，直到没有任何⼀对数字需要⽐较。
以下为实现代码：S0 SEGMENT STACKDW 30 DUP(?)TOP LABEL WORDS0 ENDSS1 SEGMENTTIP DB "Input ten number and separate the numbers with space:", 0DH, 0AH, 24HARY DW 20 DUP(0)CRLF DB 0DH, 0AH, 24HN DW 0S1 ENDSS2 SEGMENTASSUME SS:S0, DS:S1, CS:S2, ES:S1P PROC FARMOV AX, S0MOV SS, AXLEA SP, TOPMOV AX, S1MOV DS, AXMOV AX, S1MOV ES, AXLEA DX, TIPMOV AH, 9INT 21HLEA SI, ARYXOR DX, DXMOV BL, 10MOV CX, 10INPUT: MOV AH, 1INT 21HCMP AL, 20H ;空格分隔字符JE SAVE;输⼊⼗进制数，将数存⼊SI对应的内存单元MOV DL, ALMOV AX, [SI]MUL BLSUB DL, 30HADD AL, DLMOV [SI], AXJMP INPUTSAVE:ADD SI, 2LOOP INPUT;数组保存完毕LEA SI, ARYMOV DI, SIADD DI, 2CMPA: MOV BX, [DI]CMP BX, [DI-2]JA CONMOV DX, [DI-2]PUSH DXMOV [DI-2], BXPOP DXMOV [DI], DXCON: ADD DI, 2DEC CHCMP CH, 0JNE CMPACALL PRINTMOV DI, SIADD DI, 2DEC CLMOV CH, CLCMP CL, 1JNE CMPA;以下为⼗进制输出ARY中的数EXIT: MOV AH, 4CHINT 21HP ENDPPRINT PROC NEARPUSH SIPUSH CXPUSH AXPUSH DXLEA DX, CRLFMOV AH, 9INT 21HLEA SI, ARYMOV CX, 10L1: MOV AX, [SI]MOV N, AXCALL OUTPUTADD SI, 2MOV DX, 20HMOV AH, 2INT 21HLOOP L1POP DXPOP AXPOP CXPOP SIRETPRINT ENDPOUTPUT PROC NEARPUSH AXPUSH BXPUSH CXPUSH DXXOR CX, CXMOV AX, NMOV BX, 10L2: XOR DX, DXDIV BXPUSH DXINC CXL3: POP DXADD DX, 30HMOV AH, 2INT 21HLOOP L3POP DXPOP CXPOP BXPOP AXRETOUTPUT ENDPS2 ENDSEND P以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
汇编实现冒泡排序并输出结果
结果截图这样子的程序：;;无符号16位整数冒泡排序data segmenta dw 12,4,9,0,65358,6,1,3,5,79cnt dw 10data endsstack segmentstack endscode segmentassume cs:code,ds:data,ss:stacksort proc near ;冒泡排序，具有两个参数，数组偏移和个数push bppush axpush cxpush sipush dimov bp,spmov cx,ss:[bp+0CH] ;取出函数形参，放在(si,cx)mov si,ss:[bp+0EH]loop1:push cx ;外层循环还有cx-1 次，将次数压栈;同时cx-1 也是内层循环次数,不再赋值mov di,si ;di为内层循环遍历指针loop2:mov ax,ds:[di]cmp ax,ds:[di+2]jna noswapmov dx,ds:[di+2]mov ds:[di+2],axmov ds:[di],dxnoswap:inc diinc didec cxcmp cx,1ja loop2pop cx ;外层循环次数出栈dec cxcmp cx,1ja loop1pop dipop sipop cxpop axpop bpret 4sort endpdisplay proc near ;将0-15转换为0-9&&A-Fpush axmov ah,02Hcmp dl,0AHjae addAjb add0addA:add dl,37Hint 21Hjmp ffadd0:add dl,30Hint 21Hjmp ffff:pop axretdisplay endpshow proc near ;打印数组，具有两个参数，数组偏移和个数push bppush axpush bxpush cxpush sipush dxmov bp,spmov cx,ss:[bp+0EH] ;取出函数形参，放在(si,cx)mov si,ss:[bp+10H]lop1: ;将一个0-65535 的数据以十进制的形式打印push cxmov cx,0mov dx,0mov ax,ds:[si]lop2:mov bx,0AHdiv bxpush dx ;数字顺序是个,十,百,千所以先存起来inc cxmov dx,0cmp ax,0ja lop2lop21: ;和lop2并列的内循环,用于将颠倒顺序的十进制反转打印pop dxcall displaydec cxcmp cx,0ja lop21mov ah,02Hmov dl,20Hint 21Hpop cxinc siinc sidec cxcmp cx,0ja lop1pop dxpop sipop cxpop bxpop axpop bpret 4show endpstart: ;主程序调用子程序进行排序及打印mov ax,stackmov ss,axmov ax,datamov ds,axlea ax,a ;参数两个（a,cnt）push axmov ax,cntpush axcall sortlea ax,a ;参数两个（a,cnt）push axmov ax,cntpush axcall showmov ah,4CHint 21Hcode endsend start。
编程题
NEXT ADD R1,R1,#1 CMP R1,#100 BNE LOOP CEASE B CEASE END
13、编写一程序查找存储器从0x400000开始的100个 字中为0的数目将其结果存到0x400190中。
AREA procedure6,CODE,READONLY ENTRY CODE32 START MOV R0#0x400000 MOV R7#100 控制循环变量 MOV R1#0 保存0的数目 LOOP LDR R2[R0]#4 取数 CMP R2#0 比较为0 ADDEQ R1R1#1 为0加1 SUBS R7R7#1 修改控制变 量 BNE LOOP STR R1[R0] 保存0的数目 CEASE B CEASE END
•
•E
• CMP R0,R1 • BEQ STOP • CMP R0,R1 • SUBGT R0,R0,R1 • SUBLT R1,R1,R0 • BE • STOP • B STOP ;比较 ;相等就跳转到stop ;比较 ;大于执行 ;小于执行
•
END
9、内存数据区定义如上。要求将数据从源数据区复制到目标数据
;给 76 -> R0 ;给 88-> R0 ;比较R0和R1大小 ;如果相等， ;小于执行 ;大于执行
8、如果用ARM汇编程序来实现循环判断，假设两个整数分别放在寄
用汇编语言冒泡排序经典程序
冒泡排序时间复杂度
最好情况：O(n)
平均情况：O(n²)
最坏情况：O(n²)
Part Two
汇编语言基础知识
汇编语言概述
汇编语言是一种低级编程语言，与机器语言相对应。
它使用助记符和操作码表示指令，易于理解和编写。
汇编语言通常用于嵌入式系统、操作系统等底层开发。
注意事项：确保编译和链接的正确性，避免出现错误和警告
工具使用：使用编译器和链接器等工具进行编译和链接
链接过程：将目标文件合并成一个可执行文件
程序运行及结果
输入数据：随机生成一组整数
程序运行过程：按照冒泡排序算法进行排序
输出结果：排序后的整数序列
测试结果：对多个不同规模的输入数据进行测试，验证程序的正确性和稳定性
代码注释：对每行代码进行详细解释，帮助理解算法实现过程
代码解析：分析代码结构，解释冒泡排序算法的汇编语言实现方式
寄存器使用：说明在汇编语言中如何使用寄存器进行数据交换和比较
优化点：分析代码中可以优化的地方，提高程序执行效率
Part Four
程序运行及测试
程序编译链接
编译过程：将源代码转换成机器语言
指令格式：汇编语言指令由操作码和操作数组成，操作码指明指令的操作类型，操作数指明操作数或操作数的地址。
伪指令：伪指令不是真正的计算机指令，而是用于告诉汇编程序如何组织程序的一种指示。常见的伪指令包括ORG、END、DB、DW等。
Part Three
汇编语言实现冒泡排序
排序数据准备
确定排序数据类型：根据具体需求选择合适的数据类型，如整数、字符等。
优化效果：通过减少数据交换次数，可以提高冒泡排序算法的执行效率，减少程序运行时间
arm汇编之冒泡排序
arm汇编之冒泡排序AREA Sort,CODE,READONLY ：首先用AREA伪代码加上CODE，表明下面引出的将是一个代码段（于此相对的还有数据段DATA），ENTRY 和END成对出现，说明他们之间的代码是程序的主体ENTRY：表示代码的开始Start MOV r4,#0 ：将0赋值给r4LDR r6,=src ：在使用LDR时，当格式是LDR r0,=0x022248，则第二个参数表示地址，即0x022248，同样的，当src变量代表一个数组时，需要r0寄存器指向src则需要这样赋值：LDR r0,=src 当格式是LDR r0,[r2]，则第二个参数表示寄存器，我的理解是[]符号表示取内容，r2本身表示一个寄存器地址，取内容候将其存取r0这个寄存器中跳转到LDR R0,[R1]将存储器地址为R1的字数据读入寄存器R0 LDRR0,[R1,#8]将存储器地址为R1+8的字数据读入寄存器R0，并将新地址R1+8写入R1，此句是将数据src的首地址赋值给R6ADD r6,r6,#len：R6为数组的最后一个数组元素的地址。
数组这时是连续分配的。
Outer LDR r1,=src：将src地址即数组元素首地址赋值给R1Inner LDR r2,[r1] ：将存储器地址为r1的字数据读入r2 LDR r3,[r1,#4]：将存储器地址为R1+4的字数据读入R3CMP r2,r3 ：比较R2,R3STRGT r3,[r1]：若（有符号数）大于，则将R3中的字数据写入以R1为地址的存储器中STRGT r2,[r1,#4]：若大于，则将R2中的字数据写入以R1+4为地址的存储器中ADD r1,r1,#4：R1+4赋值给R1CMP r1,r6：R1与R6比较BLT Inner：若是有符号数小于，即R1<R6，则跳转到Inner行执行ADD r4,r4,#4：R4+4赋值给R4CMP r4,#len：R4与len比较SUBLE r6,r6,#4 ：若有符号数小于或等于，则R6-4赋值给R6BLE Outer ：若有符号数小于或等于，则跳转到OuterStop MOV r0,#0x18 ， stop一段是用来是程序退出的，第一个语句“MOV r0，#0x18”将r0赋值为0x18，这个立即数对应于宏angel_SWIreason_ReportException。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
arm汇编之冒泡排序
开始在ADS里面写程序后，发现自己之前对于X86汇编的学习完全归还给了我的老师门。
最直接的便是要写一个从小到大的冒泡排序。
冒泡排序的思想我想就不用赘述了。
以前c语言遍的应该很多了。
算法不成问题，可是数据结构知道是数组，可是数组在arm汇编里面该在怎么定义了？
其实，还真感觉又要从零开始了。
X86的汇编已经完全归还给了我敬爱的微机原理老师。
网上看到了一个广为流传的冒泡排序，既然写不出来，那就先学习它的精髓，说不定还能为我所用了。
代码详细的看了看。
具体翻译如下（arm汇编指令不太熟悉，就当时温习吧）：
AREA Sort,CODE,READONLY ：首先用AREA伪代码加上CODE，表明下面引出的将是一个代码段（于此相对的还有数据段DATA），ENTRY 和END成对出现，说明他们之间的代码是程序的主体
ENTRY：表示代码的开始
Start MOV r4,#0 ：将0赋值给r4
LDR r6,=src ：在使用LDR时，当格式是LDR r0,=0x022248，则第二个参数表示地址，即0x022248，同样的，当src变量代表一个数组时，需要r0寄存器指向src则需要这样赋值：LDR r0,=src 当格式是
LDR r0,[r2]，则第二个参数表示寄存器，我的理解是[]符号表示取内容，r2本身表示一个寄存器地址，取内容候将其存取r0这个寄存器中跳转
到LDR R0,[R1]将存储器地址为R1的字数据读入寄存器R0 LDR
R0,[R1,#8]将存储器地址为R1+8的字数据读入寄存器R0，并将新地址R1+8写入R1，此句是将数据src的首地址赋值给R6
ADD r6,r6,#len：R6为数组的最后一个数组元素的地址。
数组这时是连续分配的。
Outer LDR r1,=src：将src地址即数组元素首地址赋值给R1
Inner LDR r2,[r1] ：将存储器地址为r1的字数据读入r2 LDR r3,[r1,#4]：将存储器地址为R1+4的字数据读入R3
CMP r2,r3 ：比较R2,R3
STRGT r3,[r1]：若（有符号数）大于，则将R3中的字数据写入以R1为地址的存储器中
STRGT r2,[r1,#4]：若大于，则将R2中的字数据写入以R1+4为地址的存储器中
ADD r1,r1,#4：R1+4赋值给R1
CMP r1,r6：R1与R6比较
BLT Inner：若是有符号数小于，即R1<R6，则跳转到Inner行执行
ADD r4,r4,#4：R4+4赋值给R4
CMP r4,#len：R4与len比较
SUBLE r6,r6,#4 ：若有符号数小于或等于，则R6-4赋值给R6
BLE Outer ：若有符号数小于或等于，则跳转到Outer
Stop MOV r0,#0x18 ， stop一段是用来是程序退出的，第一个语句“MOV r0，#0x18”将r0赋值为0x18，这个立即数对应于宏
angel_SWIreason_ReportException。
表示r1中存放的执行状态。
语句“LDR r1，=0x20026”将r1的值设置成ADP_Stopped_ApplicationExit，该宏表示程序正常退出。
然后使用SWI，语句“SWI 0x123456”结束程序，将CPU的控制权交回调试器手中。
LDR r1,=0x20026
SWI 0x123456
AREA Array,DATA,READWRITE
src DCD 2,4,10,8,14,1,20 ：数据定义伪指令DCD表示用于分配一片连续的字存储单元并用指定的数据初始化
len EQU 7*4 ：这里的4是4个字节。
即是32位。
因为ARM7TDMI 是32位ARM指令集。
END：结束代码
代码很清晰。
思想很对。
执行结果貌似也很对。
可是详细看看不对。
数组的起始地址是0x00008058(此时的r6的值。
r6初值为起始地址加len，经过程序的递减后变成了起始地址)，那么冒泡完后
0x00008058存储的应该是01 00 00 00（按ADS里面的内存内容显示格式），可是此时存储的是00 E8 00 E8，从0x0000805c开始才是冒泡排序后的结果。
程序肯定是有问题的。
既然要找问题，那就单步调试吧。
这里面忘了介绍怎么看内存里面存的内容了。
之前我一直找不着。
因为点击出现内存框框时，没有注意到有个start adreess。
比如这个程序里面的数组起始地址是0x0000805c，那么我们把start address通过点击递加设为
0x8000。
接着单步调试。
这是第一次排序的结果。
明显不对。
因为这个数组里面排序最大的是沉到低了，可是数0x00E800E8也参合进来，冒泡到最大的数的前面了。
这个不对。
也就是这个程序的内循环控制不对。
改正的话其实很简单。
就是程序里内循环对比较了一次。
这里我采用的方法是len定义为6*4,把len理解为偏移量应该是更合适的吧。
第一个数的地址为0x00008058，那么最后一个数的地址加上6*4 = 24的偏移量，应该是0x00008070。
这样才是正确的数组地址。
改过后再看运行结果：。