这个文档还没写完,我会继续写的,由于我这里的网速慢,有些图片没传上来,我会传个附件上来,但不知能成功,第一次发帖,见谅哈^_^.

这里是附件:


汇编语言学习笔记
---傻瓜学汇编
                    
前言
    当我在学汇编的时候发现一到了实际编程就发现学过的那些指令串不起来,什么浮点数啊整数啊,怎么跳转啊,怎么循环啊,脑袋立马变成浆糊。下面的文档是我的学习经历,
希望对初学者在学习加密解密,软件调试,单片机编程有点帮助。

目录
1.  编程环境的搭建
2.  深入理解汇编语言的数据
3.  顺序程序设计
4.  分支结构程序设计
5.  循环
6.  数组及指针
7.  函数
8.  结构
9.  综合运用
10.  参考文献

一:编程环境的搭建
  首先装好masm32v10 和windbg,和editplus,然后在editplus中输入下面的程序,具体的请参考罗云彬的那本书,里面有详尽的说明,编译运行看看:
    .386
.model flat,stdcall
option casemap:none

includelib  msvcrt.lib

printf  proto C :VARARG
.data
msg  db "hello,this is the first test program!", 0dh ,0ah,0

.code
start:
  call  main
  ret
main proc
  
  push  offset msg
  call  printf
  add  esp,4

  push  offset msg
  call  printf
  add  esp,4
  ret
  main  endp
end  start
    下面是运行结果:


这里输出两行消息主要是我在写这个最简单的程序的时候发现他不换行,于是我在数据定义后面我加了“0ah,0dh”,呵呵,就是回车换行的十六进制表示,你也可以用其他方法试试,
程序就不多解释了,后面会有更多的解释,不过你一定要走到这以步,才能进行下一章。

2.深入理解汇编语言的数据
  整数常量及变量,先看一段很简单的汇编程序:

  .386
.model flat,stdcall
option casemap:none

includelib  msvcrt.lib

printf  proto C :VARARG
.data
PRICE  EQU  30
msg1  db  "total=%d",0dh,0ah,0
.code
start:
  call    main
  ret
main proc
  local    num:dword
  local    total:dword

  mov    num,10
  mov    eax,num
  imul    eax,eax,PRICE
  mov    total,eax

  push    offset msg1
  call    printf
  add    esp,4
  ret
  main    endp
end  start
程序的意思很简单就是在屏幕上打印出某个东西的价格,如过要你拿笔和纸算,拿你肯定很快就能算出来,但你让电脑怎么算呢?当电脑执行到第一个语句的时候,也就是num=10,
它就把10放到某个地方并且记住这个值,寄存器或者内存,呵呵,它也就这两个地方,为什么要这么做呢?因为后面要用它来计算啊,为了算出这个值,电脑好的办法就是放在它的内存里,为什么不是寄存器?因为寄存器太少了,就那么几个,呵呵,所以了它就把10存在一个叫num的内存里,注意了哦,num是程序里的变量名,是存中里的一个位置的名称,它的值是10,你可能会问,不起名不行么?行,等下在调试器中你看到的就是没名的。来看看它在调试器中的样子:

num变成了[ebp-4]了,现在你想象有个几千行的程序如果都用[ebp-4]这样的名字的话,那我们会疯的,所以汇编程序就让我们给程序里面的变量起个直观的名字,而不是用具体的数字去让你去记住变量内存的位置。程序中imul eax,eax,1eh中的1eh就是个整形常量,也就是30.现在你应该对常量和变量有点感觉了吧。

再看个例子:
.386
.model   flat,stdcall
option   casemap:none

includelib    msvcrt.lib

printf  proto C :VARARG
.data

a  db  12h
b  dw  1234h
c1  dd  12345678h
msg1    db  "the  number is=%xh",0dh,0ah,0
.code
start:
  call  main
  ret
main   proc
  mov    al,a
  cbw
  cwde
  push    eax
  push    offset  msg1
  call    printf
  add    esp,8

  mov    ax,word ptr a
  cwde
  push    eax
  push    offset msg1
  call    printf
  add    esp,8

  mov    eax,dword ptr a
  push    eax
  push    offset  msg1
  call    printf
  add    sp,8

  ret
  main    endp
end  start
  首先,你得想a,b,c1三个变量在程序中到底是怎么存的,是12 12 34 12 34 56 78,还是 78 56 34 12 34 12 12呢?呵呵,用调试器载入程序看看就知道了:
 
哈哈,看到了没,正确的是这个:00403000: 12 34 12 78 56 34 12 74-68,这是为什么?
还有就是这个程序打印的三个结果又是什么呢?是12h和0012h和00000012h吗?如果是,那你就错了哦,应该是:the  number is=12h the  number is=3412h the  number is=78123412h
 
呵呵,首先,你得明白这三个你定义的数据在内存是怎么存的,一个原则就是你定义的数据的高位存在内存中的高字节地址,你定义的第二个数据:1234h,高位字节是12吧,低位字节是34吧,所以编译器它先存34字节存在内存的低地址,然后再把12存在高地址,当然如果是你只定义了一个字节那顺序就没反了,就像你定义的第一个字节数据12好一样,同样第三个双自数据12345678h,编译器它就先存78好字节了,然后是56好字节,34h字节,12h字节。下面我们来看看程序:
mov    al,a,就是是把12h放到al中,movzx  ax,al 0扩展指令,将al中的字节扩展到ax中,不足的位用0填充,不改变al的值,al里面是什么值,扩展后ax的值还是等于al中的值。  movzx  eax,ax  ;0扩展指令,将ax中的字节扩展到eax中,不足的位用0填充,不改变ax的值,al里面是什么值,扩展后eax的值还是等于ax中的值。然后push  eax,和 push    offset  msg1,call  printf 就是调用c语言库函数printf打印消息,
就相当于c语言里面的:printf("the  number is=%xh\n",a);下面的和这段一样,我就不写废话了。如果面对的是有符号数,那就得用movsx了,当然还有其他指令,后面再介绍。

浮点数:
在计算机内部,浮点数是以二进制表示的,所以,要先转换为二进制浮点数,转换分两部,整数部分的装换,采用“除2取余法”,小数部分的装换,采用“乘2取整法”,例如19.2,
先将19 转换成二进制:10011,然后将0.2转换成二进制:00110011……0011,它是个无穷循环小数,然后就是规格化,分三种情况:如果定义的数据类型是dword或者是real4,那么符号位占一位,阶码占8位,位数占23位,总共是32位,如果定义的类型是qword或real8,那么符号位占一位,阶码占11位,位数占52位,总共64位,如果定义的类型是real10或者是tword,那么阶码占15位,位数占64位,符号位占一位,总共80位。怎么算阶码呢?如果是32位,就将阶码加上127,然后转换成二进制,如果是64位,就加上1023,如果是80位,就加上16383。我们看看怎么将19.2转换成32位的二进制浮点数:
首先将19转换成二进制:10011,然后将0.2转换成二进制:00110011……0011,整理成32位就是:10011,001100110011001100110011001。然后规格化为:1,0011001100110011001100110011001x2的4次方,阶码为127加4等于131:10000011。所以当浮点数19.2表示为三种不同的数据类型为:
32位(dword,real4):0,10000011,0011001100110011001101
64位(qword,real8):0,100000000011,0011001100110011001100110011001100110011001100110011
80位:0,100000000000011,001100110011001100110011001100110011001100110011001100110011001100110011。
转换成16进制就是4199999Ah,40333333 33333333 h,403999999999999999ah。
然后我们yong程序来验证一下对不对。例子如下:
.386
.model flat,stdcall
option casemap:none

includelib  msvcrt.lib

printf  proto C :VARARG
.data

