《汇编语言》论坛

. : : Assembly Language : : .	\| 首页 \| 我提出的问题 \| 我参与的问题 \| 我的收藏 \| 消息中心 \| 游客登录 \|

刷新 \| 提问 \| 未解决 \| 已解决 \| 精华区 \| 搜索 \|
《汇编语言》论坛－＞数据处理的两个基本问题

管理员： assembly

[回复本贴]　[收藏本贴]　[管理本贴]　[关闭窗口]

主题 : :　看看高手是怎么写试验7代码的！！！强烈推荐中... [待解决]

回复[ 104次 ] 点击[ 9683次 ]

liuxianming2001

[帖主] [ 发表时间：2008-10-10 02:55 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2008-09-03 00:18

DATAS  SEGMENT
              DB        '1975', '1976', '1977', '1978', '1979', '1980', '1981', '1982'
              DB        '1983', '1984', '1985', '1986', '1987', '1988', '1989', '1990'
              DB        '1991', '1992', '1993', '1994', '1995'

              DD        16, 22, 382, 1356, 2390, 8000, 16000, 24486, 50065, 97479, 140417, 197514
              DD        345980, 590827, 803530, 118300, 184300, 2759000, 3753000, 4649000, 5937000

              DW        3, 7, 9, 13, 28, 38, 130, 220, 476, 778, 1001, 1442, 2258, 2793, 4037, 5635, 8226
              DW        11542, 14430, 15257, 17800
       DATAS  ENDS

       TABLE  SEGMENT
              DB        21 DUP ('year summ ne ?? ')
       TABLE  ENDS

      STACKS  SEGMENT
              DB 16 DUP (0)
      STACKS  ENDS

ASSUME    CS:CODES,DS:DATAS,SS:STACKS

       CODES  SEGMENT
      START:
              ;相关寄存器初始化
              MOV       AX,DATAS
              MOV       DS,AX
              MOV       AX,TABLE
              MOV       ES,AX
              MOV       AX,STACKS
              MOV       SS,AX
              MOV       SP,16

              MOV       BX,0
              MOV       BP,0
              MOV       DI,0
              MOV       SI,0

              MOV       CX,21

      cycle:  ;使用栈复制年份
              PUSH      [DI].0
              PUSH      [DI].2
              POP       ES:[BP].2
              POP       ES:[BP].0

              ;使用栈复制收入
              PUSH      54H.[DI].0
              PUSH      54H.[DI].2
              POP       ES:[BP].7
              POP       ES:[BP].5

              ;使用栈复制雇员数
              PUSH      0A8H.[SI]
              POP       ES:[BP].0AH

              ;计算人均收入
              MOV       AX,ES:[BP].5
              MOV       DX,ES:[BP].7
              DIV WORD PTR ES:[BP].0AH
              MOV       ES:[BP].0DH,AX

              ADD       SI,2H
              ADD       DI,4H
              ADD       BP,10H

              loop cycle


              MOV       AH,4CH
              INT       21H
       CODES  ENDS
END       START

-------------------------------------------------------------------
栈的使用、结构化程序设计的思想...
话就不多说了，自己体会吧

mess

[第1楼] [ 回复时间：2008-10-15 17:36 ] [引用] [回复] [ top ]　

荣誉值：337
信誉值：0
注册日期：2008-01-01 17:48

强烈不推荐，没有写的一定要自己写才行，要不然试验的成效会大打折扣 :-)

lzzhy

