Recursivite en asm

Soyez le premier à donner votre avis sur cette source.

Snippet vu 9 154 fois - Téléchargée 29 fois

Contenu du snippet

ce programme illustre la recursivite en assembleur
on utilise comme example la fonction de "FIBONACCI" et la "FACTORIEL"

Source / Exemple :


DONNE SEGMENT 

MESSAGE   DB 10,13,"*********CE PROGRAMME CALCULE LE SUIT DE FIBONACCI EN ASSEMBLEUR*******",10,13,'$'
UN_NUMERO DB 10,13,"	ENTRER LE RANG :  ",'$'
RESULTAT  DB 10,13,"			VIOCI LE RESULTAT ",'$'
MSGFACTO  DB 10,13,"      ET POUR LE FACTORIELLE LE RESULTATA EST : ",'$' 
MSGERREUR DB 10,13,"ENTRER UN NOMBRE SVP",'$'
DONNE ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DONNE
debut:
MOV AX,DONNE
MOV DS,AX

LEA DX,MESSAGE
MOV AH,09H
INT 21H
LEA DX,UN_NUMERO
INT 21H
MOV BX,0
MOV CX,10
 ;LECTURE ET CONVERTION DES DU NOMBRE LU DANS LE REGISTRE BX
LECT:
  MOV AH,01H ;on lit un caractaire
  INT 21H
  CBW
  CMP AL,13  ; si c'est ENTRER on va la suit du programme
  JE  SUIT    
  CMP AL,30H ;SINON ON VERIFIE SI C'EST UN CHIFFRE
  JL  ERREUR
  CMP AL,39H
  JA  ERREUR
  SUB AL,30H ;si oui on lui soustrait 30H
  XCHG AX,BX
  MUL  CX    ;on multiplie le resultat deja obtenu par 10
  JC   SUIT
  ADD  AX,BX ;ON L'ADDITIONNE AVEC LE NOMBRE LU
  XCHG AX,BX ; on met le resultat dans bx
  JMP  LECT
SUIT:
   MOV  CX,BX ;ON MET DANS CX LE RAG
   PUSH CX
   CALL FIBO
   MOV  DX,OFFSET RESULTAT
   MOV  AH,09H
   INT  21H
   CALL AFFICHE
   POP CX
   CALL FACTO
   MOV  BX,AX
   LEA  DX,MSGFACTO
   MOV  AH,09H
   INT  21H
   CALL AFFICHE
   JMP  FIN
ERREUR:
   LEA DX,MSGERREUR
   MOV AH,09H
   INT 21H
FIN:
  MOV AH,01H
  INT 21H
  MOV AH,4CH
  INT 21H
;*************************************************
;   LA PROCEDURE NON RECURSIVE DE FIBONACCI
;*************************************************
FIBO:
  XOR AX,AX
  JCXZ RETOURE
  MOV BX,AX
  INC AX
  CMP CX,1
  JBE RETOURE
TANQUE:
  PUSH AX
  ADD  AX,BX
  POP  BX
  LOOP TANQUE
RETOURE:
  RET
;***************************************************
;   LA PROCEDURE D'AFFICHAGE DU RESULTAT
;***************************************************
AFFICHE:
  mov cl,10
  MOV AX,BX
  MOV SI,0
  MOV DX,0
convert:
   INC SI
   div CX
   cmp AX,0
   je BOUCLE
   ADD DL,30H
   PUSH DX
   CWD
   JMP  CONVERT
BOUCLE:
   ADD  DX,30H
   PUSH DX
BCL:
   POP DX
   MOV AH,02H
   INT 21H
   DEC SI
   CMP SI,0
   JNE BCL
   ret
;*******************************************************************
;******************************************************************
;**** LA FONCTION FACTORIELLE RECURSIF                         ****
;******************************************************************
FACTO:
  XOR AX,AX
  INC AX
FACTORIELLE:
  JCXZ RET_PROG
  MUL  CX
  DEC  CX
  CALL FACTORIELLE   ;ICI LE CALL EST SEULLEMENT FAIR ILLUSION A LA RECURSIVITE
                     ; LE RESULTAT RESTERA LE MEME AVEC UN JMP MAIS TRES EFFICASSE
RET_PROG:
  ret

;****  FIN DE LA PROCEDURE    ******
CODE ENDS
END debut

A voir également

Ajouter un commentaire

Commentaires

Messages postés
21042
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
20
La récursivité implique:
- 1 ou plusieurs PUSH (EIP au minimum).
- 1 JMP.
- 1 ou plusieurs POP.
- 1 JMP de retour.
On peut donc poser comme principe général que l'itération sera quasi toujours plus performante que la récursivité.
Messages postés
6535
Date d'inscription
lundi 16 décembre 2002
Statut
Modérateur
Dernière intervention
22 août 2010
7
Fibonacci est pourtant l'exemple type de fonction qu'on ne fait pas récursivement. Ici le débordement arrivera très vite
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
2
La récursivité génère un système de boucles imbriquées. Il est souvent plus économique d'utiliser une boucle, comme par exemple
mov cx,n
mov ax,1
fact mul ax,cx ;effectue fact(n)=n.fact(n-1)
loop fact ;si cx>0 on continue sinon fini
;ax contient le résultat
Messages postés
1466
Date d'inscription
vendredi 2 janvier 2004
Statut
Modérateur
Dernière intervention
14 février 2014
1
salut,

j'aime pas trop la recursivité par call car il y a des risques de debordement de pile ( surtout en 16 bits ) ce qui oblige a calculer le nombre max de recursivité par rapport à la taille de la pile.

@++
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
2
Merci pour la source (plus il y en aura sur le site et plus on pourra progresser). Cependant je trouve dommage que pour un tutoriel la partie récursivité soit un peu noyée dans le reste. C'est peut-être le prix à payer pour avoir un programme complet qui fonctionne et qui affiche des résultats.

Pour ma part je pense qu'il serait préférable (pour une question de clarté)de scinder les différents éléments du programme en plusieurs tutoriels du genre :
-comment saisir des données au clavier
-comment afficher un message
-comment convertir une chaine de caractère en nombres
-comment convertir un nombre en chaine ascii
-comment appeler un sous programme
-la gestion de la pile
-le passage de paramètres entre plusieurs applications (asm et langage évolué).
-optimisation d'un programme (les trucs et astuces genre xor ax,ax...)en vue de le rendre plus compact ou plus rapide

En règle générale, moins il y en a dans un programme et plus il est facile à comprendre - c'est le but recherché d'un tutoriel.

Pour terminer il est vrai que le 16 bits est un peu dépassé à l'heure des 32 et 64 bits mais il est vrai que l'enseignement de l'assembleur s'effectue trop souvent sur du 16 bits.
Afficher les 7 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.