f1  real4  19.2
f2  real8  19.2
f3  real10  19.2
msg1  db  "the floating number is=%g",0dh,0ah,0
.code
start:
  call  main
  ret
main proc
  
  local  f:real8
  
  
  fld  dword ptr f1
  fstp  f
  
  push  dword ptr f+4
  push  dword ptr f+8
  
  push  offset msg1
  call  printf
  add  esp,12

  push  dword ptr f2+4
  push  dword ptr f2
  push  dword ptr offset msg1
  call  printf
  add  esp,12
  
  
  fld  f3
  fstp  qword ptr f
  push  dword ptr f+4
  push  dword ptr f+8
  push  offset msg1
  call  printf
  add  esp,12
  ret
  main  endp
end  start
程序很简单,就是分别在屏幕上打印三个浮点值,如下图:
 
在这里我要说明下,我只有把32位和80位的转换为64位的,才能打印成功,这可能是库函数printf的原因,怎么转换呢?
32位浮点转换64位浮点:首先得借助一个64位的浮点局部变量:
local    f:real8
  fld    dword ptr f1
  fstp    f
第一句定义了f位一个64位的浮点局部变量,第二句就是把32位浮点数转换为80位的,然后第三句就是把80位的转换位64位的。
80位浮点转换位64位浮点数:同样借助一个64位的浮点局部变量:
fld    f3
fstp    qword ptr f
第二句就是把80位的浮点转换位60位的。

但是这两句怎么解释呢:push    dword ptr f2+4
            push    dword ptr f2
为什么要先把f2的高4位字节入栈呢?
好,我们先来看看这个数转换成64位的16进制为:40333333 33333333h,前面我说了高低对应原则,那么这个64位的16进制在内存中高4字节地址应该存40333333h,也就是存它的高4字节,然后是33333333h,但是,呵呵,在堆栈中的地址是从高往低增长的,所以我们应该先把这个数的高四字节入栈,也就是40333333h,怎么在内存中得到这高4字节呢?就是从f2+4处压入4字节就可以了,然后就是低4字节入栈。如果还没理解,用cdb调试一下就清楚了。

浮点与整数之间的转换:
先看例子成ch2-4:
.386
.model flat,stdcall
option casemap:none

includelib  msvcrt.lib

printf  proto C :VARARG
.data
f1  real8  19.2
f2  dword  20
msg1  db  "the floating to int number is=%d",0dh,0ah,0
msg2  db  "the int to floating number is=%f",0dh,0ah,0
.code
start:
  call  main
  ret
main proc
  
  local  f:real8
  
  fld  f1
  fistp  dword ptr f
  push  dword ptr f
  push  offset msg1
  call  printf
  add  esp,8


  fild  f2
  fstp  f
  push  dword ptr f+4
  push  dword ptr f+8
  push  offset msg2
  call  printf
  add  esp,12


  ret
  main  endp
end  start
运行结果为:
 
浮点数转换成整数:
fld    f1
  fistp    word ptr f
首先我们还是借助了一个64位的局部变量,先把浮点数装入浮点寄存器,然后用装换整行的指令变成整数再存入一个局部变量就行了。
整数转换成浮点数:
fild  f2
fstp  f
先把整数用装换指令装入浮点寄存器,然后把浮点数存到一个局部变量就可以了。
我在后面会详细说名浮点数的运算和浮点寄存器的。

字符与字符串常量:
怎么定义他们?他们是以什么形式存在计算机中?
  首先我们怎么在汇编中定义他们呢:先看看例子ch2-5:
.386
.model flat,stdcall
option casemap:none

includelib  msvcrt.lib

printf  proto C :VARARG
.data
str1  db  'this is a string test',0ah,0dh,0
str2  db  "this is a string test",0ah,0dh,0

.code
start:
  call  main
  ret
main proc
  
  mov  eax,  offset str1
  push  offset str2
  call  printf
  add  esp,4

  push  offset str1
  call  printf
  add  esp,4
  ret
  main  endp
end  start
程序就是在屏幕上打印两行消息,下面是运行结果:
 

然后我们用cdb调试器看看定义的那两个字符串变量在内存中到底是怎么样的:
 
恩,它们是以asii码的形式存在的。
其他的数据类型我会在下面的各个章节会随着编程的算法和调试一起讲解。