[第2楼] [ 回复时间：2008-10-19 22:32 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2008-09-13 09:21

比较会用栈.

zhongsi

[第3楼] [ 回复时间：2008-10-27 10:53 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2007-11-06 16:12

assume cs:code
data segment
        db '1975','1976','1977','1978','1979','1980','1981','1982','1983'
        db '1984','1985','1986','1987','1988','1989','1990','1991','1992'
        db '1993','1994','1995'
        ;以上是表示21年的21个字符串

        dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
        dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000
        ;以上是表示21年公司总收的21个dword型数据

        dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226
        dw 11542,14430,45257,17800
        ;以上是表示21年公司雇员人数的21个word型数据
data ends

table segment
        db 21 dup('year summ ne ?? ')
table ends

; 堆栈段
stack segment
    db 16 dup(0)
stack ends

code segment
start:        mov ax, data
                mov ds, ax
                mov bx, 0
                mov si, 0

                mov ax, table
                mov es, ax
                mov bp, 0

                mov ax, stack
                mov ss, ax
                mov sp, 16

                mov cx, 21

        s:        ;计算
                push 84[bx]
                push 86[bx]
                pop dx
                pop ax
                div word ptr 168[si]
                ;进栈
                push ax
                push [bx]
                push 2[bx]
                push 84[bx]
                push 86[bx]
                push 168[si]
                ;出栈
                pop es:10[bp]
                pop es:7[bp]
                pop es:5[bp]
                pop es:2[bp]
                pop es:[bp]
                pop es:13[bp]
                ;准备下一轮循环
                add bx, 4
                add si, 2
                add bp, 16
                loop s

                mov ax, 4c00h
                int 21h
code ends
end start

xianxia

[第4楼] [ 回复时间：2008-10-31 15:23 ] [引用] [回复] [ top ]　

荣誉值：6
信誉值：6
注册日期：2008-10-15 11:11

还没有仔细看，但感觉思想和结构相当的好，我用了2个循环，结果还调了很长时间！思路还是很有差距，顶了！

xianxia

[第5楼] [ 回复时间：2008-10-31 15:30 ] [引用] [回复] [ top ]　

荣誉值：6
信誉值：6
注册日期：2008-10-15 11:11

一对比就是差距，佩服！

assume cs:codesg

data segment

db '1975','1976','1977','1978','1979','1980','1981','1982','1983'
db '1984','1985','1986','1987','1988','1989','1990','1991','1992'
db '1993','1994','1995'

dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197517
dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000

dw 3,7,9,13,28,38,130,220,476,778,1001,1443,2258,2793,4037,5635,8226
dw 11542,14430,15257,17800

data ends

table segment

db 21 dup ('year summ ne ??')

table ends

codesg segment

start: mov ax,data
        mov ds,ax
        mov ax,table
        mov ss,ax
        mov bx,0

        mov cx,21
    s0: mov dx,cx
        mov cx,4
        mov si,0

     s: mov al,[bx+si]
        mov [bp].0h.[si],al
        inc si
        loop s
        add bx,4
        add bp,16
        mov cx,dx
        loop s0


        mov bp,0
        mov si,bx

        mov cx,21

    s1: mov ax,[bx]
        mov dx,[bx+2]
        mov [bp].5h,ax
        mov [bp].7h,dx

        div word ptr [si].54h
        mov [bp].0dh,ax

        mov ax,[si].54h
        mov [bp].0ah,ax

        add bx,4
        add si,2
        add bp,16
        loop s1

        mov ax,4c00h
        int 21h

codesg ends

end start

zcouyangpeng

[第6楼] [ 回复时间：2008-11-02 11:23 ] [引用] [回复] [ top ]　

荣誉值：35
信誉值：44
注册日期：2008-09-03 21:36

恩不错栈命令在这个实验确实比MOV强多了学习了

zcouyangpeng

[第7楼] [ 回复时间：2008-11-04 23:34 ] [引用] [回复] [ top ]　

荣誉值：35
信誉值：44
注册日期：2008-09-03 21:36

assume cs:code

data segment
  db '1975','1976','1978','1979'
  dd 16,22,382,1356
  dw 3,7,9,13,28,38,130
data ends

table segment
  db 5 dup ('year summ ne ?? ')
table ends

stack segment
  db 16 dup(0)
stack ends

code segment
s:  mov ax,data
    mov ds,ax
    mov ax,table
    mov es,ax
    mov ax,stack
    mov ss,ax
    mov sp,16
    mov bx,0
    mov si,0
    mov di,0
    mov cx,4

xh: push 32[di]---压入人数
    push 18[si]
    push 16[si]---压入收入
    push 2[si]
    push [si]---压入年份
    pop es:[bx]
    pop es:2[bx]---一以上2句弹出年份
    pop es:5[bx]
    pop es:7[bx]---以上2句弹出收入
    pop es:0ah[bx]--弹出人数
    mov ax,es:5[bx]
    mov dx,es:7[bx]
    div word ptr es:0ah[bx]
    mov es:0dh[bx],ax--复制平均收入
    mov byte ptr es:4[bx],20h--以下4句对应TABLE段4空格
    mov byte ptr es:9H[bx],20h
    mov byte ptr es:0cH[bx],20h
    mov byte ptr es:0FH[bx],20h

    add si,4---以下3句为下次循环准备数据
    add di,2
    add bx,16
    loop xh

    mov ax,4c00h
    int 21h ----------共计32行代码
code ends
end s

此程序是看到有人用栈命令。所以我也写一个，果然简洁明了，省略很多DATA段的数据地址。看来栈命令对于复制数据要比MOV强很多。2种传送命令结合起来用，比单纯用MOV传送指令强。

在此再次感谢发贴的朋友，让我受到启发

younggay

[第8楼] [ 回复时间：2008-11-06 15:34 ] [引用] [回复] [ top ]　

荣誉值：273
信誉值：0
注册日期：2008-01-23 20:23

顶！！！

liuxianming2001

[第9楼] [ 回复时间：2008-11-22 07:18 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2008-09-03 00:18

好久没上来看，还以为没人顶了呢

继续努力学习，fighting!

ieyniiqpl

[第10楼] [ 回复时间：2008-11-27 12:00 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2008-11-20 00:49

多谢各位!!!受教了!!程序思想比我的好几倍,受益不浅!

theguiking

[第11楼] [ 回复时间：2009-01-13 22:55 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：1
注册日期：2008-12-16 19:25

栈用内存作为变量，比用寄存器的性能要低，但是可扩充性好，便于编写，而且这小程序根本目测不出来性能的差距。

gjcqfdy

[第12楼] [ 回复时间：2009-02-07 19:56 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2009-01-30 17:47

回复：[第11楼]
－－－－－－－－－－－－－－－－－－
up 确实应该考虑栈的效率

lonely

[第13楼] [ 回复时间：2009-04-13 17:44 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2009-02-21 16:37

算法太棒了！佩服！！佩服！！

whclc918

[第14楼] [ 回复时间：2009-04-19 12:08 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2009-04-19 11:55

高手啊！栈用的出神入化了。

cfcxg

[第15楼] [ 回复时间：2009-05-03 19:10 ] [引用] [回复] [ top ]　

荣誉值：9
信誉值：3
注册日期：2008-12-21 10:26

看来我还得对汇编语言编程的的思考方式有待更好的理解，我的思维相比之下感觉太死板了，对所学的知识及相关寄存器的使还很灵活。楼主的思维让深感佩服：）

zhenglxd

[第16楼] [ 回复时间：2009-05-11 09:59 ] [引用] [回复] [ top ]　

荣誉值：30
信誉值：0
注册日期：2009-04-09 10:05

这个题不过中规中矩而已客观点评价只能说比较清爽整体思路比较清晰

用栈只是为了数据交换方便而已你用一次循环实现还是多次循环实现不过是人省力和不省力的问题
处于维护的考虑楼主这个代码是值得肯定的但如果一个程序过长重复过多的话
仅一个循环是不现实的因为代码过长了！
把代码变短无非是总结规律用递归等方式代码越短越难懂和古文一样但是脑力和体力区别就在于此啊
如果仅仅从清晰易懂角度考虑高级语言也没有出现的必要的典型的累死写代码的
就这题而言 es:0～3 和 5～8 单元是有共同性的当然就为了这个2个而专门写个循环不划算
但是如果是20个200个呢？所以我觉得这道题不应该有你们那么高的评价
至于算法更加谈不上了

yangtuan2010

[第17楼] [ 回复时间：2009-06-07 12:54 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2009-06-03 15:34

我这个程序有一个错误！我不知道错在那里！
希望兄弟们帮忙解决以下
谢谢了！

assume cs:codesg,ds:data,es:table
data segment
     db '1975','1976','1977','1978','1979','1980','1981','1982','1983'
     db '1984','1985','1986','1987','1988','1989','1990','1991','1992'
     db '1993','1994','1995'
     ;以上是21个年份字符(0-83)

     dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
     dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000
     ;以上是21个双字型收入数据（84-167）

     dw 3,7,9,13,28,,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226
     dw 11542,14430,15257,17800
     ;以上是21个字型雇员数据（168—）

data ends

table segment
      db 21 dup ('year sume ne ??' )
table ends                           ;21个数据放置点

codesg segment
start:       mov ax,data
       mov ds,ax
       mov si,0
       mov di,0                      ;定义数据段

       mov ax,table
       mov es,ax
       mov bx,0                      ;定义table段

       mov cx,21                     ;循环21次

s:     mov ax,ds:[si]
       mov word ptr es:[bx],ax
       mov ax,ds:[si+2]
       mov word ptr es:[bx+2],ax              ;完成年份的处理

       mov ax,ds:[168+di]
       mov word ptr es:[bx+10],ax             ;完成雇员数据的处理

       mov ax,ds:[84+si]
       mov word ptr es:[bx+5],ax
       mov dx,ds:[86+si]
       mov word ptr es:[bx+7],dx              ;完成收入数据的处理

       div word ptr es:[bx+10]
       mov word ptr es:[bx+13],ax             ;完成人均收入数据的处理

       add si,4
       add di,2
       add bx,10h               ;为下一轮做准备
       loop s

       mov ax,4c00h
       int 21h                        ;返回

codesg ends
end start

tsembrace

[第18楼] [ 回复时间：2009-06-24 22:49 ] [引用] [回复] [ top ]　

荣誉值：31
信誉值：3
注册日期：2009-06-15 19:20

用栈在这里会显得思路很顺。。受教了，我的代码，纯mov的。。
assume cs:codesg
data segment
db '1975','1976','1977','1978','1979','1980','1981','1982','1983','1984'
db '1985','1986','1987','1988','1989','1990','1991','1992','1993','1994'
db '1995'

dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000

dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258
dw 2793,4037,5635,8226,11542,14430,15257,17800

data ends

table segment
db 21 dup ('year summ ne ?? ')
table ends

codesg segment
start:
   mov ax,data
   mov ds,ax
   mov ax,table
   mov es,ax
   mov bx,0
   mov bp,0
   mov si,0
   mov di,0
   mov cx,15h
s: mov ax,ds:[bx]
   mov es:[bp],ax
   mov ax,ds:[bx+2]
   mov es:[bp+2],ax

   mov ax,ds:[si+84]
   mov es:[bp+5],ax
   mov ax,ds:[si+86]
   mov es:[bp+7],ax

   mov ax,ds:[di+168]
   mov es:[bp+10],ax

   mov ax,ds:[si+84]
   mov dx,ds:[si+86]
   div word ptr ds:[di+168]
   mov es:[bp+13],ax

   add bp,10h
   add bx,4
   add si,4
   add di,2
   loop s

   mov ax,4c00h
   int 21h
codesg ends
end start

lengxiaoyao

[第19楼] [ 回复时间：2009-06-30 13:05 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2009-06-30 10:29

有弊也有利

891204dh

[第20楼] [ 回复时间：2009-08-06 02:37 ] [引用] [回复] [ top ]　

荣誉值：2
信誉值：0
注册日期：2009-04-08 06:33

都说思路好,可指令多了点
我没用栈,不知道我的思路好不好?请大家看看
assume cs:code,ds:data,ss:table

data segment
        db '1975','1976','1977','1978','1979','1980','1981','1982','1983'
        db '1984','1985','1986','1987','1988','1989','1990','1991','1992'
        db '1993','1994','1995'
        ;21年的年份字符串,每个年份字符串都占了两个字的空间
        dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
        dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000
        ;21年,每年公司总收入的21个dword型数据
        dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226
        dw 11542,14430,15257,17800
        ;21年公司雇员人数的21个word型数据
data ends

table segment
        db 21 dup ('year summ ne ?? ')
table ends

code segment
  start:mov ax,data;初始化
        mov ds,ax
        mov ax,table
        mov ss,ax
        mov si,0;指向一年的年份数据,和总收入数据
        mov bx,0;指向一年的人数数据
        mov bp,0;指向表的行
        mov cx,21
      s:mov ax,[si];处理年的数据
        mov [bp],ax
        mov ax,[si+2]
        mov [bp+2],ax
        mov ax,[si+54H];处理总收入数据
        mov dx,[si+56H]
        mov [bp+5H],ax
        mov [bp+7H],dx
        div word ptr [bx+0a8H];处理人均收入数据
        mov [bp+0DH],ax
        mov ax,[bx+0a8H];处理人数数据
        mov [bp+0aH],ax;数据至此全部处理完毕
        add si,4;指向下一年
        add bp,10H;指向下一行
        add bx,2;指向下一年
        loop s
        mov ax,4c00H
        int 21H
code ends
end start

sjy9816

[第21楼] [ 回复时间：2009-08-06 08:41 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：6
注册日期：2009-06-21 14:14

我用栈做了一次，没成功，没转过弯来，放弃了！改用mov来做了，学习的有点肤浅了。看来要回头再学一遍了！

mrxliu

[第22楼] [ 回复时间：2009-08-08 15:56 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2009-07-23 11:44

为什么我的代码，只显示了所有年份，但收入那些却不出来

wtan

[第23楼] [ 回复时间：2010-01-08 00:36 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-01-03 08:56

栈用得相当好，作学习用很好，很佩服楼主，不过不能用在实际应用中，效率实在太差

qiangzi

[第24楼] [ 回复时间：2010-01-14 19:02 ] [引用] [回复] [ top ]　

荣誉值：4
信誉值：6
注册日期：2010-01-07 10:37

我觉得还是一定要写出自己的，然后再来对照。
有时候看着很简单，但是真正自己写的时候就不这么顺利了

regex

[第25楼] [ 回复时间：2010-01-14 22:56 ] [引用] [回复] [ top ]　

荣誉值：61
信誉值：0
注册日期：2009-12-19 01:51

为什么我的代码，只显示了所有年份，但收入那些却不出来
－－－－－－－－－－－－－－－－－－
回复：因为年份用的是ascii显示的。

regex

[第26楼] [ 回复时间：2010-01-15 00:00 ] [引用] [回复] [ top ]　

荣誉值：61
信誉值：0
注册日期：2009-12-19 01:51

楼主代码简练思路清晰，学艺一下~~~。

jesnop

[第27楼] [ 回复时间：2010-05-19 11:15 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：3
注册日期：2010-03-26 09:37

思路简洁清晰.

xbkaishui

[第28楼] [ 回复时间：2010-05-22 17:22 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-05-12 11:30

assume cs:codesg,ds:data,es:table

data segment

        db '1975','1976','1977','1978','1979','1980','1981','1982','1983'

        db '1984','1985','1986','1987','1988','1989','1990','1991','1992'

        db '1993','1994','1995'

        ;以上是表示21年的21个字符串

        dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514

        dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000

        ;以上是表示21年公司总收的21个dword型数据

        dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226

        dw 11542,14430,45257,17800

        ;以上是表示21年公司雇员人数的21个word型数据

data ends

table segment

        db 21 dup('year summ ne ?? ')

table ends

codesg segment

start:

        mov ax,data

        mov ds,ax

        mov ax,table

        mov es,ax

        mov bx,0

        mov si,0

        mov di,0

        mov cx,21

        s:   ;进入循环

                mov al,[bx]

                mov es:[di],al

                mov al,[bx+1]

                mov es:[di+1],al

                mov al,[bx+2]

                mov es:[di+2],al

                mov al,[bx+3]

                mov es:[di+3],al

                ;以上8句的作用是存放年份

                mov ax,54h[bx]     ;第一个'年收入'的段基址为54H

                mov dx,56h[bx]

                mov es:5h[di],ax

                mov es:7h[di],dx

                ;以上4句的作用是存放公司总收入

                mov ax,0A8h[si]    ;第一个'人数'的段基址为0A8H

                mov es:0Ah[di],ax

                ;以上2句是存放公司的人数

                mov ax,54h[bx]

                div word ptr ds:0A8h[si]

                mov es:0dh[di],ax

                ;以上3句是存放人均收入

                add bx,4

                add si,2

                add di,16

                ;以上3句是为下一次循环时存放数据做准备

                ;3个寄存器递增的速度决定了所要存取的数据的位置的偏移地址

        loop s  ;跳到标号s处

mov ax,4c00h

int 21h

codesg ends

end start

iseaside

[第29楼] [ 回复时间：2010-06-09 14:05 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-05-15 15:02

= =晕。。人家题目可没让用栈。。但也是一种。本来想用堆栈来解决。可惜要添足。索性不加。

jonytan

[第30楼] [ 回复时间：2010-06-30 09:17 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-05-04 17:53

3楼大哥！你的思路，确实不错，可是我总是调试通不过，为什么呢？在出栈的(POP ES:10[BX]),报错终止调试，能解释一下吗？

hzk123

[第31楼] [ 回复时间：2010-07-08 19:27 ] [引用] [回复] [ top ]　

荣誉值：2
信誉值：0
注册日期：2010-03-26 18:29

按楼主的代码，运行，发现1991年那行的有些数据跟答案里面的结果不一样。
是不是因为栈操作中的中断呢？？？？？

jjch224

[第32楼] [ 回复时间：2010-07-14 20:11 ] [引用] [回复] [ top ]　

荣誉值：16
信誉值：0
注册日期：2010-07-09 09:48

调试了一天，经master老大提醒，完成了。
assume cs:codesg,ds:data,ss:stacksg
data segment
db '1975','1976','1977','1978','1979','1980','1981','1982','1983'
db '1984','1985','1986','1987','1988','1989','1990','1991','1992'
db '1993','1994','1995'
;21年的21个字符串
dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000
;21年的总收入的dword型数据
dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226
dw 11542,14430,15257,17800
;21年雇员人员的word型数据
data ends
table segment
db 21 dup('year summ ne ?? ')
table ends
stacksg segment
        dw 4 dup (0,0,0,0);16个word型数据作为暂存
stacksg ends
codesg segment
start:        mov ax,data
        mov ds,ax
        mov ax,table
        mov es,ax
        mov ax,stacksg
        mov ss,ax
        mov sp,20h

        mov ax,0h
        mov di,0h
        mov si,0h

        mov bx,0h
        mov cx,15h
s0:        push cx;保护cx
        push si;si为雇员
        mov di,0h
        mov si,ax;si为年份
        mov cx,2h
        s1:        mov ax,ds:[si]
                mov es:[bx+di],ax;年份
                mov ax,ds:[si+54h]
                mov es:[bx+5h+di],ax;总收入
                add si,2h
                add di,2h
                loop s1
        pop ax;保护雇员
        push si;保护年份，此时ss:p为年份，ss:p+2为cx
        mov si,ax;雇员

        mov ax,ds:[si+0a8h]
        mov es:[bx+0ah],ax;雇员
        add si,2h
        push si;保护雇员，此时ss:p是雇员，ss:p+2为年份，ss:p+4为cx

        mov dx,es:[bx+7]
        mov ax,es:[bx+5]
        div word ptr es:[bx+0ah]
        mov es:[bx+0dh],ax;人均收入

        add bx,10h
        pop si;si为雇员
        pop ax;ax为年份
        pop cx;此时sp＝20h
        loop s0

        mov ax,4c00h
        int 21h
codesg ends
end start

infosecer

[第33楼] [ 回复时间：2010-07-17 18:31 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：2
注册日期：2010-07-16 14:24

回复：[第1楼]
－－－－－－－－－－－－－－－－－－
楼主挺好的，很清新。
发一下我的吧，应该是对的，刚刚做完
assume cs:codesg,ds:data
data segment
        ; 0
        db '1975','1976','1977','1978','1979','1980','1981','1982','1983'
        db '1984','1985','1986','1987','1988','1989','1990','1991','1992'
        db '1993','1994','1995'
        ; 84
        dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
    dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000
        ; 168
    dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226
    dw 11542,14430,15257,17800
data ends
table segment
    db 21 dup ('year summ me ?? ') ;0,5,10,13 year,sar,people,average
table ends

codesg segment

        start:  mov ax,data
                        mov ds,ax

                        mov ax,table
                        mov es,ax

                        mov bx,0

                        mov si,0
                        mov di,0

                        mov cx,21
                s0: mov ax,ds:[si]
                        mov es:[bx],ax
                        mov ax,ds:[si+2]
                        mov es:[bx+2],ax   ;年份
                        ;总收入
                        mov ax,ds:[si+84]  ;地位
                        mov es:[bx+5],ax
                        mov dx,ds:[si+2+84];高位
                        mov es:[bx+5+2],dx

                        div word ptr ds:[168+di] ;做除法
                        mov es:[bx+13],ax        ;人均
                        mov ax,ds:[168+di]
                        mov es:[bx+10],ax        ;雇员
                        add si,4    ;双字
                        add di,2         ;单字
                        add bx,16
                        loop s0
                        mov ax,4c00H
                        int 21H

codesg ends
        end start


调试显示的信息：

-d es:0 14f
1479:0000  31 39 37 35 20 10 00 00-00 20 03 00 20 05 00 20   1975 .... .. ..
1479:0010  31 39 37 36 20 16 00 00-00 20 07 00 20 03 00 20   1976 .... .. ..
1479:0020  31 39 37 37 20 7E 01 00-00 20 09 00 20 2A 00 20   1977 ~... .. *.
1479:0030  31 39 37 38 20 4C 05 00-00 20 0D 00 20 68 00 20   1978 L... .. h.
1479:0040  31 39 37 39 20 56 09 00-00 20 1C 00 20 55 00 20   1979 V... .. U.
1479:0050  31 39 38 30 20 40 1F 00-00 20 26 00 20 D2 00 20   1980 @... &. ..
1479:0060  31 39 38 31 20 80 3E 00-00 20 82 00 20 7B 00 20   1981 .>.. .. {.
1479:0070  31 39 38 32 20 A6 5F 00-00 20 DC 00 20 6F 00 20   1982 ._.. .. o.
1479:0080  31 39 38 33 20 91 C3 00-00 20 DC 01 20 69 00 20   1983 .... .. i.
1479:0090  31 39 38 34 20 C7 7C 01-00 20 0A 03 20 7D 00 20   1984 .|.. .. }.
1479:00A0  31 39 38 35 20 81 24 02-00 20 E9 03 20 8C 00 20   1985 .$.. .. ..
1479:00B0  31 39 38 36 20 8A 03 03-00 20 A2 05 20 88 00 20   1986 .... .. ..
1479:00C0  31 39 38 37 20 7C 47 05-00 20 D2 08 20 99 00 20   1987 |G.. .. ..
1479:00D0  31 39 38 38 20 EB 03 09-00 20 E9 0A 20 D3 00 20   1988 .... .. ..
1479:00E0  31 39 38 39 20 CA 42 0C-00 20 C5 0F 20 C7 00 20   1989 .B.. .. ..
1479:00F0  31 39 39 30 20 18 0D 12-00 20 03 16 20 D1 00 20   1990 .... .. ..
1479:0100  31 39 39 31 20 38 1F 1C-00 20 22 20 20 E0 00 20   1991 8... "  ..
1479:0110  31 39 39 32 20 58 19 2A-00 20 16 2D 20 EF 00 20   1992 X.*. .- ..
1479:0120  31 39 39 33 20 28 44 39-00 20 5E 38 20 04 01 20   1993 (D9. ^8 ..
1479:0130  31 39 39 34 20 28 F0 46-00 20 99 3B 20 30 01 20   1994 (.F. .; 0.
1479:0140  31 39 39 35 20 68 97 5A-00 20 88 45 20 4D 01 20   1995 h.Z. .E M.

chever19

[第34楼] [ 回复时间：2010-07-17 19:36 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-07-12 14:54

数字在内存中是以补码的形式存放的，所以我们看到年份后面的数字是乱码。是这个原因吗？？
有什么办法看到那些数字呢？？？！！！

infosecer

[第35楼] [ 回复时间：2010-07-17 21:27 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：2
注册日期：2010-07-16 14:24

回复：[第34楼]
－－－－－－－－－－－－－－－－－－
数字前面不是有吗，后面年份和乱码是以ASCII吗形式给出的。
31 39 39 35 20 68 97 5A-00 20 88 45 20 4D 01 20 1995 h.Z. .E M.
这些就是数据，对应的是'1','9','9','5',' ',5937000,' ',17800,' ',333,' '

13784632020

[第36楼] [ 回复时间：2010-07-18 22:33 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：2
注册日期：2010-07-02 05:46

结构简洁，思路清晰，学习了。

move9009

[第37楼] [ 回复时间：2010-07-31 21:40 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-07-27 16:00

菜鸟学习中……

int20

[第38楼] [ 回复时间：2010-08-06 06:24 ] [引用] [回复] [ top ]　

荣誉值：2
信誉值：0
注册日期：2010-07-25 14:15

很精彩

tony7day

[第39楼] [ 回复时间：2010-08-28 15:12 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-08-27 08:30

tony7day

[第40楼] [ 回复时间：2010-08-28 15:14 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-08-27 08:30

通过这贴至少明白了一点：使用栈处理数据是通过内存的，而使用寄存器的效率要比栈快的多。
这个原来倒是没有意识到。

gao693282043

[第41楼] [ 回复时间：2010-09-05 11:16 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-04-06 11:41

gao693282043

[第42楼] [ 回复时间：2010-09-05 11:20 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-04-06 11:41

15143222000

[第43楼] [ 回复时间：2010-09-23 19:30 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-09-19 19:28

assume cs:code

data segment
   db '1975','1976','1977','1978','1979','1980','1981','1982','1983'
   db '1984','1985','1986','1987','1988','1989','1990','1991','1992'
   db '1993','1994','1995'

   dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
   dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000

   dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226
   dw 11542,14430,15257,17800
data ends

table segment
    db 21 dup ('year summ ne ?? ')
table ends

code segment
    start:mov ax,data
          mov ds,ax

          mov ax,table
          mov ss,ax

          mov cx,15H
          mov bp,0H
          mov bx,0H
     WS1: push cx

          mov cx,4H
          mov si,0H
     NS1: mov al,ds:[bp+si]
          mov ss:[bx+si],al
          inc si
          loop NS1

          add bp,4
          add bx,10H
          pop cx
          loop WS1

          mov cx,15H
          mov bp,54H
          mov bx,0H
     WS2: mov ax,ds:[bp]
          mov ss:[bx+5],ax
          mov ax,ds:[bp+2]
          mov ss:[bx+7],ax

          mov byte ptr ss:[bx+4],0
          mov byte ptr ss:[bx+9],0
          mov byte ptr ss:[bx+12],0
          mov byte ptr ss:[bx+0fH],0

          add bp,4H
          add bx,10H
          loop WS2

          mov cx,15H
          mov bp,0a8H
          mov bx,0H
     WS3: mov ax,ds:[bp]
          mov ss:[bx+0aH],ax

          add bp,2H
          add bx,10H
          loop WS3

          mov cx,15H
          mov bp,0
     WS4: mov ax,[bp+5]
          mov dx,[bp+2+5]
          div word ptr [bp+10]
          mov [bp+0dH],ax

          add bp,10H
          loop WS4

          mov ax,4c00h
          int 21h
code ends

end start

michael47

[第44楼] [ 回复时间：2010-10-30 21:45 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-10-13 21:26

实验七是为了练习寻址方式的灵活使用，用mov指令做完了是对的，用栈的应该是个人爱好，是在用mov完成后，个人又写的，才对

cy512118091

[第45楼] [ 回复时间：2010-11-15 11:23 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-10-21 07:50

顶下

hdu_sgy

[第46楼] [ 回复时间：2010-11-15 18:32 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-11-11 23:17

在本题情况下，循环次数少，用栈方便，但是循环一多，栈就不合适了。
不过就本体而言，楼主贴出的代码确实不错，比我的短多了！！！

bijin

[第47楼] [ 回复时间：2010-11-27 08:57 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-11-20 08:50

获益良多啊，很好，有助于更好地理解数据结构

haojunyu

[第48楼] [ 回复时间：2010-11-30 19:26 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：2
注册日期：2010-11-16 21:58

纯mov流  呵呵
assume cs:codesg

datasg segment
DB        '1975', '1976', '1977'
DD        16, 22, 382
DW        3, 7, 9
datasg ends

table segment
db 3 dup ('year summ ne ?? ')
table ends

codesg segment
start:
              mov ax,datasg
        mov ds,ax

        mov ax,table
        mov es,ax

        mov bx,0      //table的偏移
        mov si,0      //data的偏移
        mov cx,3

lab:
        mov ax,[si]             //debug模式下不让使用eax所以只能用两次mov
        mov es:[bx],ax
        mov ax,[si+2]
        mov es:[bx+2],ax

        mov ax,[si+12]      //取收入
        mov es:[bx+5],ax
        mov ax,[si+14]
        mov es:[bx+7],ax

        mov ax,[si+24]       //取雇员数
        mov es:[bx+10],ax

        add si,4             //前面的年份和收入都是4个字节的
        add bx,10h           //跳到table下一行
        loop lab


codesg ends

end start

jonyjony

[第49楼] [ 回复时间：2010-12-01 01:27 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-11-15 23:58

不是一班的高手。学习了。谢谢。

bzyxtsg

[第50楼] [ 回复时间：2011-01-10 16:18 ] [引用] [回复] [ top ]　

荣誉值：14
信誉值：6
注册日期：2010-12-20 13:34

希望连同调试过程也带上那就perfect了

lshang

[第51楼] [ 回复时间：2011-01-19 00:47 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2011-01-19 00:37

栈机制是我老师一直推荐的东西.可是我还用不好
呵呵初始汇编,要学的东西还很多.要走的路还很长

open263

[第52楼] [ 回复时间：2011-02-10 14:21 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2010-12-30 21:41

48楼你写的什么啊!!!!!!!!!!!!!!!!!!!!!!!!!!

wlzaini1314

[第53楼] [ 回复时间：2011-04-16 21:20 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2011-01-15 22:31

栈你没白学用的真好

frogoscar

[第54楼] [ 回复时间：2011-06-16 20:43 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2011-05-16 07:53

just like 18 floor

cjlchenjilin

[第55楼] [ 回复时间：2011-06-21 10:49 ] [引用] [回复] [ top ]　

荣誉值：1
信誉值：0
注册日期：2011-05-30 14:33

呵呵，学习了!

vs9841

[第56楼] [ 回复时间：2011-07-31 17:09 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2009-01-17 12:29

没有觉得好在哪里，33楼，48楼的方法不错。比栈的效率高多了。同样都是一个环搞定。

liash

[第57楼] [ 回复时间：2011-08-03 10:17 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2011-07-29 21:21

回复：[第56楼]
－－－－－－－－－－－－－－－－－－
没发现48楼偷工减料了很多么
懂得用栈搞定就能用mov搞定

liash

[第58楼] [ 回复时间：2011-08-03 10:34 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2011-07-29 21:21

回复：[第44楼]
－－－－－－－－－－－－－－－－－－
用栈也是要寻地和 mov 一样

minidxer

[第59楼] [ 回复时间：2011-10-03 16:10 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2011-08-18 06:18

Mark

soulzfq

[第60楼] [ 回复时间：2011-11-09 16:54 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2011-11-07 13:02

用栈写的好简洁，我固步自封了，光用MOV了

chenmiao

[第61楼] [ 回复时间：2011-11-27 17:58 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2011-11-27 17:40

我写这个的时候报了“除法溢出”，怎么查都没查出来错误，希望各位高手多帮帮忙代码如下：
assume cs:codesg
datasg segment
        db '1975','1976','1977','1978','1979','1980','1981','1982','1983'
        db '1984','1985','1986','1987','1988','1989','1990','1991','1992'
        db '1993','1994','1995'
        ;以上是表示21年的21个字符串
        dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
        dd 345980,590827,803530,1183000,11843000,2759000,3753000,4649000,5937000
        ;以上是表示21年公司的21个dword型数据
        dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226
        dw 11542,14430,15257,17800
        ;以上表示21年公司雇员人数的21个word型数据
datasg ends
table segment
        db 21 dup ('year summ ne ?? ')
table ends
stack segment
        db 16 dup('0');
stack ends
codesg segment
start:
        mov ax,datasg
        mov ds,ax

        mov ax,table
        mov es,ax

        mov ax,stack
        mov ss,ax
        mov sp,16

        mov bx,0
        mov bp,0
        mov di,0
        mov cx,21
        push cx
  s:mov si,0
        mov cx,4
s0:mov al,[bp+si]
        mov es:[bx+si],al

        mov al,[bp+84+si]
        mov es:[bx+5+si],al
        inc si
        loop s0

        mov ax,[di+168]
        mov [bx+10],ax
        mov dx,es:[bx+5]
        mov ax,es:[bx+7]
        div word ptr [bx+10]
        mov [bx+14],ax

        add di,2h
        add bp,4h
        add bx,10h
        pop cx
        loop s

        mov ax,4c00h
        int 21h
codesg ends
end start

realbit

[第62楼] [ 回复时间：2011-12-01 20:23 ] [引用] [回复] [ top ]　

荣誉值：1
信誉值：4
注册日期：2011-11-28 20:29

我发现，是不是使用堆栈是为了解决寄存器不足的问题？而使用内存又需指出地址，而堆栈更容易使用

tomato

[第63楼] [ 回复时间：2011-12-01 21:25 ] [引用] [回复] [ top ]　

荣誉值：405
信誉值：0
注册日期：2008-01-19 14:51

不仅可以解决寄存器不足的问题，而且，使用起来很方便，不需要想着存放在什么地方了，只需要入栈出栈就可以了。

realbit

[第64楼] [ 回复时间：2011-12-02 14:12 ] [引用] [回复] [ top ]　

荣誉值：1
信誉值：4
注册日期：2011-11-28 20:29

我发现，是不是使用堆栈是为了解决寄存器不足的问题？而使用内存又需指出地址，而堆栈更容易使用
－－－－－－－－－－－－－－－－－－
回复：但是堆栈效率应该很低

q382267644

[第65楼] [ 回复时间：2011-12-02 22:30 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2011-12-02 22:19

求高手一句句详解。。加QQ382267644

447861996

[第66楼] [ 回复时间：2011-12-15 10:08 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2011-04-28 20:08

想法确实不错，不过好像1989往后数据，计算有误，请楼主确定一下。

zhujinwu

[第67楼] [ 回复时间：2011-12-15 15:19 ] [引用] [回复] [ top ]　

荣誉值：15
信誉值：0
注册日期：2011-11-03 09:29

这个实验中给出的数据是不会产生除法溢出错误的，你的出现了这个错误，应该是计算人均收入时的被除数（总收入）和除数（雇员人数）不对应，即在位置的指向上，二者不同步了，你可以朝这个方面检查一下。

447861996

[第68楼] [ 回复时间：2011-12-15 23:01 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2011-04-28 20:08

同意67楼的说法不过除法溢出好像是在下一章学到的

justpanxu

[第69楼] [ 回复时间：2011-12-24 11:24 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2011-12-14 16:00

不错

javaimgod

[第70楼] [ 回复时间：2012-01-24 18:42 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2012-01-10 21:29

我的代码：请高手指教
assume cs:code

data segment

db '1975','1976','1977','1978','1979','1980','1981','1982'
db '1983','1984','1985','1986','1987','1988','1989','1990'
db '1991','1992','1993','1994','1995'
dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000
dd 5937000
dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635
dw 8226,11542,14430,15257,17800

data ends

table segment

db 21 dup ('year summ ne ?? ')

table ends

stack segment

db 16 dup (0)

stack ends

code segment

start: mov ax,data
     mov ds,ax    ;定义数据段地址

     mov ax,table
     mov es,ax    ;定义表格段地址

     mov ax,stack
     mov ss,ax
     mov sp,16

     mov bx,0
     MOV di,0
     mov cx,21



s:   push cx
     mov si,0

     mov cx,2
s0:  mov dx,ds:[di]
     mov es:[bx+si],dx  ;年份输入

     mov dx,ds:[di+84]
     mov es:[bx+si+5],dx ;收人输入

     add di,2
     add si,2

     loop s0


     add bx,16
     pop cx

loop s

     mov bx,0
     mov di,0
     mov si,0
     mov cx,21
s1:  mov dx,ds:[di+168]
     mov es:[bx+10],dx     ;  人数输入

     mov ax,ds:[si+84]
     mov dx,ds:[si+86]
     div word ptr es:[bx+10] ;  平均收入计算
     mov es:[bx+13],ax       ;  平均收入输入
     add si,4
     add bx,16
     add di,2

loop s1

     mov  ax,4c00h
     int 21h
code ends
end start

javaimgod

[第71楼] [ 回复时间：2012-01-24 21:07 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2012-01-10 21:29

看来还是单循环的好。我的太啰嗦了，思路没转过来。现在看了几个帖子明白了

programmingring

[第72楼] [ 回复时间：2012-02-09 17:19 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2012-02-08 18:30

这个和mov到寄存器差不多嘛，不过这个解决寄存器少的问题

wjb0001

[第73楼] [ 回复时间：2012-02-23 20:40 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2011-07-20 08:57

看到有个人贴出的代码，跟楼主形式有点类似，我弄的太长，郁闷
assume cs:codesg
data segment
   db '1975','1976','1977','1978','1979','1980','1981','1982','1983'
   db '1984','1985','1986','1987','1988','1989','1990','1991','1992'
   db '1993','1994','1995'
   dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
   dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000
   dd 5937000
   dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226
   dw 11542,14430,15257,17800
data ends
table segment
   db 21 dup ('year summ ne ?? ')
table ends
codesg segment
start: mov ax,data
       mov ds,ax
       mov bx,0
       mov si,0
       mov ax,table
       mov es,ax
       mov di,0
       mov cx,21
    s: mov ax,[bx]
       mov es:[si],ax
       mov ax,[bx+2]
       mov es:[si+2],ax

       mov ax,[bx+84]
       mov es:[si+5],ax
       mov ax,[bx+86]
       mov es:[si+7],ax

       mov ax,[di+168]
       mov es:[si+10],ax
       mov ax,es:[si+5]   ; 这里你都没用加es：
       mov dx,es:[si+7]   ;这里你都没用加es：
       div word ptr es:[si+10]   ;这里你都没用加es：
       mov es:[si+13],ax

       add bx,4
       add di,2
       add si,10h
       loop s

       mov ax,4c00H
       int 21H
codesg ends
end start

tiandaochouqin

[第74楼] [ 回复时间：2012-03-12 11:24 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2012-03-12 11:03

这些人很是牛b啊，我菜鸟学习学习，看不懂，真心

powlin1991

[第75楼] [ 回复时间：2012-03-23 10:43 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：5
注册日期：2012-03-22 15:34

一直有个问题想请教啊，因为数据是有42个字，但是为什么栈的sp都只设置成16呢？

如果入栈不马上出栈，显然16是不够用的。

chinatopman

[第76楼] [ 回复时间：2012-03-25 13:59 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2012-03-21 13:33

请大侠、牛人们指点一下什么时候会想到用栈来代替MOV啊？

powlin1991

[第77楼] [ 回复时间：2012-03-27 22:33 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：5
注册日期：2012-03-22 15:34

回复：[第76楼]
－－－－－－－－－－－－－－－－－－
我认为并不是用栈代替mov，而是两者都可以用，只是擅长于哪种方法的问题吧。

xxyasm2012

[第78楼] [ 回复时间：2012-05-19 12:34 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2012-05-11 14:41

年份是字符的,能显示,数字的不显示.你只要仔细看一下内存中的数据,就知道你的结果是不是正确了..

sz_hgc

[第79楼] [ 回复时间：2012-08-28 01:03 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2012-07-21 21:21

弄了几个小时用了四个循环感觉收获还是不少的

;实验7

assume cs:codesg,ds:datasg,ss:stacksg

datasg segment

        db '1975','1976','1977','1978','1979','1980','1981','1982','1983'
        db '1984','1985','1986','1987','1988','1989','1990','1991','1992'
        db '1993','1994','1995'
        ;以上是表示21年的21个字符串

        dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
        dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000
        ;以上表示21年公司总收入的21个word型数据

        dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226
        dw 11542,14430,15257,17800
        ;以上是表示21年公司雇员人数的21个word型数据

datasg ends

table segment

        db 21 dup('year summ ne ?? ')

table ends

stacksg segment

        db 16 dup(0)

stacksg ends

codesg segment

start:        mov ax,datasg
                mov ds,ax
                mov ax,table
                mov es,ax
                mov ax,stacksg
                mov ss,ax
                mov sp,10h

                mov bx,0
                mov si,0
                mov di,0
                mov cx,21
s0:                mov ax,ds:[bx+si+0]
                mov es:[bx+di+0],ax
                add bx,2
                mov dx,ds:[bx+si+0]
                mov es:[bx+di+0],dx
                add si,2
                add di,0eh
                loop s0

                mov bx,0
                mov si,0
                mov di,0
                mov cx,21
s1:                mov ax,ds:[bx+si+54h]
                mov es:[bx+di+5],ax
                add bx,2
                mov dx,ds:[bx+si+54h]
                mov es:[bx+di+5],dx
                add si,2
                add di,0eh
                loop s1

                mov si,0
                mov di,0
                mov cx,21
s2:                mov ax,ds:[si+0a8h]
                mov es:[di+0ah],ax
                add si,2
                add di,10h
                loop s2

                mov di,0
                mov cx,21
s3:                mov ax,es:[di+5]
                mov dx,es:[di+7]
                div word ptr es:[di+0ah]
                mov es:[di+0dh],ax
                add di,10h
                loop s3

codesg ends

end start

sz_hgc

[第80楼] [ 回复时间：2012-08-29 14:07 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2012-07-21 21:21

重写实验7

;实验7

assume cs:codesg,ds:datasg

datasg segment

        db '1975','1976','1977','1978','1979','1980','1981','1982','1983'
        db '1984','1985','1986','1987','1988','1989','1990','1991','1992'
        db '1993','1994','1995'
        ;以上是表示21年的21个字符串

        dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
        dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000
        ;以上表示21年公司总收入的21个word型数据

        dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226
        dw 11542,14430,15257,17800
        ;以上是表示21年公司雇员人数的21个word型数据

datasg ends

table segment

        db 21 dup('year summ ne ?? ')

table ends

codesg segment

start:        mov ax,datasg
                mov ds,ax
                mov ax,table
                mov es,ax

                mov si,0
                mov di,0
                mov bx,0

                mov cx,21

s0:                mov ax,ds:[si]                               ;写入年份
                mov es:[di],ax
                mov dx,ds:[si+2]
                mov es:[di+2],dx

                mov ax,ds:[si+54h]                           ;写入年收入
                mov es:[di+5],ax
                mov dx,ds:[si+56h]
                mov es:[di+7],dx

                mov ax,ds:[bx+0a8h]                           ;写入雇员人数
                mov es:[di+0ah],ax
                mov ax,es:[di+5]
                mov dx,es:[di+7]

                div word ptr es:[di+0ah]                ;计算平均收入
                mov es:[di+0dh],ax

                add si,4
                add di,10h
                add bx,2
                loop s0

                mov ax,4c00h
                int 21h

codesg ends

end start

sz_hgc

[第81楼] [ 回复时间：2012-08-29 14:14 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2012-07-21 21:21

不好意思，上面那个发错了

;实验7

assume cs:codesg,ds:datasg

datasg segment

        db '1975','1976','1977','1978','1979','1980','1981','1982','1983'
        db '1984','1985','1986','1987','1988','1989','1990','1991','1992'
        db '1993','1994','1995'
        ;以上是表示21年的21个字符串

        dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
        dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000
        ;以上表示21年公司总收入的21个word型数据

        dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226
        dw 11542,14430,15257,17800
        ;以上是表示21年公司雇员人数的21个word型数据

datasg ends

table segment

        db 21 dup('year summ ne ?? ')

table ends

codesg segment

start:        mov ax,datasg
                mov ds,ax
                mov ax,table
                mov es,ax

                mov si,0
                mov di,0
                mov bx,0

                mov cx,21

s0:                mov ax,ds:[si]                               ;写入年份
                mov es:[di],ax
                mov dx,ds:[si+2]
                mov es:[di+2],dx

                mov ax,ds:[si+54h]                           ;写入年收入
                mov es:[di+5],ax
                mov dx,ds:[si+56h]
                mov es:[di+7],dx

                mov ax,ds:[bx+0a8h]                           ;写入雇员人数
                mov es:[di+0ah],ax

                div word ptr es:[di+0ah]                ;计算平均收入
                mov es:[di+0dh],ax

                add si,4
                add di,10h
                add bx,2
                loop s0

                mov ax,4c00h
                int 21h

codesg ends

end start

red_myth

[第82楼] [ 回复时间：2012-11-08 18:59 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2011-03-07 11:17

自己搞了1天才出来，差距大啊！

dela2000

[第83楼] [ 回复时间：2012-11-17 13:17 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2012-06-19 00:22

我花了好长时间整出来了，调试OK,欢迎拍砖:
ssume cs:codesg, ds:datasg,ss:stacksg,es:table

datasg segment

db '1975','1976','1977','1978','1979','1980','1981','1982','1983'
db '1984','1985','1986','1987','1988','1989','1990','1991','1992'
db '1993','1994','1995','0000','0000','0000'

dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000
dd 0000,0000,0000

dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226
dw 11542,14430,15257,17800,00,00,00

datasg ends

stacksg segment

   dw  0,0,0,0,0,0,0,0

stacksg ends

table segment

   db 21 dup('year summ ne ?? ')

table ends

codesg segment

       start:mov ax,datasg
             mov ds,ax
             mov ax,table
             mov es,ax

             mov bx,0
             mov bp,0
             mov ax,stacksg
             mov ss,ax
             mov sp,16
             mov cx,21

         s0: push cx
             mov si,0
             mov cx,4

         s:  mov al,ds:[bp+si]
             mov es:[bx+si],al
             inc si
             loop s

             mov ax,ds:[0c0h+di]
             mov es:[bx+0ah],ax

             mov ax,ds:[60h+bp+0]
             mov dx,ds:[60h++bp+2]

             mov es:[bx+5],ax
             mov es:[bx+7],dx
             div word ptr es:[bx+0ah]
             mov es:[bx+0dh],ax
             sub dx,dx


             add bp,4
             add bx,16
             add di,2
             pop cx
             loop s0

             mov ax,4c00h
             int 21h

codesg ends

end start

sbjcm33

[第84楼] [ 回复时间：2012-11-22 23:23 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2012-11-13 22:06

没见到楼主有输入空格的语句，为什么结果中确有空格（20h)?

huibian2014

[第85楼] [ 回复时间：2013-03-10 12:00 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2013-03-10 11:42

学习中》》》》》》》》》》

lonelyhover

[第86楼] [ 回复时间：2013-04-17 17:16 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2009-07-18 20:29

呵呵，我是将整个table作为栈段，将数据按顺序压栈，来完成的。

lpy

[第87楼] [ 回复时间：2013-10-20 17:39 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2013-09-03 01:15

jjdjjdbcjd

[第88楼] [ 回复时间：2016-05-12 20:02 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2016-05-12 20:00

谁能教教咱怎么查看运行结果啊，求大神

qiangge

[第89楼] [ 回复时间：2018-07-16 16:21 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2018-07-16 16:20

为啥复制雇员数的地址是OA8H

cdylss

[第90楼] [ 回复时间：2018-10-25 08:21 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2018-10-19 10:17

我用了3个循环，哎，差距太大了，看来我的继续努力

cdylss

[第91楼] [ 回复时间：2018-10-25 08:21 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2018-10-19 10:17

我用了3个循环，哎，差距太大了，看来我的继续努力

trxnb

[第92楼] [ 回复时间：2022-10-20 13:19 ] [引用] [回复] [ top ]　

荣誉值：0
信誉值：0
注册日期：2022-10-09 11:54

assume cs:codesg

data segment
       ;表示21年的字符串 4字节*21个=84字节
       db '1975','1976','1977','1978'
       db '1979','1980','1981','1982'
       db '1983','1984','1985','1986'
       db '1987','1988','1989','1990'
       db '1991','1992','1993','1991'
       db '1995'

       ；表示21年公司总收入  开始为bx+84 4字节*21个=84字节
       dd 16,22,382,1356,2390,8000,16000,24486,50065,97479,140417,197514
       dd 345980,590827,803530,1183000,1843000,2759000,3753000,4649000,5937000

       ;表示21年员工总数  开始为bx+168
       dw 3,7,9,13,28,38,130,220,476,778,1001,1442,2258,2793,4037,5635,8226
       dw 11542,14430,15257,17800
data ends

table segment
       db 21 dup ('year summ ne ?? ')
table ends

code segment
start: mov ax,data
       mov ds,ax

       mov ax,table
       mov es,ax

       mov bx,0
       mov si,0
       mov di,0
       mov cx,21

s:     mov ax,[bx]
       mov es:[si],ax
       mov ax,[bx+2]
       mov es:[si+2],ax

       mov ax,[bx+84]
       mov es:[si].5h,ax
       mov ax,[bx+84+2]
       mov es:[si].7h,ax

       mov ax,[di+168]
       mov es:[si].0ah,ax

       mov ax,[bx+84]
       mov dx,[bx+84+2]
       div word ptr [di+168]
       mov es:[si].0dh,ax

       add bx,4
       add di,2
       add si,16
       loop s

       mov ax,4c00h
       int 21h

code ends
end start

需要登录后才能回帖　－－＞＞请单击此处登录


	Copyright © 2006-2024 ASMEDU.NET All Rights Reserved