|
本文成篇的起因于社长的一条记录 链接/ u: U6 B$ U' l
# ^; ^* s5 q. c1 u5 t4 n! |
递归是计算机科学中一种解决问题的重要方法。所谓递归,通俗地说就是自己调用自己,它在很多语言和环境下都可以实现。以社长的工作场景为例,根据爱坛上的信息,大概是两个关键词:Unix和汇编。本人条件有限,只能用Linux模拟,汇编也只限于x86汇编。下面就是用汇编语言编写的,用递归方法计算阶乘的示范程序。2 z$ ~5 a7 Y3 Y1 }/ Y
- LEN_OF_OUTPUT equ 101 F @( z' E8 G
0 E1 s5 N% e% c6 l! c, a- section .data ;9 W5 t* ]- N4 j. k2 Q
- userMsg db 'Please enter a single-digit number: ' ;
8 v6 i+ o' T6 M - lenUserMsg equ $-userMsg ;
1 H0 L2 } F4 J) ~ - disp1Msg db 'The factorial of '2 A/ a& \5 i6 g/ q6 C
- lenDisp1Msg equ $-disp1Msg 0 \0 d$ `# S9 d) {) t% g
- disp2Msg db ' is '( _4 \# v7 X& I1 k' |5 s
- lenDisp2Msg equ $-disp2Msg ) v7 t3 W7 Y( X6 k
- errMsg db 'Wrong input. Only one-digit number can be accepted.',0x0a
7 u4 ~: a5 q5 M; [( r% J - lenErrMsg equ $-errMsg
; _" f+ V y& m. j- j1 }. O1 X$ R( L - & A4 x+ P L3 ?/ h1 J) W) C
- section .bss ;
- Q) Y. B: f+ V: p+ }, _ - num resb 1
" i9 t2 t4 m+ r# i @- m - result resd 12 |+ L3 d+ x4 w+ ~3 ~
- buffer resb LEN_OF_OUTPUT+11 ^9 e" P5 F" g! {2 ^
-
0 ~! G, c& g5 d - section .text ;
/ }2 p" D% \5 i6 b - global _start
1 V6 P x# J3 T2 J9 F5 ^ - 0 O3 o* ^/ z ~+ f( X8 |' i) e
- _start: ;$ b% J8 i* }* Q8 ]% t" V" `7 K
- mov eax, 4
3 K+ w* j. e5 l; \3 S# h4 T0 o# u6 M - mov ebx, 1, u9 X1 L, L% T' l- z: t' h
- mov ecx, userMsg7 O5 h0 Y- ~- ?- v: e
- mov edx, lenUserMsg6 z: L9 V$ O8 x3 c; N4 Q. m _
- int 80h1 h* h. X" G% g* j- B5 ]+ `, `8 r* ~
5 T9 O, X7 e; R, H' l0 c2 U2 {- ; read user's input: V. D h7 @8 w+ t* l" U% d
- mov eax, 3
4 S u4 m1 n L. \0 H7 V - mov ebx, 04 j2 e" u! w1 l7 L0 R6 F, i0 f O: u
- mov ecx, num " M7 `6 L4 C. I \, D' y
- mov edx, 1 ; length of input buffer+ u% W3 }- O7 B( |
- int 80h
. a: z: m9 N1 _# }6 R% z - . q; K; k% X- y2 H& T( f
- mov eax, [num]
. Y( K; X. [0 C6 l @ - and eax, 0xFF+ F2 X) X. v( y1 m) w; ~
- sub eax, 0x30
( ]8 q. h! P5 f; h - jl ERROR
* D5 Y7 |$ M; T) J% B - cmp eax, 10+ C. K$ i, t' G! G& p$ R9 u, h4 s3 t
- jl DO_CALC
7 y5 U n3 n" E' S$ m - ERROR:$ i% i; \# ^. C1 } J
- mov eax, 4
/ `. G9 }7 y4 W2 y( f - mov ebx, 1' [# p$ [2 ~+ ~
- mov ecx, errMsg
3 w! {% k1 f* ]! k, I - mov edx, lenErrMsg
* {* H }; C9 z k8 a$ z - int 80h 9 r6 y3 ?5 P! S& j, O- O1 j p* [
- jmp EXIT9 @- e, E3 i: b$ _
, _: R6 e4 v. h, p q% x- ! U8 z/ m1 Q, N/ g# l
- DO_CALC:
) Q5 ?4 w2 |# A t* _- N1 X - call factorial
# [2 j' Q, q- |) Z7 u; r0 j - ; The parameter is in eax. After calling, the result will be stored in eax.
/ u {6 e6 M! f; t - mov [result], eax ; Save the result
+ j7 ?) ]1 @* X! w# T- o, @
# ^+ F1 `7 S. e; G' S- ; print result
" j$ `: Y& U! f4 k6 f2 U& R - mov eax, 4
4 ^. N2 G+ _* e' }1 ^% j0 h5 g0 ` - mov ebx, 1( d2 X0 x& e3 J, ]) Y
- mov ecx, disp1Msg/ c X% V @5 z; J( z
- mov edx, lenDisp1Msg" V2 ^5 o. }# @/ m, x
- int 80h
3 Z8 ]' `" c1 i4 v9 M - mov eax, 4' v2 ?" i. v) X+ w
- mov ebx, 1
$ P! W7 R) ^, l - mov ecx, num
4 ?2 G B; y1 p+ }9 W8 V - mov edx, 1
; E# f) ^( s) | - int 80h & R @5 o- z" U4 ~( t6 ?
- mov eax, 40 J& b% y$ d& u, l( g; B( y
- mov ebx, 1
3 Y* k' l. k7 @% G5 O# d' Q! A - mov ecx, disp2Msg: X8 M4 H3 M' B" N: ^
- mov edx, lenDisp2Msg1 @; j! Z9 \7 k
- int 80h
" |; K4 p$ g1 x1 p+ C) K4 F - , e4 l4 }5 n2 r2 x" w
- ; output number' b& ^! M4 I1 f- ^! X/ P7 e% v
- mov eax, [result] ; VALUE THAT I WANT TO CONVERT AND DISPLAY
' Y0 ^9 u' p" k7 v/ W$ R) ^ - mov byte [buffer+LEN_OF_OUTPUT],0x0a: u, Q3 ~) W9 g% V1 T( m( e
- lea esi,[buffer+LEN_OF_OUTPUT]$ g- Q+ W9 ?( z- }% B* _+ r3 M
- mov ebx,10
# E) E6 J& M+ [2 g E( l* _6 f - ASC_LOOP:; I$ }% x. t; k
- mov edx,0 ; clear dx prior to dividing edx:eax by bx
, R j( s6 C' @* Q. Y, G3 B# N - div ebx ;DIV EAX/10
1 a5 ^. g( ?8 n8 J, N: h, E4 g5 } - add edx,0x30 ;ADD 48 TO REMAINDER TO GET ASCII CHARACTER OF NUMBER
+ ]. H' w- [5 E, J. Q - dec esi ; store characters in reverse order
" D/ b* }. B! T4 I - mov [esi],dl
' x9 A0 W2 A0 [) k - cmp eax,0
$ n" C( F" _' N D) t& F, I - jz END_ASC ;IF AX=0, END THE PROCEDURE OF NUMBER TO ASCII
1 V- E0 j; b2 K2 [! {8 Y% k" u - jmp ASC_LOOP ;ELSE REPEAT& ?' ~3 N) ^" _4 T
- END_ASC:
/ X% F3 L7 Z4 B* W' o; Y - mov eax, 4
: @! E/ I v6 ]8 X - mov ebx, 1
4 V0 S- M( A2 P, J% R% R - mov ecx, esi( M9 t0 b; `) R. i
- lea edx,[buffer+LEN_OF_OUTPUT+1]
/ d3 V0 E: \" N2 i% b# J$ Z2 s - sub edx, ecx
+ Y) p/ z3 Y( J5 { - int 80h 4 R! j" m7 t! N4 m9 F8 C
-
7 p7 |" b( ?# C; f4 _( a5 R - ; Exit code
; r' q7 G: Y' ?- S: H - EXIT:: R( M9 ^$ u9 X8 p. }( k; @& T0 d
- mov eax, 1
4 F- ] s% }- @ J4 }2 g; m - mov ebx, 0
S' f4 ?5 m, o8 x - int 80h
6 ]5 D9 W5 a K( b6 g7 R& ^ - , ^9 U% `8 n7 P9 w
. C+ u7 p6 j# ?7 J
% C6 _% G; f9 D1 `9 ^- ; Factorial function using recursion
/ D# U; ?% k( \9 X2 Y- f8 A/ s5 a - factorial:4 h4 }+ V. Z F; t' J7 B. h
- ; Check if eax is 0 (base condition)
- O9 t! k- G! f5 ]4 n* w; U - cmp eax, 0
5 h$ C- ^ A/ t: K - jz end_recursion) B! D7 O# w" M6 G C% O1 ^
- , A! r0 v& F ~/ E+ ~( n9 \
- ; Save the current value of eax5 p S2 K' ^2 Q+ X n+ N. x
- push eax
0 I* C( |, X4 N& F - , g+ Q6 i$ V- \7 a/ `' d0 w8 U* ^
- ; Decrement eax and call factorial function recursively
( A4 G( u6 _& N* ] - dec eax
! S1 j9 z+ h1 r - call factorial- P3 E3 f/ Y8 g8 b$ g
# o# k" Q8 ]0 m" l& H; _+ [- ; Multiply the result returned in eax with the saved value of eax
. w |- Q# Y, y, _$ {5 t - pop ebx
. P" k# d9 g/ Y4 |8 n7 p/ F- M - imul eax, ebx
; R+ P- P- ?" L/ g( z$ v - # X' v+ k; d& e0 N
- ret
/ F4 J s% S* } - 5 U# L, M: }! [+ c/ d" x
- end_recursion:9 r! M' A4 u: a4 H5 b8 K1 M
- ; Return 1 when eax is 0 (base condition)% s. B* u& k4 @
- mov eax, 1
* [! h, H; l5 @ \ - ret
复制代码
% @; g: I* y) V6 b$ V% v) b" h9 m程序在nasm编译器下通过并成功运行。相应的命令行如下,有兴趣的童鞋可以自行验证。
! Y9 E% Z/ s4 n3 M! j) `0 l8 {- nasm -f elf factorial.asm
$ z3 q& I) p; i7 p: q: w" w6 W - ld -m elf_i386 -s -o factorial factorial.o
- B% Z6 U# D, q" [ - ./factorial( P j' M& d; n- E1 p0 e
复制代码 8 C/ S2 @% D) O: A
由于汇编不擅长处理I/O,所以程序限制输入仅限于一位数字(0-9),以免过于喧宾夺主。其实程序中真正紧扣主题的就最后一小段:
2 X5 t. t: e9 J9 y5 g4 V. q G- ; Factorial function using recursion
: C/ f& j6 D( y- N V - factorial:
4 x- S' \) Y, }1 h3 G5 c& M# q - ; Check if eax is 0 (base condition)& G7 ^6 S" g; ?/ i
- cmp eax, 0
+ R& q- \. x8 I4 |, S - jz end_recursion
- @7 {( M J* T2 e6 K+ e2 T: E6 y' i& ^0 L - 9 k1 J9 e9 w* Z- Y! W! j
- ; Save the current value of eax
/ R: M2 @/ L, v4 J/ O, w - push eax
% v* u/ \6 V9 X, `7 _
7 b B8 [* ~5 f. ?, T$ v' u- ; Decrement eax and call factorial function recursively
# K! l& H2 X0 [/ W9 R( K - dec eax
- F: Q, A1 u7 w! p - call factorial
$ A8 A( ? e* @6 {
$ @' v3 h% c) {2 I1 I9 ^- ; Multiply the result returned in eax with the saved value of eax8 h, y8 ]" o) d: h- D' q
- pop ebx- R9 L5 s9 `8 g0 j3 L# }( T
- imul eax, ebx
0 u+ D" e3 o( n" i& J5 j! w - ) {1 ~2 X5 ~5 f$ V/ b' U3 c
- ret
6 r0 ?* ^ e& x& V - 7 K* b4 S6 T: Y% B
- end_recursion:
1 E* G y0 r* M' I, K - ; Return 1 when eax is 0 (base condition)( i. q) Y* d5 ^* v& ^3 H
- mov eax, 1
9 [. B+ C% t3 v - ret
复制代码 可以清晰看出函数在其函数体中调用了它本身。
! [) x0 X. {) L3 I# f: o. p0 h) [3 X; m. I a1 ?) \0 r
以上证明了汇编语言不是实现递归的障碍。推而广之,所有中低级语言都可以轻松实现递归。某些高级语言反而不能做递归是人为强制规定的,换而言之是原作者权衡利弊的结果。# i7 X5 S' u _8 I( k2 l2 |
% E3 q0 H" u7 `3 E
世界上没有免费的午餐,递归在编写程序的时候简洁优雅,但运行过程中要付出极大的代价,甚至有可能是灾难。由于是函数反复调用自己,那么所有的中间结果都要暂时保留在栈(stack)上,直到最后一层函数调用完毕才能逐步清除。这既低效,又不安全。栈式计算是一个古老的概念,它与现代的多寄存器和流水线等都格格不入,难以优化提速。递归对栈空间的占用更可怕,占用量与调用函数次数线性相关(套用复杂度的概念就是O(n)),递归次数多了之后,很容易超出栈容量,从而导致栈溢出。具体到社长的工作中可能还有很多实时任务,一大堆高优先级的中断响应程序可不会等着递归函数运行完了再启动,这会让栈空间雪上加霜。想一想某个核电控制程序突然栈溢出了,那场面,哈哈哈。0 Y3 K) p; z$ f7 @: k4 [
; ]. y6 I0 t% B. A这可以解释,为什么条件上有可能,但社长很长时间里都没有接触到递归编程。无论用C还是用汇编,都强调的是速度与可靠性。社长实战出发,不需要知道回字的4种写法。至于Python,整个编程思想都变了,Python假定计算机的计算速度远远超过了需求,编程者无需为性能而操心。 Python语言的设计初衷,也不是为关键任务而生,而是想让更多的门外汉用起计算机来。所以在Python程序中容易见到递归。* N4 S/ d, Y4 L4 P7 I! {" ?
4 i# x7 {$ p9 H# ~( ?+ D. {有很多时候,递归用作概念性算法表达。真到了用代码实现的时候,再换用其它方法。比如说将递归转化成迭代(iteration)。
# x; t$ J. ~+ f0 D
C- q7 o4 P4 i: _, }9 ^( @另外,汇编语言作为一种低级编程语言,在不考虑时间成本的前提下,没有什么是它做不了的。本期课后作业:如何用汇编语言实现继承(Inheritance)和多态(Polymorphism)?请写出示范程序。我们知道继承和多态是面向对象编程(Object-oriented programming)的两个基本点,有了它们就可以实现汇编语言的面向对象编程。( T8 ?) k$ J( `5 w5 J; N
- E. X& n% _: [- D: _ |
评分
-
查看全部评分
|