3:顺序程序设计
汇编语言的顺序编程比较好理解,就是在编程的时候没有跳转,没有循环,看看例子ch3-1:
例 ch3-1:输入三角形的边长,求三角形的面积。
我假设输入的三边长都是能构成三角形的,求三角形面积的公式为area=s(s-a)(s-b(s-c)。
s=(a+b+c)/2.
这里要用到浮点指令,那就先回顾下浮点指令的用法:这里要加减乘除和平方根五种指令,由于Intel的浮点数据寄存器是种堆栈结构,我们要记住这一点。

先看看数据传送指令:fld和fild,fst,fstp:
fld 源操作数,源操作数可以是浮点寄存器和内存,这个指令主要是把源操作数压入浮点寄存器堆栈(其实就是st0),如果源操作数是整数,那就用fild。
Fst和fstp是把st(0)浮点寄存器中的数弹出到目的操作数中,目的操作数可以为浮点寄存器和内存。

加减法指令:fadd,faddp,fub,fsubp
第一种形式:fadd   目的操作数,源操作数。其中目的操作数,源操作数可以为浮点寄存器和内存。
第二种形式:fadd  源操作数,我本人比较喜欢这种,它不会把我脑海里的浮点寄存器的顺序弄乱,这种形式的源操作数只能是内存。减法指令同加法指令,就不多说了。

乘除法指令:fmul,fdiv
浮点的乘除法是不区分有符号和无符号数的,他们也有两种形式:
fmul目的操作数,源操作数 和 fmul 源操作数这两种形式,第一种 操作数和源操作数可以为浮点寄存器和内存,但第二种 源操作数 值能为内存。

平方根指令:fsqrt
这个指令就一种形式就是fsqrt,就是把第0个浮点寄存器st0 的值变成平方根值然后存在st0中。
再回到例题中,我们应该先算s值,然后再算平方根下面的值然后求平方根就行了。
S值是三边长除以2,转换成浮点指令就是:fld  a ;先把a值放到浮点寄存器st0中
                再就是  fadd b ;这个就是a+b,结果存在st0中
                然后  fadd c ;同上,结果存在st0中
现在算出了三边长的和,在除以2就ok了  fiv  two;结果在st0中,
最后把st0里面的值用fstp  s 存到s中就把s值算出来了。
再来算根号下面的值,这里有乘法和减法,我们先算减法:fld s
                          fsub,a;这个就是s-a,结果在st0里
                      再    fld  s
                        fsub b;这个结果还是在st0里,但是上面那个s-a已经被推到st(1)这个浮点堆栈了啊,记住了。
                    再    fld  s
                        fsub  c;这个结果还是在st0里,
那么s-a被推到st(2)了,s-b被推到st(1)了,s-c的值在st(0)中,这里千万不能及乱了啊,下一步算乘法,先算s*(s-c),        mul  s;果在st0li
                        fmul st(0),st(1)这一步是算s*(s-a)*(s-b)
      最后算s*(s-a)*(s-b)*(s-a)    fmul st(0),st(2),
然后把s*(s-a)*(s-b)*(s-a)的结果再求平方根  fsqrt   
再把这个平方根的值弹出到area中。
这是按照上面的想法写出的程序:
.386
.model flat,stdcall
option casemap:none

includelib  msvcrt.lib

printf  proto C :VARARG
scanf  proto C :VARARG

.data
msg1  db  "%f,%f,%f",0
msg2  db  "area=%7.2f",0ah,0dh,0
msg3  db  "please input three floating numbers",0ah,0dh,0
two  real4  2.0
.code
start:
  call  main
  ret
main proc
  local  a:real4
  local  b:real4
  local  c1:real4
  local  s:real4
  local  area:real8

  push  offset msg3
  call  printf
  add  esp,4

  lea  eax,c1
  push  eax
  lea  eax,b
  push  eax
  lea  eax,a
  push  eax

  push  offset msg1
  call  scanf
  add  esp,16

  fld  a
  fadd  b
  fadd  c1
  fdiv  two
  fstp  s

  fsub  a
  fsub  b
  fsub  c1

  fmul  s
  fmul  st,st(1)
  fmul  st,st(2)
  fsqrt
  fstp  area

  push  dword ptr area+8
  push  dword ptr area+4
  push  offset msg2
  call  printf
  add  esp,12
  
  ret
  main  endp
end  start
编译运行:下面是结果:
 
但是出乎意料哦,错了,怎么办呢?你发现什么问题了没?那只有调试看看了,用
cdb -2 C:\w\b\ch3\ch3-1\ch3-1打开程序然后逐步调试看看,当跟踪到下面这句是就发现有问题了:
 
就是fstp,s,也就是00401041 d95df0          fstp    dword ptr [ebp-10h]  ss:0023:0013ffac=a9e45d08,然后发现st中的值被弹走了,但紧接着又用st(0)用与下一步进行计算了,先推出调试,改动下再运行看看对不对,但结果还是错的:
 
那还得继续调试了,发现我对fsub指令理解错了,原来这个指令执行完之后它不把结果推到下一个浮点堆栈:
 
那只能用fsubp了,改动如下:
fld  a
  fsubp  st(1),st

  fld  s
  fld  b
  fsubp  st(1),st

  fld  s
  fld  c1
  fsubp  st(1),st  ;然后改成这种了
但结果还是错的,一看到这句push  dword ptr area+8
               push  dword ptr area+4
想一下“高低原则”,改成   push  dword ptr area+4
               push  dword ptr area+8
编译运行,哈哈,ok了:
 
最后正确的代码:
.386
.model flat,stdcall
option casemap:none

includelib  msvcrt.lib

printf  proto C :VARARG
scanf  proto C :VARARG

.data
msg1  db  "%f,%f,%f",0
msg2  db  "area=%7.2f",0ah,0dh,0
msg3  db  "please input three floating numbers",0ah,0dh,0
two  real4  2.0
.code
start:
  call  main
  ret
main proc
  local  a:real4
  local  b:real4
  local  c1:real4
  local  s:real4
  local  area:real8  ;这里是变量定义

  push  offset msg3
  call  printf
  add  esp,4    ;这里是提示输入三个边长

  lea  eax,c1
  push  eax
  lea  eax,b
  push  eax
  lea  eax,a
  push  eax

  push  offset msg1
  call  scanf
  add  esp,16    ;这里是调用库函数scanf

  fld  a
  fadd  b
  fadd  c1
  fdiv  two
  ;fstp  s    这一句其实是有问题的,你可以调试看看
  fst  s    ;改成这句

  ;fsub  a
  ;fsub  b
  ;fsub  c1    ;经调试发现这三句都是错的
  
  fld  a
  fsubp  st(1),st

  fld  s
  fld  b
  fsubp  st(1),st

  fld  s
  fld  c1
  fsubp  st(1),st  ;然后改成这种了
          

  fmul  s
  fmul  st,st(1)
  fmul  st,st(2)
  fsqrt
  fstp  qword ptr area    ;这一段是计算area值,我的文档上有详细解释

  push  dword ptr area+4
  push  dword ptr area+8
  push  offset msg2
  call  printf
  add  esp,12    ;打印结果
  
  ret
  main  endp
end  start
呵呵,定义的时候用了c1,因为c是汇编里面的关键字,所以我就改了下,你可能会说,你怎么不优化一下呢?呵呵,先把程序写对了,把指令理解透了再去优化也不晚。
练习ch2-2:
求下面x1和x2的值:
x1=(b+b*b-4ac)/2a,  x2=(b- b*b-4ac)/2a,  a,b,c由键盘输入。
提示下真确运行结果:
a=1,b=3,c=2
x1=-1.00
x2=-2.00




















4.选择分支结构程序设计
前面我们看到的程序都是从上到下这样执行的,程序的执行流程没有跳转和循环,cpu为我们实现程序的跳转提供了硬件环境和一些指令,首先cpu它有个处理器状态寄存器,跳转指令就是无条件跳转jmp和有条件跳转指令jcc(里面包含了很多种形式的),总的来说就是你在你写的程序里面用跳转指令让cpu取改变程序的执行流程,cpu会根据那个状态寄存器的一个或多个值的改变来执行程序,我们先来看个例子:
例 4.1:输入3个整数a,b,c,请输出其中最大的数。
我们只要一次把这三个数比较一次,在每次比较中,把那个大值继续和下一个数来做比较,然后再输出那个最大值就行了。代码如下:
.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib
printf  proto   c:VARARG
scanf  proto   c:VARARG
.data

msg1  db  "please input three int numbers",0ah,0dh,0
msg2  db  "The Max of three numbers is =%d",0ah,0dh,0
msg3  db  "%d,%d,%d",0
.code

start:
  call  main
  ret

main  proc
  
  local  a:dword
  local  b:dword
  local  c1:dword
  
  push  offset msg1
  call  printf
  add  esp,4

  lea  eax,c1
  push  eax
  lea  eax,b
  push  eax
  lea  eax,a
  push  eax
  push  offset msg3
  call  scanf
  add  esp,16    ;提示用户输入三个整型数
  
  mov  eax,a
  cmp  eax,b
  jg  a_compare_c     ;跳转到将a与c比较
  mov  eax,b
  cmp  eax,c1
  jg  print_max  ;到这里三个数已经全部比较完,跳转到打印最最大值
  @@:
  mov  eax,c1    ;到这里三个数已经全部比较完,跳转到打印最最大值
  jmp  print_max  
  a_compare_c:
  cmp  eax,c1
  jg  print_max  ;到这里三个数已经全部比较完,跳转到打印最最大值
  jmp  @b

  print_max:
  push  eax
  push  offset msg2
  call  printf
  add  esp,8
  ret
  
  main  endp
end  start
运行结果:
 
无论是整数还是负数,结果都是正确的。这里的cmp指令相当于减法,只是它不保存运算结果,而是改变前面说的状态寄存器,具体的就是状态寄存器的符号位,零标志位,溢出标志位和进位位,然后那个条件跳转指令jg就会根据上面那些状态位来确定怎么跳转,这里的jg即使指令就是根据符号位和零标志位来确定跳转的,你可以用windbg验证一下。在分支程序设计中,在前面有比较,比较完之后看当前情况满足哪种情况,然后用跳转指令跳取即可,前面这个判断中是个最简单的判断,下面我们来看看比较复杂的情况,先看例子ch4-2:
例  ch4-2 输入一个年份,判断是否闰年。
在判断是否是闰年时,我们可以用一个复杂的判断表达式来包含所有的闰年条件,也就是当输入的年份(year%4==0&&year%100!==0)||year%400==0则输出这个年份是闰年,否则输出不是,现在的问题就是怎么把上面的那个复杂的判断用汇编语言来正确的表达,下面是代码:
.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib
printf  proto   c:VARARG
scanf  proto   c:VARARG
.data

msg1  db  "please input a year",0ah,0dh,0
msg2  db  "%d is not a leap year",0ah,0dh,0
msg3  db  "%d is  a leap yaer" ,0ah,0dh,0
msg4  db  "%d"
.code

start:
  call  main
  ret

main  proc
  
  local  year:dword
  local  leap:dword

  push  offset msg1
  call  printf
  add  esp,4    ;到这里是输出提示信息

  lea  eax,year
  push  eax
  push  offset msg4
  call  scanf
  add  esp,8    ;这几句是调用输入函数把输入的年份存到year变量里

  mov  eax,year
  xor  edx,edx
  mov  ebx,400
  div  ebx
  test  edx,edx
  jz  is_a_leap_year ;这里先测试年份除以400,如果满足就直接跳转到打印是闰年的代码处
  
  mov  eax,year
  xor  edx,edx
  mov  ebx,4
  div  ebx
  test  edx,edx         ;到这里就是判断闰年的第二种情况了,如果除以4,不能整除就直接跳到打印不是闰年的代码处
  jnz  is_not_a_year  ;如果能整除就继续判断
  mov  eax,year
  xor  edx,edx
  mov  ebx,100
  div  ebx
  test  edx,edx
jz  is_not_a_year  ;这里是继续判断这个年份能不能整除100,如果你能整除就跳到打印不是闰年代码处
is_a_leap_year:
  push  year
  push  offset msg3
  call  printf
  add  esp,8    ;打印是闰年的信息
  jmp  out_this_program ;然后跳转到退出本程序
is_not_a_year:
  push  year
  push  offset msg2
  call  printf
  add  esp,8    ;打印不是闰年消息
out_this_program:

  ret      ;退出本程序的地方
  main  endp
end  start
下面是运行结果:

C:\w\b\ch4\ch4-2>ch4-2
please input a year
2008
2008 is a leap yaer

C:\w\b\ch4\ch4-2>ch4-2
please input a year
2000
2000 is a leap yaer

C:\w\b\ch4\ch4-2>ch4-2
please input a year
1989
1989 is not a leap year

这里我们先判断那个比较简单的测试点就是看年份能不能能整除400,如果为真,就直接跳转到打印是闰年的代码处,然后再判断看能不能整除4,如果为假,就直接跳转到打印不是闰年的代码处,然后下面的就不用再判断了,呵呵,因为这里是&&逻辑与哦,就是著名的“短路表达式”,程序本身比较简单,就不多解释了。下面来看看判断语句的嵌套。




判断语句的嵌套:
判断语句的嵌套就是判断里面又有判断,呵呵,先看例子:
例 ch4-3:有一函数:
 
从题意可以看出,当输入一个x值,程序就得先判断是不是小与0啊,然后紧接着判断是不是等于0啊,再判断是不是大于0 啊,然后才算判断完全,下面是代码:
.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib
printf  proto   c:VARARG
scanf  proto   c:VARARG
.data

msg1  db  "please input a int number",0ah,0dh,0
msg2  db  "the Y value is %d",0ah,0dh,0
msg4  db  "%d"
.code

start:
  call  main
  ret

main  proc
  
  local  x:dword
  

  push  offset msg1
  call  printf
  add  esp,4    ;输出提示信息

  lea  eax,x
  push  eax
  push  offset msg4
  call  scanf
  add  esp,8    ;调用scanf将输入的一个值存在局部变量x里面

  ;mov  eax,x
  ;cmp  eax,-1
  ;je  Y_equal_minus_one
  ;test  eax,eax
  ;jz  Y_equal_zero
  ;cmp  eax,1
  ;je  Y-equal_one  未优化的嵌套判断语句
        
        ;下面是有点优化的嵌套判断语句
  mov  eax,x
  inc  eax    ;x如果是-1加1就是0啦,呵呵
  jle  Y_equal_minus_one  ;如果是0 就跳转到打印y值的代码处
  mov  eax,x
  test  eax,eax    ;用test来判断寄存器是否为0,感觉要比cmp eax,0要好很多,你可以用cdb看看
  jz  Y_equal_zero
  mov  eax,x
  dec  eax    ;x如果是1减1就是0啦,呵呵
  jae  Y_equal_one  ;如果是0 就跳转到打印y值的代码处
  
Y_equal_minus_one:
  push  -1
  push  offset msg2
  call  printf
  add  esp,8
  jmp  out_this_program ;这里如果不跳转的话就会执行到Y_equal_zero了,这明显是不行的,所要跳转
Y_equal_zero:
  xor  eax,eax
  push  eax
  push  offset msg2
  call  printf
  add  esp,8
  jmp  out_this_program ;这里如果不跳转的话就会执行到Y_equal_zero了,这明显是不行的,所要跳转
Y_equal_one:
  push  1
  push  offset msg2
  call  printf
  add  esp,8    ;这里就不要再跳转了,直接执行到下面就行了
out_this_program:
  ret      
  main  endp
end  start
下面是运行结果:
C:\w\b\ch4\ch4-3>ch4-3
please input a int number
0
the Y value is 0

C:\w\b\ch4\ch4-3>ch4-3
please input a int number
-56
the Y value is -1

C:\w\b\ch4\ch4-3>ch4-3
please input a int number
56
the Y value is 1
像这种判断嵌套的地方,就是不停的比较,然后根据判断结果跳转到要执行的地方,下面我们来看看浮点数的判断,在比较完两个浮点数之后,我们紧接着得用fstsw将FPU的状态寄存器里面的比较结果存到一个16位的内存位置或者是个16位的寄存器,但最好是存在ax中,因为紧接着就得用sahf指令把浮点数比较的结果存到标志寄存器EFLAGS中,然后我们就可用JCC条件跳转指令来实现跳转了,具体的化来看看例子:
例子 ch4-4: 
这个一元二次方程怎么求解,大家应该很熟悉了吧,就不多说了,下面来看看怎么实现浮点数的比较,代码如下:
.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib
printf  proto   c:VARARG
scanf  proto   c:VARARG
.data
zero  dq  0.0000001
four  dw  4
msg1  db  "please input three numbers",0ah,0dh,0
msg2  db  "%f,%f,%f",0
msg3  db  "The equation is not a quadratic" ,0ah,0dh,0
msg4  db  "The equation has two cpmplex roots: %8.4f+%8.4fi",0ah,0dh,0
msg5  db  "The equation has two cpmplex roots: %8.4f-%8.4fi",0ah,0dh,0
msg6  db  "The equation has two equal roots: %8.4f",0ah,0dh,0
msg7  db  "The equation has two real roots: %8.4f,%8.4f",0ah,0dh,0
.code

start:
  call  main
  ret

main  proc
  
  local  a:dword
  local  b:dword
  local  c1:dword
  local  d:dword
  local  disc:dword
  local  x1:qword
  local  x2:qword
  local  realpart:qword
  local  imagpart:qword
  local  x:qword    ;一些局部变量定义

  push  offset msg1
  call  printf
  add  esp,4    ;打印提示消息

  lea  eax,c1
  push  eax
  lea  eax,b
  push  eax
  lea  eax,a
  push  eax
  push  offset msg2
  call  scanf
  add  esp,12    ;调用scanf函数得到方程的三个系数

  fld  a
  fabs
  fcom  zero    ;这里就是浮点数的比较和判断了,如果a位零
  fnstsw  ax
  sahf
  jb  is_not_quadratic  ;就跳转到打印消息的代码处然后退出本程序
  
  fld  b
  fmul  b
  
  fild  four
  fmul  a
  fmul  c1
  fsubp  st(1),st
  
  fst  disc      ;到这里就是计算b*b-4ac
  
  fabs
  fcom  zero      ;将b*b-4ac与零比较,
  fnstsw  ax
  sahf
  jbe  two_equal_roots    ;等于零,就跳转到计算有两个相等的实根处

  fld  disc
  fcom  zero
  fnstsw  ax
  sahf
  ja  two_roots    ;大于零,就跳转到计算有两个不相等的实根处
  shr  four,1
  fild  four
  fmul  a
  fld  b
  fchs
  fdivp  st(1),st
  fstp  realpart

  fild  four
  fmul  a
  fld  disc
  fchs
  fsqrt
  fdivp  st(1),st
  fstp  imagpart    ;这部分人是计算有两个复数根的地方
  
  push  dword ptr imagpart+4
  push  dword ptr imagpart+8
  push  dword ptr realpart+4
  push  dword ptr realpart+8
  push  offset msg4
  call  printf
  add  esp,20

  push  dword ptr imagpart+4
  push  dword ptr imagpart+8
  push  dword ptr realpart+4
  push  dword ptr realpart+8
  push  offset msg5
  call  printf
  add  esp,20      ;到这里是打印两个复数根的代码处
  jmp  out_this_program
is_not_quadratic:
  push  offset msg3
  call  printf
  add  esp,4
  jmp  out_this_program  ;这一段代码是打印不是二次方程的消息
two_equal_roots:
  shr  four,1
  fild  four
  fmul  a
  fld  b
  fchs
  fdivp  st(1),st
  fstp  x

  push  dword ptr x+4
  push  dword ptr x+8
  push  offset msg6
  call  printf
  add  esp,12
  jmp  out_this_program  ;这一段是计算和打印有两个相等的实数根
two_roots:
  shr  four,1
  fild  four
  fmul  a
  
  fld  disc
  fsqrt
  fsub  b
  fdiv  st,st(1)
  fstp  x1

  fild  four
  fmul  a
  
  fld  disc
  fsqrt
  fchs
  fsub  b
  fdiv  st,st(1)
  fstp  x2

  push  dword ptr x2+4
  push  dword ptr x2+8
  push  dword ptr x1+4
  push  dword ptr x1+8
  push  offset msg7
  call  printf
  add  esp,20      ;这一段是计算和打印两个不相等的实数根

out_this_program:
  ret
  main  endp
end  start
下面是运行结果:
C:\w\b\ch4\ch4-4>ch4-4
please input three numbers
1,2,1
The equation has two equal roots:  -1.0000

C:\w\b\ch4\ch4-4>ch4-4
please input three numbers
2,6,1
The equation has two real roots:  -0.1771, -2.8229

C:\w\b\ch4\ch4-4>ch4-4
please input three numbers
1,2,2
The equation has two cpmplex roots:  -1.0000+  1.0000i
The equation has two cpmplex roots:  -1.0000-  1.0000i
从这里你可以看见浮点数的比较和整数的比较有很大的不同之处了吧?
下面我们来看看直接跳转表
直接跳转表类似于c语言里面的case语句,实现了程序的多分支跳转
先看例子,例子 ch4-5:给出一百分成绩,要求输出成绩等级‘A’,’B‘,C,D,E,90分以上就输出’A‘,80~89分为’B‘,70~79为’C’,60~69为’D‘,60以下为’E‘。
首先我们把打印成绩等级的代码写成直接定址表,方便程序的判断和跳转,代码如下:
.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib
printf  proto   c:VARARG
scanf  proto   c:VARARG
.data
onehunderd  dword 100.0
one    dword 1.0

msg1  db  "please input a score",0ah,0dh,0
msg2  db  "the score leveal is %c",0ah,0dh,0
msg3  db  "%d",0
.code

start:
  call  main
  ret

main  proc
  
  local  score:dword
  local  s:dword
  local  p:dword
  local  w:dword
  local  d:dword
  local  f:qword      
  
  
  
  push  dword ptr offset msg1
  call  printf
  add  esp,4      ;输出提示消息

  lea  eax,score
  push  eax
  push  offset msg3
  call  scanf
  add  esp,8      ;得到输入的的成绩

  mov  eax,score
  cmp  eax,60
  jb  less_60
  cmp  eax,70
  jb  less_70
  cmp  eax,80
  jb  less_80
  cmp  eax,90
  jb  less_90
  mov  ebx,0
  jmp  print_score  

  less_60:
  mov  ebx,16
  jmp  print_score
  less_70:
  mov  ebx,12
  jmp  print_score
  less_80:
  mov  ebx,8
  jmp  print_score
  less_90:
  mov  ebx,4    ;这一段根据输入的成绩来生成跳转表的序数

  print_score:
  jmp  short set
  table  dword print_a,print_b,print_c,print_d,print_e
  set  :
  call  dword ptr table[ebx]      ;这一段就是跳转表,根据前面的比较结果来跳转到相应的代码处
  

  print_a:
  push  'A'
  push  offset msg2
  call  printf
  add  esp,8
  ret

  print_b:
  push  'B'
  push  offset msg2
  call  printf
  add  esp,8
  ret

  print_c:
  push  'C'
  push  offset msg2
  call  printf
  add  esp,8
  ret

  print_d:
  push  'D'
  push  offset msg2
  call  printf
  add  esp,8
  ret

  print_e:
  push  'E'
  push  offset msg2
  call  printf
  add  esp,8
  ret

  out1:
  ret
  
  main  endp
end  start
下面是运行结果:
C:\w\b\ch4\ch4-5>ch4-5
please input a score
99
the score leveal is A

C:\w\b\ch4\ch4-5>ch4-5
please input a score
88
the score leveal is B

C:\w\b\ch4\ch4-5>ch4-5
please input a score
77
the score leveal is C

C:\w\b\ch4\ch4-5>ch4-5
please input a score
66
the score leveal is D
C:\w\b\ch4\ch4-5>ch4-5
please input a score
55
the score leveal is E

C:\w\b\ch4\ch4-5>



5:循环
先看看简单的一重循环,例子ch5-2:
例 ch5-2:求1+2+3+4。。。。。。+100 的和
如果不用循环来算的话,就是先算1+2,然后把结果再加到3,直到加到100,这里面计算部分都是重复的,既然是重复的,那我们就用循环来实现它,具体代码如下:
.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib

printf  proto   c:VARARG
.data


msg1  db  "The sum of 1+2+3...+100 is:%d",0ah,0dh,0

.code

start:
  call  main
  ret

main  proc
  
  local  sum:dword  
  local  i:dword
  
  
  mov  i,1
  mov  sum,0  ;这部分是初始化循环变量和存和的变量
again:      ;循环开始处
      
  cmp  i,100  ;比较循环变量,不满足就跳出循环
  ja  out_again

  mov  eax,i
  add  eax,sum
  mov  sum,eax
  inc  i
  jmp  again    ;这部分就是计算1+2+3+。。。100

  out_again:    ;这部分是循环结束的地方,打印结果
  push  sum
  push  offset msg1
  call  printf
  add  esp,8
  ret
  
  main  endp
end  start
运行结果:

C:\w\b\ch5\ch5-2>ch5-2
The sum of 1+2+3...+100 is:5050

总的来说,循环它有个循环初始值和结束值,先判断满足循环条件么,满足就进入循环体,不满足就退出循环。

例子ch5-1:
 
首先我们看看怎么算某个数的阶乘,用数学公式表达就是t=t*1,t=t*2…..t=t*n,
然后用个循环把这些乘积加起来就行了,我们用n作为循环控制的变量,它从1递增到20,然后用个临时变量temp保存着每个数的阶乘值,然后把temp值加起来存在sum中就行了,代码如下:.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib
printf  proto   c:VARARG
scanf  proto   c:VARARG
.data


msg1  db  "The sum of 1!+2!+3!...+20! is:%e",0ah,0dh,0

.code

start:
  call  main
  ret

main  proc
  
  local  sum:qword
  local  temp:dword
  local  n:dword
  
  
  mov  n,1
  fldz
  fstp  sum
  

  fld1
  fstp  temp
  
  again:
  cmp  n,20
  ja  outagain
  fimul  n
  fadd  sum
  fst  sum
  inc  n
  jmp  again

outagain:
  fstp  sum
  push  dword ptr sum+4
  push  dword ptr sum+8
  push  offset msg1
  call  printf
  add  esp,12
  ret
  
  main  endp
end  start
运行结果如下:
C:\w\b\ch5\ch5-1>ch5-1
The sum of 1!+2!+3!...+20! is:-1.#QNAN0e+000
呵呵,错的不行,唉,仔看看程序,实在没看出哪里错了,只好调试了,用cdb -2 C:\w\b\ch5\ch5-1\ch5-1 打开程序,然后用rm f 打开我们想要看的寄存器,然后用g @$exentry跳到我们的这个程序,然后单步跟踪程序发现ch5_1!main+0x1d:
00401023 da4df0          fimul   dword ptr [ebp-10h]  ss:0023:0013ffac=00000001这句时,发现st0是个不定值,st0= 0.183338657867652323710e+0834,所以乘出来当然是错的哦,然后就不停的改,调试,最后终于正确了,结果如下:
C:\w\b\ch5\ch5-1>ch5-1
The sum of 1!+2!+3!...+20! is:2.561326e+018
最后正确的代码:
.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib
printf  proto   c:VARARG
scanf  proto   c:VARARG
.data


msg1  db  "The sum of 1!+2!+3!...+20! is:%e",0ah,0dh,0

.code

start:
  call  main
  ret

main  proc
  
  local  sum:qword
  local  temp:dword
  local  n:dword
  
  
  mov  n,1  ;初始化循环变量n

  fldz
  fstp  sum  ;初始化存和的变量
  

  fld1
  fstp  temp  ;初始化计算阶乘的变量
  
  again:
  cmp  n,20
  ja  outagain  ;不满足循环条件就退出循环
  fld  temp
  fild  n
  fmulp  st(1),st
  fst  temp
  fld  sum
  faddp  st(1),st
  fstp  sum
  inc  n
  jmp  again    ;这一段就是计算 temp=temp*n,sum=sum+temp,就相当于算出了1!+2!+3!。。。20!


outagain:
  
  push  dword ptr sum+4
  push  dword ptr sum+8
  push  offset msg1
  call  printf
  add  esp,12
  ret      ;打印结果
  
  main  endp
end  start
写浮点运算的时候,一定得弄清楚浮点寄存器的变化哦,要不然都不直到程序是错在哪里了,只有多调试,在调试的时候看每个浮点指令对浮点寄存器的影响,然后慢慢的就有感觉了的哦,就很清楚要用哪些浮点指令,脑袋就很清楚了,不再是浆糊啦。

下面我们再来看看多重循环:
多重循环就是循环里面有循环,先看个例子:
 
呵呵,我们先看这个图形的上半部分,一共有四行,每行的※号是呈1,3,5,7递增的,所以我们先用3个循环,外循环控制总共打印多少行,第二 个循环控制每行打印多少个空格 第三个循环控制打印多少个*号,然后同理再打印出下半部分就可以了,代码如下:
.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib
printf  proto   c:VARARG
scanf  proto   c:VARARG
.data

msg1  db  '*',0
msg2  db  ' ',0
msg3  db  0ah,0dh
.code

start:
  call  main
  ret

main  proc
  
  local  i:dword
  local  j:dword
  local  k:dword

  mov  i,0
for1:
  cmp  i,3
  ja  outfor1    ;第一层循环判断,不满足就退出
  mov  j,0
print_space:
  mov  eax,2
  sub  eax,i
  cmp  j,eax
  jg  outfor2
  push  offset msg2  ;空格数是2-i
  call  printf
  add  esp,4
  inc  j
  jmp  print_space  ;这一段是打印空格
outfor2:
  mov  k,0
print_x:
  mov  eax,i
  imul  eax,eax,2
  cmp  k,eax
  ja  print_crlf
  push  offset msg1  ;*号数是2*i
  call  printf
  add  esp,4
  inc  k
  jmp  print_x    ;这一段是打印*号
  
print_crlf:
  push  offset msg3
  call  printf
  add  esp,4
  inc  i    ;这一段是打印回车换行
  jmp  for1    ;到这里就跳转到第一层循环
outfor1:

  mov  i,0
for11:
  cmp  i,2
  ja  outfor11
  
  mov  j,0
print_spcae1:
  mov  eax,i
  cmp  j,eax
  jg  outfor22
  
  push  offset msg2
  call  printf
  add  esp,4
  inc  j    ;空格数是i
  jmp  print_spcae1
outfor22:
  mov  k,0
printf_x1:
  mov  eax,i
  imul  eax,eax,2
  mov  ebx,4
  sub  ebx,eax
  cmp  k,ebx
  ja  ptint_crlf1

  push  offset msg1
  call  printf
  add  esp,4
  inc  k    ;※号数是4-2*i
  jmp  printf_x1
ptint_crlf1:
  push  offset msg3
  call  printf
  add  esp,4
  inc  i
  jmp  for11
outfor11:
  ret
  
  main  endp
end  start
运行结果:
C:\w\b\ch5\ch5-3>ch5-3
   *
  ***
 *****
*******
 *****
  ***
   *
这里主要弄清,需要及个循环,及每个循环要打印东西的数目,理清了这些就比较容易写程序了。

6.数组和指针
数组其实就是一片连续的存放着同类型数据的内存,指针就是存放着某种数据类型的内存地址,它们之间其实在汇编层是差不多的,看看例子:
例 ch6-1:用下标法输出数组的全部元素
.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib

printf  proto   c:VARARG

.data

msg1  db  "%d",0ah,0dh,0
.code

start:
  call  main
  ret

main  proc
  
  local  i:dword    ;定义了一个循环变量,就是数组的下标
  local  a[10]:byte  ;定义了一个10个字节的数组
  local  b[10]:dword  ;定义了一个10个双字的数组
  local  p    :byte  ;定义了一个字节变量,这里可以把它看成是字节指针
  local  p1   :dword  ;定义了一个双字变量,这里可以把它看成是双字指针
  
  mov  i,0
  mov  ebx,i
again:  
  cmp  i,9
  mov  eax,i
  ja  out_again
  mov  byte ptr a[ebx],al ;这句就是用下标访问数组了,和下面的比较下,想想为什么
  inc  i
  jmp  again    ;这一段代码主要是往a数组里面依次存入0,1,2,。。。9
  
out_again:
  mov  i,0
  mov  ebx,i
  
  again1:
  cmp  i,9
  mov  eax,i
  ja  print_arry
  mov  b[ebx*4],eax  ;根据下标i访问数组,和上面那句比较下看看
  inc  i
  jmp  out_again
print_arry:
  
  mov  i,0
  mov  ebx,i
loop_print_arry:
  cmp  i,9
  ja  out_print_arry
  mov  al,byte ptr a[ebx]
  movzx  eax,al
  push  eax
  push  offset msg1
  call  printf
  add  esp,8
  jmp  loop_print_arry  ;循环打印字节数组
out_print_arry:
  mov  i,0
  mov  ebx,i
loop_print_arry1:
  cmp  i,9
  ja  out_this_program
  mov  eax,dword ptr b[ebx*4]
  
  push  eax
  push  offset msg1
  call  printf
  add  esp,8
  jmp  loop_print_arry1 ;循环打印双字节数组

out_this_program:

  ret
  
  main  endp
end  start
编译运行一看,程序没能运行正常,再看看自己写的那些代码,又看不出什么问题,那又只好在调试器里面找问题了,经调试发现这句mov  ebx,i
应该放到循环语句的里面,然后再把这句 out_ again:
                   mov  i,0
里面的mov  i,0放到out_ again:的前面,然后在打印每个数组元素的语句后面加上 inc i,然后编译运行,终于正确了,下面是运行结果:
C:\w\b\ch6\ch6-1>ch6-1
0123456789
0123456789
第-行输出是字节数组的,第二行输出是双字节数组的
最后经调试发现错误后改正的代码:
.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib

printf  proto   c:VARARG

.data

msg1  db  "%d",0
msg2  db      0ah,0dh,0
.code

start:
  call  main
  ret

main  proc
  
  local  i:dword    ;定义了一个循环变量,就是数组的下标
  local  a[10]:byte  ;定义了一个10个字节的数组
  local  b[10]:dword  ;定义了一个10个双字的数组
  local  p    :byte  ;定义了一个字节变量,这里可以把它看成是字节指针
  local  p1   :dword  ;定义了一个双字变量,这里可以把它看成是双字指针
  
  mov  i,0
  
again:  
  
  
  cmp  i,9
  mov  ebx,i
  mov  eax,i
  ja  out_again
  mov  byte ptr a[ebx],al ;这句就是用下标访问数组了,和下面的比较下,想想为什么
  inc  i
  jmp  again    ;这一段代码主要是往a数组里面依次存入0,1,2,。。。9
  
  
out_again:
  mov  i,0
again1:
  cmp  i,9
  mov  eax,i
  mov  ebx,i
  ja  print_arry
  mov  b[ebx*4],eax  ;根据下标i访问数组,和上面那句比较下看看
  inc  i
  jmp  again1
print_arry:
  
  mov  i,0
  
loop_print_arry:
  cmp  i,9
  ja  out_print_arry
  mov  ebx,i
  mov  al,byte ptr a[ebx]
  movzx  eax,al
  push  eax
  push  offset msg1
  call  printf
  add  esp,8
  inc  i
  jmp  loop_print_arry  ;循环打印字节数组
out_print_arry:
  push  offset msg2
  call  printf
  add  esp,4  ;这里打印回车换行

  mov  i,0
  
loop_print_arry1:
  cmp  i,9
  mov  ebx,i
  ja  out_this_program
  mov  eax,dword ptr b[ebx*4]
  
  push  eax
  push  offset msg1
  call  printf
  add  esp,8
  inc  i
  jmp  loop_print_arry1 ;循环打印双字节数组

out_this_program:
  push  offset msg2
  call  printf
  add  esp,4    ;这里打印回车换行
  ret
  
  main  endp
end  start
呵呵,你可以和前面的代码比较看看,如果你看不出第一个程序的问题,最好的是你把第一个代码编译运行,自己调试着看看,保你收获多多。

下面看看用指针试试:看例子ch6-2:
例 ch6-2:用指针输出数组的全部元素









代码如下:

.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib

printf  proto   c:VARARG

.data

msg1  db  "%d",0
msg2  db      0ah,0dh,0
.code

start:
  call  main
  ret

main  proc
  
  local  i:dword    ;定义了一个循环变量,就是数组的下标
  local  a[10]:byte  ;定义了一个10个字节的数组
  local  b[10]:dword  ;定义了一个10个双字的数组
  local  p    :dword  ;定义了一个双字变量,这里可以把它看成是字节指针,至于怎么会这样,请看下面代码
  local  p1   :dword  ;定义了一个双字变量,这里可以把它看成是双字指针
  
  mov  i,0  
again:  
  
  
  cmp  i,9
  mov  ebx,i
  mov  eax,i
  ja  out_again
  mov  byte ptr a[ebx],al ;这句就是用下标访问数组了,和下面的比较下,想想为什么
  inc  i
  jmp  again    ;这一段代码主要是往a数组里面依次存入0,1,2,。。。9
  
  
out_again:
  mov  i,0
again1:
  cmp  i,9
  mov  eax,i
  mov  ebx,i
  ja  print_arry
  mov  b[ebx*4],eax  ;根据下标i访问数组,和上面那句比较下看看
  inc  i
  jmp  again1


print_arry:
  lea  eax,a
  mov  p,eax
  add  eax,10
loop_print_arry:
  
  cmp  p,eax
  ja  out_print_arry
  
  mov  bl,byte ptr p ;这里就是把双字节指针当成字节用
  movzx  ebx,bl
  push  ebx
  push  offset msg1
  call  printf
  add  esp,8
  inc  p
  
  jmp  loop_print_arry  ;循环打印字节数组
out_print_arry:
  push  offset msg2
  call  printf
  add  esp,4  ;这里打印回车换行

  
  lea  eax,b
  mov  p1,eax
  add  eax,40
loop_print_arry1:
  
  cmp  p1,eax
  ja  out_this_program

  
  mov  ebx,dword ptr p
  push  ebx
  push  offset msg1
  call  printf
  add  esp,8
  add  p,4
  
  jmp  loop_print_arry1 ;循环打印双字节数组

out_this_program:
  push  offset msg2
  call  printf
  add  esp,4    ;这里打印回车换行
  ret
  
  main  endp
end  start
但是我们得到了很奇怪的结果,没办法啦,只有调试咯,经调试发现mov  bl,byte ptr p 这句访问数组元素根本访问不到,因为ch6_2!main+0x3f:
00401045 8d45f2          lea     eax,[ebp-0Eh]
0:000>
eax=0013ffae ebx=0000000a ecx=0013ffb0 edx=7c90e514 esi=00000000 edi=00000000
eip=00401048 esp=0013ff7c ebp=0013ffbc iopl=0         nv up ei pl nz na po nc
cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000202
ch6_2!main+0x42:
00401048 8945c4          mov     dword ptr [ebp-3Ch],eax ss:0023:0013ff80=852c3fe0
0:000>
eax=0013ffae ebx=0000000a ecx=0013ffb0 edx=7c90e514 esi=00000000 edi=00000000
eip=0040104b esp=0013ff7c ebp=0013ffbc iopl=0         nv up ei pl nz na po nc
cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000202
因为a的首地址是0013ffae,当执行这句mov  bl,byte ptr p 时,你可以看到调试器是这样的:
00401048 8945c4          mov     dword ptr [ebp-3Ch],eax ss:0023:0013ff80=852c3fe0
哈哈,它访问了0013ff80 里面的元素了,唉,怎么办呢?
我想只能用第一个那种寄存器间接寻址方式了,呵呵,又回到第一种访问方式了。
发现第二个错误就是这个程序调用了printf之后,就改变了eax,ecx,ebx的值,反正就是我们这里用到的寄存器都被它改了。然后修改后的程序如下:

.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib

printf  proto   c:VARARG

.data

msg1  db  "%d",0
msg2  db      0ah,0dh,0
.code

start:
  call  main
  ret

main  proc
  
  local  i:dword    ;定义了一个循环变量,就是数组的下标
  local  a[10]:byte  ;定义了一个10个字节的数组
  local  b[10]:dword  ;定义了一个10个双字的数组
  local  p    :dword  ;定义了一个双字变量,这里可以把它看成是字节指针,至于怎么会这样,请看下面代码
  local  p1   :dword  ;定义了一个双字变量,这里可以把它看成是双字指针
  
  mov  i,0  
again:  
  
  
  cmp  i,9
  mov  ebx,i
  mov  eax,i
  ja  out_again
  mov  byte ptr a[ebx],al ;这句就是用下标访问数组了,和下面的比较下,想想为什么
  inc  i
  jmp  again    ;这一段代码主要是往a数组里面依次存入0,1,2,。。。9
  
  
out_again:
  mov  i,0
again1:
  cmp  i,9
  mov  eax,i
  mov  ebx,i
  ja  print_arry
  mov  b[ebx*4],eax  ;根据下标i访问数组,和上面那句比较下看看
  inc  i
  jmp  again1


print_arry:
  lea  eax,a
  mov  p,eax
  add  eax,10
loop_print_arry:
  push  eax

  cmp  p,eax
  jae  out_print_arry
  
  mov  ecx,p
  mov  bl,byte ptr [ecx] ;这里就是把双字节指针当成字节用
  movzx  ebx,bl
  push  ebx
  push  offset msg1
  call  printf
  add  esp,8
  inc  p
  pop  eax

  jmp  loop_print_arry  ;循环打印字节数组
out_print_arry:
  push  offset msg2
  call  printf
  add  esp,4  ;这里打印回车换行

  
  lea  eax,b
  mov  p1,eax
  add  eax,40
loop_print_arry1:
  push  eax  ;由于下面的ptintf会改变我们这里要用到的寄存器,我用他们的时候就先保存
  cmp  p1,eax
  jae  out_this_program

  mov  ecx,p1
  mov  ebx,dword ptr [ecx]
  push  ebx
  push  offset msg1
  call  printf
  add  esp,8
  add  p1,4
  pop  eax     ;弹出保存的eax值
  jmp  loop_print_arry1 ;循环打印双字节数组

out_this_program:
  push  offset msg2
  call  printf
  add  esp,4    ;这里打印回车换行
  ret
  
  main  endp
end  start
下面是运行结果:
C:\w\b\ch6\ch6-2>ch6-2
0123456789
0123456789
呵呵,终于是对的了。
下面再来看看多重数组:
先看个最简单的例子ch6-3:输出一个二维数组,例如:
 
然后运行完程序在屏幕上打印如下:
 
然后写好的程序如下:

.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib

printf  proto   c:VARARG

.data

a  dd  1,2,3
  dd  4,5,6                    ;定义了一个两行三列的整数数组

msg1  db  "array a :",0ah,0dh,0
msg2  db      "%8d",0
msg3  db  0ah,0dh,0
.code

start:
  call  main
  ret

main  proc
  
  local  i:dword    
  local  j:dword      ;定义了两个循环变量
  
  
  push  offset msg1
  call  printf
  add  esp,4      ;打印消息
  
  mov  i,0
  mov  j,0      ;初始化两个循环变量
loop_1:
  cmp  i,1
  ja  out_loop_1
loop_2:
  cmp  j,2
  ja  out_loop_2

  mov  eax,3      ;首先这个数组每行有三个元素,所以要用当前的行数乘以3
  mul  i
  add  eax,j      ;然后再加上当前的列数,由于这个数组数四字节的,所以还要
  push  a[eax*4]    ;乘以4,你才能正确的访问每个数组元素
  push  offset msg2
  call  printf
  add  esp,8      ;内循环就是依次打印每行的数组元素

  inc  j
  jmp  loop_2
out_loop_2:
  inc  i
  push  offset msg3
  call  printf
  add  esp,4

  jmp  loop_1      ;这里是跳转到外循环,外循环是控制打印多少行
out_loop_1:
  ret
  
  main  endp
end  start
但是结果是这样的:
C:\w\b\ch6\ch6-3>ch6-3
array a :
       1       2       3
很明显是错的哦,你能在上面的那段程序里看出哪里错了么?呵呵,我反正没看出什么名堂来,经过调试之后发现,再进入第二次循环之前忘记把循环变量赋初值了!!!那我就在这里改了下:
ja  out_loop_1
  mov  j,0
再调试运行,结果如下:
C:\w\b\ch6\ch6-3>ch6-3
array a :
       1       2       3
       4       5       6
呵呵,是正确的,最后正确的代码如下:

.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib

printf  proto   c:VARARG

.data

a  dd  1,2,3
  dd  4,5,6                    ;定义了一个两行三列的整数数组

msg1  db  "array a :",0ah,0dh,0
msg2  db      "%8d",0
msg3  db  0ah,0dh,0
.code

start:
  call  main
  ret

main  proc
  
  local  i:dword    
  local  j:dword      ;定义了两个循环变量
  
  
  push  offset msg1
  call  printf
  add  esp,4      ;打印消息
  
  mov  i,0
          ;初始化两个循环变量
loop_1:
  cmp  i,1
  ja  out_loop_1
  mov  j,0      ;呵呵,就是错在这里了,再进入第二次循环之前忘记把循环变量赋初值了!!!
loop_2:
  cmp  j,2
  ja  out_loop_2

  mov  eax,3      ;首先这个数组每行有三个元素,所以要用当前的行数乘以3
  mul  i
  add  eax,j      ;然后再加上当前的列数,由于这个数组数四字节的,所以还要
  push  a[eax*4]    ;乘以4,你才能正确的访问每个数组元素
  push  offset msg2
  call  printf
  add  esp,8      ;内循环就是依次打印每行的数组元素

  inc  j
  jmp  loop_2
out_loop_2:
  inc  i
  push  offset msg3
  call  printf
  add  esp,4

  jmp  loop_1      ;这里是跳转到外循环,外循环是控制打印多少行
out_loop_1:
  ret
  
  main  endp
end  start
这里再回顾下怎么访问数组中的元素:
怎么访问一维数组中的元素:这个简单,就是用序数乘以元素的字节大小再加上数组基地址就可以了,比如在例子ch6-2 里面的这句mov  b[ebx*4],eax,就把eax里面的值存到了以ebx为序数(就是在数组中第几个中的几)乘以4,因为这个数组的每个元素是4字节的,再加上数组基地址b,就可以了。
怎么访问二维数组中的元素:
这个复杂点,就是先用每行数组元素的个数(是个常量)乘以当前行的序数再加上当前列的序数,再把这个值乘以元素的字节大小就可以了,比如在ch6-3里面的这一段代码:
mov  eax,3      ;首先这个数组每行有三个元素,所以要用当前的行数乘以3
  mul  i
  add  eax,j      ;然后再加上当前的列数,由于这个数组数四字节的,所以还要
  push   a[eax*4]
到了最后一句就是把数组a里面的第i行的第j个元素入栈,乘以3是因为这个二维数组是每行3个元素,好,下面再看个例子
例子ch6-4: 
 
为了求出其中最大的那个元素的值,我们的用循环遍历整个数组,然后就可以找出来了,代码如下:

.386
.model flat,stdcall
option casemap:NONE

includelib  msvcrt.lib

printf  proto   c:VARARG

.data

a  dd  1,2,3,4
  dd  9,8,7,6    ;定义了一个3*4的二维数组
  dd  -10,10,-5,2

msg1  db  "the max value of array a is: %d,it in row %d column %d of array a",0ah,0dh,0
    
.code

start:
  call  main
  ret

main  proc
  
  local  i:  dword    
  local  j:  dword  
  local  max:  dword
  local  row:  dword
  local  column: dword  ;局部变量定义

  mov  eax,a[0]
  mov  max,eax    ;这里相当于max=a【0,0】

  mov  i,0
loop_1:
  cmp  i,2
  ja  out_loop_1
  mov  j,0
loop_2:
  cmp  j,3
  ja  out_loop_2
  
  mov  eax,4
  mul  i
  add  eax,j
  mov  ebx,a[eax*4]  ;这里就是ebx等于当前a【i,j】
  cmp  ebx,max    ;这里是用a【i,j】和max做比较
  jg  change_max  ;如果a【i,j】大于max就将他们两个交换
  inc  j
  jmp  loop_2
change_max:
  mov  max,ebx
  mov  eax,i
  mov  row,eax
  mov  eax,j
  mov  column,eax
  inc  j
  jmp  loop_2
out_loop_2:
  inc  i
  jmp  loop_1
out_loop_1:
  push  column
  push  row
  push  max
  push  offset msg1
  call  printf
  add  esp,12    ;在两个循环外打印出题目的要求

  ret
  
  main  endp
end  start
下面是运行结果:
C:\w\b\ch6\ch6-4>ch6-4
the max value of array a is: 10,it in row 2 column 1 of array a

上传的附件 汇编语言学习笔记.doc