Addition et affichage du resultat.

**Code Rom** · 03/04/2018, 18h33

Bonjour, toujours dans l'apprentissage de l'assembleur je me créer des exercices simples.L'un d'eux consiste a faire une addition et a afficher le résultat, évidement j'ai quelques problèmes.Je me suis aidé de sources trouvées sur le net et il y a certaines instructions que je ne comprends pas.Un éclairsissement ne serait pas de refus.

Voici mon code actuel, qui m'affiche bien les deux chiffres mais au lieu de m'afficher le resultat de la somme de ces derniers il m'affiche 7 (alors qu'il devrait m'afficher 14, 7+7)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
segment .text
 
global _start
 
_start:
 
	; affichage chiffre 1
	mov dx, 0
	mov ax, 7
 
	mov bl, 1
 
	add al, 30h
 
	mov [chiffre1], al
 
	mov eax, 4
	mov ebx, 1
 
	mov ecx, chiffre1
	mov edx, 1
	int 80h
 
	; Affichage chiffre 2
	mov dx, 0
	mov bx, 7
 
	add bx, 30h
 
	mov [chiffre2], bx
 
	mov eax, 4
	mov ebx, 1
 
	mov edx, chiffre2
	mov edx, 1
	int 0x80
 
	; addition des deux chffres
	add ax, bx
 
	mov eax, 4
	mov ebx, 1
	int 0x80 
 
	; FIN
	mov eax, 1
	mov ebx, 0
 
	int 80h
 
segment .bss
 
chiffre1 	resb	1
chiffre2	resb 	1
chiffre3	resb	1

De plus voici les lignes que je ne comprends pas :

- mov bl, 1 ( pourquoi mov ax, 7 ne suffit pas ?)

- add al, 30h (pourquoi additioner 0 (30h est égal a 0 en ASCII il me semble))

- quel est la difference entre mov [chiffre1], al, et mov al, [chiffre1], je sais que mov al, [chiffre1] met la valeur de chiffre 1 dans al et non pas l'adresse mais l'autre instruction je ne la comprends pas.

Voila et pour finir je réitère ma question principale pourquoi le programme ne m'affiche pas la somme des deux chiffres (7+7 = 14).

Merci a vous et bonne fin de journéee !

**chrtophe** · 03/04/2018, 20h20

- mov bl, 1 ( pourquoi mov ax, 7 ne suffit pas ?)

Le mov bl ne sert à rien car ensuite tu as une ligne mov ebx,1
Pour savoir ce qu'il faut dans les registres entre eax à edx, il faut lire la documentation. Il s'agit de la fonction write sous linux (eax=4), ebx doit contenir le handle ou écrire : 1 correspond à stdout, ecx doit contenir l'adresse contenant ce qu'il fait écrire, et edx le nombre de caractères à écrire.

add al, 30h (pourquoi additioner 0 (30h est égal a 0 en ASCII il me semble

al vaut 7, ajouter 0x30 va donner 0x37, correspondant au code ASCII du chiffre 7. Cela permet dans ce cas de facilement convertir le chiffre 7 en code ASCII, attendu par la fonction write. attention ce n'est pas valable pour une conversion plus complexe.

quel est la difference entre mov [chiffre1], al, et mov al, [chiffre1], je sais que mov al, [chiffre1] met la valeur de chiffre 1 dans al et non pas l'adresse mais l'autre instruction je ne la comprends pas.

Ca fait l'inverse à savoir met la valeur de al dans [chiffre1]

Quand à l'addition qui ne se fait pas, elle se fait après ton affichage.

**Code Rom** · 03/04/2018, 20h30

Merci pour cette réponse rapide et très détaillée, ça me permet de comprendre encore un peu mieux ce langage assez difficile a appréhender.

Je vais me repencher sur mon code et je pense qu'avec ta réponse je vais pouvoir afficher correctement le résultat de l'addition.

Je met le sujet résolu et y reviendrais si besoin, encore merci !

**Code Rom** · 03/04/2018, 23h15

Re bonsoir, bon je reviens vers vous car je suis perdu là, voilà un petit moment que je cherche et le meilleur affichage que j'ai pu avoir est un pauvre n qui ne me parle pas.

Voici mon code actuel :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
segment .text
 
global _start
 
_start:
 
	; affichage chiffre 1
	mov dx, 0
	mov ax, 7
 
	add al, 30h
 
	mov [chiffre1], al
 
	;mov eax, 4
	;mov ebx, 1
 
	;mov ecx, chiffre1
	;mov edx, 1
	;int 80h
 
	; Affichage chiffre 2
	mov dx, 0
	mov bx, 7
 
	add bx, 30h
 
	mov [chiffre2], bx
 
	mov [chiffre1], ax
 
	add ax, bx
 
	mov [chiffre3], ax
 
	mov eax, 4
	mov ebx, 1
 
	mov ecx, chiffre3
	mov edx, 2
	int 0x80 
 
	; FIN
	mov eax, 1
	mov ebx, 0
 
	int 80h
 
segment .bss
 
chiffre1 	resb	1
chiffre2	resb 	1
chiffre3	resw	1

Avec ce code j'obtiens comme affichage le caractère n ...... je comprend pas.

**chrtophe** · 04/04/2018, 08h48

Et du coup, que veux u additionner ?

Il te faut effectuer l'addition, puis convertir le résultat en code ASCII, le stocker dans l'adresse passée en paramètre à la fonction write

Sépare bien les différentes étapes

Fais un code qui :
charge un registre avec le 1er chiffre, un autre avec le second, puis additionne les deux

Un code qui converti ce résultat en ASCII

et un code qui affiche

Avant cela je vais te donner cet exercice :
Fais -moi un code qui va additionner les chiffres 320 et 412 en base 10. Ces deux chiffres proviendront de mémoires réservées (comme tu l'a fait pour adresse) de 16 ou 32 bits nommée chiffre1 et chiffre2 pour le second.
Quel est le résultat de cette addition en héxadécimal ?

Une fois cela fait, nous ferons une conversion fonctionnelle en ASCII.

**Code Rom** · 04/04/2018, 11h37

Voila le code que j'ai fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
segment .text
 
global _start
 
_start:
 
	xor eax, eax
	xor ebx, ebx
 
	mov eax, [chiffre1]
	mov ebx, [chiffre2]
 
	add eax, ebx
 
	mov eax, 4
	mov ebx, 1
	mov ecx, eax
	mov ebx, 3
 
	;FIN
	mov eax, 1
	mov ebx, 0
	int 0x80
 
segment .data
 
chiffre1	dw	320
chiffre2	dw	412

Et pour le résulat de l'addition en héxa :

en hexa :
16^5 = 1 048 576
16^4 = 65 536
16^3 = 4 096
16^2 = 256
16^1 = 16

On divise par le nombre hexa le plus proche.

320 en decimal :
320 / 256 = 1.25 (on garde que le 1)
1 * 256 = 256
320 - 256 = 64
64 / 16 = 4 (on garde le 4)
4 / 16 = 0.25(on garde le 0)

donc 320d = 140h

Avec la même logique :
412 / 256 = 1,609375 (on garde que le 1)
1 * 256 = 256
412 - 256 = 156
156 /16 = 9,75 (on garde que le 9)
9 * 16 = 144
156 - 144 = 12 (egal C en hexa)

donc 412d = 19Ch

Maintenant additionnons 140h + 19Ch:

140
+
19C
______

O + C = 0 + 12 = 12 = C
4 + 9 = 13 = D
1 + 1 = 2

Donc le resultat en hexa de 140h + 19Ch = 2DCh

**chrtophe** · 04/04/2018, 21h13

Jusqu'à la ligne 13, c'est bon. En dessous je n'ai pas regardé, car je n'avais demandé que l'addition.
Les calculs sont bons. Je pense que tu as compris.

Maintenant la suite sera de faire l’algorigramme pour transformer le résultat de eax (732/0x2dc) en chaine de caractères.

nous aurons donc dans eax les 4 octets suivants : 00 00 02 DC

Nous avons vu précédemment qu'ajouter 0x30 à un chiffre permet de le transformer en son équivalent ASCII. Mais dans ce cas, ça ne peut pas marcher.

Il faut procéder par puissance de 10, c'est à dire extraire le chiffre des unités, des dizaines, des centaines, etc. Dans chaque cas, tu auras alors un chiffre entre 0 et 9 qui correspondra au critère de conversion en ajoutant 0x30

Essayes de faire un algorigramme pour faire cela. On verra le code ensuite.

**Code Rom** · 05/04/2018, 05h26

Alors voici l'algorigramme, je n'avais jamais fait ce genre d'exercice avant. J'ai donc lut quelque tutoriel et j'espère avoir fait quelque chose de correct.J'ai fait ça sur papier que j'ai ensuite scanné, j'écris un peu mal si vraiment tu trouves ça laid ou illisible je le referais sur ordi avec paint ou gimp, ça doit pas être sorcier.

Algorigramme dispo ici : http://www.image-heberg.fr/files/152...1623797875.jpg

Je voulais aussi te dire un grand merci pour l'aide apporté, ta pédagogie et ta sympathie, c'est vraiment super de m'aider comme tu le fait.

**chrtophe** · 05/04/2018, 09h29

De rien.

Alors voici l'algorigramme, je n'avais jamais fait ce genre d'exercice avant. J'ai donc lut quelque tutoriel et j'espère avoir fait quelque chose de correct

Non, ce n'est pas correct. Je t'explique : Si je te demande de le faire avec un résultat>1000, tu devras refaire ton algorigramme pour y ajouter une case, et si je te donne un chiffre>10000, ou >100000 ?

L'idée est de diviser ton résultat par 10 tant que c'est possible, le reste de la division étant le caractère en cours à convertir en ASCII.

Essayes de refaire ton algorigramme en conséquence. En parallèle, cherches les mnémoniques assembleur permettant d'effectuer des testssur des valeurs de registres et donc des sauts conditionnels.
Si tu as pratiqué d'autres langages, il s'agit d'effectuer l'équivalent de boucles while et de tests if

Pour l’algorigramme, cherches tests conditionnels.

Évites de mettre des images par liens, Insères-les plutôt dans le post avec l’icône image (juste à gauche de l’icône vidéo dans l'éditeur de message).

**Code Rom** · 05/04/2018, 13h40

Alors voici le nouveau algorigramme :

Nom : 15229281231984267319.jpg
Affichages : 3490
Taille : 607,8 Ko

Et pour le mnémoniques :

les généraux seront : mov, div, int

pour les test de conditions : je (jump if equal)

les registres utilisé seront : eax, al, ah

Voila j'ai fait du mieux que j'ai pu mais je sais pas je le sens pas.

**chrtophe** · 05/04/2018, 20h43

Voila plutôt à quoi devrait ressembler ton algorigramme :
Nom : algorigramme.jpg
Affichages : 2915
Taille : 31,9 Ko

Pour les mnémoniques :

Tu auras besoin de cmp (pour effectuer une comparaison)
pour les saut les mnémoniques possibles seront :
jmp (jump), jg (jump greater),jge (jump greater equal) jl (jump less) - liste non exhaustive.
pour les registres utilisés, nous utiliserons des registres 32 bits, donc probablement pas ah et al qui sont des sous-parties de eax.

Essayes de faire un code depuis l'organigramme en présumant que eax contient la valeur à afficher.

Un peu de lecture sur les mnémoniques :
https://benoit-m.developpez.com/asse...ndex.php#LIV-C

PS : sur l'organigramme fait vite fait avec powerpoint (il existe des logiciels dédiés à ça), j'ai oublié à la fin l'ajout de 0x30 au quotient.

**Code Rom** · 06/04/2018, 14h13

Bonjour, bon j'ai écris deux code car je n'arrive vraiment pas a savoir lequel est le "bon" (si il y en a un de bon pour commencer).

Voici les codes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
segment .text
 
global _start
 
_start
 
	mov eax, 732		; eax vaut 732
 
	operation :
 
	div 10				; on divise eax par 10
 
	add edx, 0x30		; on ajoute a edx (qui contient le reste) 0x30 pour la convertion ASCII
 
	adc edx, eax		; add with carry sur eax, le reste est placé dans edx.
 
	inc edx				; incrémentation de edx
 
	cmp eax, 10			; on compare eax a 10, eax > 10 ?
 
	jg operation 		; saut conditionnel jump if greater, saut a l'étiquette operation si eax > 10
 
	mov ecx, eax		; si eax < 10 on le place dans ecx
 
	add ecx, 0x30		; on ajoute a ecx 30h pour la covertion ASCII
 
	;Fin du programme
	mov eax, 1
	mov ebx, 0
	int 0x80
 
 
 
segment .text
 
global _start
 
_start
 
	mov eax, 732		; eax vaut 732
 
	operation :
 
	div 10				; on divise eax par 10
 
	add edx, 0x30		; on ajoute a edx (qui contient le reste) 30h pour la convertion ASCII
 
	add reste, edx		; on ajoute le reste a l'adresse de la  variable non initialisé : "reste"
 
	inc reste			; incrémentation de l'adresse de reste
 
	cmp eax, 10			; on compare eax a 10, eax > 10 ?
 
	jg operation 		; saut conditionnel jump if greater, saut a l'étiquette operation si eax > 10
 
	mov ecx, eax		; si eax < 10 on le place a dans ecx
 
	add ecx, 0x30		; on ajoute a ecx 30h pour la convertion ASCII
 
	;Fin du programme
	mov eax, 1
	mov ebx, 0
	int 0x80
 
 
segment .bss
 
reste	resb	1

En fait c'est cette partie qui me perturbe : "Stockage reste dans adresse".Je stocke a l'adresse d'un resgitre ou a l'adresse d'une variable ? c'est peut être bête comme question mais ça me perturbe.

**chrtophe** · 06/04/2018, 20h54

oui, je vois ça.

il faut stocker les codes ASCII dans des cases mémoires contiguës qui représenteront ta chaine. Pour cela on va utiliser une adresse stockées dans un registre que l'on va incrémenter après chaque écriture.

Pour cela je vais t'apprendre 2 nouveaux mnémoniques :
xchg reg1,reg2 : permet d'échanger le contenu des deux registres passé en paramètre
stosb : stocke le contenu de al dans l'adresse contenu dans edi et incrémente de un la valeur de edi. (il existe aussi stosw, et stosd : cherche la différence)
Tu vas pouvoir modifier ton code :
Avant la boucle stocker dans edi l’adresse de ta variable qui stockera la chaine ASCII, la mémoire devra avoir été correctement réservée dans le segment data (ou bss si tu veux).
Dans la boucle, Une fois la division effectuée et 0x30 ajouté dans edx, échanger eax et edx
stocker le contenu de al dans la variable avec stosb
mettre le contenu de edx dans eax (edx ayant été swapé contient le quotient restant à traiter)
mettre edx à 0, car une chose qui t'as probablement échappée à moins de bien avoir lue la doc de div, div prend en paramètre edx:eax (edx représentant les bits de poids fort, eax ceux de poids faible).

**Code Rom** · 09/04/2018, 00h04

bon voila le code, déjà quand je compile il ne me trouve pas d'erreur, pour moi c'est déjà bien, mais je doute que le code soit correct.....

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
segment .text
 
global _start
 
_start:
 
	mov eax, 732		; eax vaut 732 = aussi le numérateur
 
	mov edi, chaine 	; Avant la boucle stocker dans edi l’adresse de ta variable qui stockera la chaine ASCII.
 
	operation :
 
	mov ebx, 10			; ebx est le dénominateur.
 
	div ebx				; on divise eax par 10
 
	add edx, 0x30		; on ajoute a edx (qui contient le reste) 0x30 pour la convertion ASCII
 
	xchg eax, edx		; échanger eax et edx
 
	stosb 				; stocker le contenu de al dans la variable avec stosb
 
	mov eax, [edx]		; mettre le contenu de edx dans eax 
 
	xor edx, edx		; mettre edx à 0
 
	cmp eax, 10			; on compare eax a 10, eax > 10 ?
 
	jg operation 		; saut conditionnel jump if greater, saut a l'étiquette operation si eax > 10
 
	mov ecx, eax		; si eax < 10 on le place dans ecx
 
	add ecx, 0x30		; on ajoute a ecx 30h pour la convertion ASCII
 
	;Fin du programme
	mov eax, 1
	mov ebx, 0
	int 0x80
 
 
segment .bss
 
chaine	resb	1

Désole pour la réponse tardive j'étais absent ce week-end.

**chrtophe** · 09/04/2018, 07h34

Quelques erreurs :

Ligne 23 : Il faut remplacer mov eax,[edx] par mov eax,edx, sinon tu vas copier la valeur contenu à l'adresse stockée dans edx à la place de la valeur d'edx.

Ligne 29 : Il faut utiliser jge (jump greater equal) au cas ou la valeur serait de 10.

Ligne 30 à 35 :

Tu peux laisser la valeur dans eax pour ajouter 0x30, pas besoin de passer par ecx, par contre il faudra utiliser stosb

Pour la partie affichage, tous les registres nécessaires à l'affichage ne sont pas positionnés.

Enfin, tu ne réserve qu'un octet pou ta chaine, c'est pas un peu faible ?

**Code Rom** · 12/04/2018, 17h13

Salut je me connecte vite fait juste pour te dire de ne pas t'inquieter, ces deux jours ci je suis pas mal pris.Je ne pourrais malhureusement poster une réponse que vendredi soir ou en fin d'arpès-midi du même jours.

Je vais esaiyer de te présenter un code correct et juste en fonction de tes indications et du code déjà porposer sur le post précédents.

Voila encore merci je progresse beaucoup grace a toi j'ai compris plein de truc, c'est géniale

**chrtophe** · 12/04/2018, 20h13

**Code Rom** · 13/04/2018, 21h14

Salut, bon ça avance doucement mais surement.J'arrive desormais a affiché le 2 de 732, j'aurais aimé y passé plus de temps .Mais avec la fatigue ça a était dur dur.

Voici le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
segment .text
 
global _start
 
_start:
 
	mov eax, 732		; eax vaut 732 = aussi le numérateur															
 
	mov edi, total 	; Avant la boucle stocker dans edi l’adresse de ta variable qui stockera la chaine ASCII.				
 
	operation :																																					
 
	mov ebx, 10			; ebx est le dénominateur.
 
	div ebx				; on divise eax par 10
 
	add edx, 0x30		; on ajoute a edx (qui contient le reste) 0x30 pour la convertion ASCII
 
	xchg eax, edx		; échanger eax et edx
 
	stosb 				; stocker le contenu de al dans la variable avec stosb
 
	mov eax, edx		; mettre le contenu de edx dans eax 
 
	xor edx, edx		; mettre edx à 0
 
	cmp eax, 10			; on compare eax a 10, eax > 10 ?
 
	jge operation 		; saut conditionnel jump if greater equal, saut a l'étiquette operation si eax > 10
 
	add eax, 0x30		; on ajoute a ecx 30h pour la convertion ASCII
 
	stosb
 
	mov eax, 4
	mov ebx, 1
 
	mov ecx, total
	mov edx, 1
	int 0x80
 
	xor eax, eax
 
	mov edi, total
 
	mov ebx, 10
	div ebx
 
	add ebx, 0x30
 
	xchg eax, ebx
 
	stosb
 
	;Fin du programme
	mov eax, 1
	mov ebx, 0
	int 0x80
 
 
segment .bss
 
centaines	resb	100
dizaines	resb	 10
unite		resb	  1
 
total		resb	732

Sur ce bonne fin de soirée, tchao !

**chrtophe** · 14/04/2018, 08h56

Tu y est presque.

les déclarations de centaines dizaines unités ne servent à rien. Ligne 67, tu réserves 732 octets, ce qui est inutile.

Ensuite ton code de 42 à 55 ne sert à rien.

Mais tout ceci n'a pas d'incidence sur ton problème. Tu arrive à afficher que 2, car tu dis à la fonction write (eax=4 int 0x80) de n'afficher qu'un caractère. Il est indispensable de te documenter sur les fonctions utilisées et d’émettre ce qu'il faut dans les bons registres.

1er exercice annexe : de combien d'octets as-tu besoin pour ce cas précis
2ème : pour pouvoir afficher n'importe quel nombre 32 bits, combien d'octet dois tu réserver.
3ème : la fonction write attend en edx le nombre de caractères de la chaine qu'il va te falloir renseigner. Indice tu connais l'adresse de début et de fin.

Autre petite astuce : Ta ligne 13 mov ebx,10 peut être placée juste avant la boucle, ce qui évitera qu'à chaque boucle, ebx soit positionné sur 10. Si ta boucle se faisait plusieurs milliers de fois, tu ferais plusieurs milliers d'opérations inutile, une seule étant nécessaire.

**Code Rom** · 14/04/2018, 17h33

Alors déjà je suis bien content car j'ai réussis a afficher mes 3 chiffres, mais dans le sens inverse c'est a dire que j'affiche 237 au lieu de 732, mais je vais réfléchir a cette question dans la soirée.

Voici le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
segment .text
 
global _start
 
_start:
 
	mov eax, 732		; eax vaut 732 = aussi le numérateur															
 
	mov edi, total 	; Avant la boucle stocker dans edi l’adresse de ta variable qui stockera la chaine ASCII.				
 
	mov ebx, 10			; ebx est le dénominateur.
 
	operation :																																					
 
 
	div ebx				; on divise eax par 10
 
	add edx, 0x30		; on ajoute a edx (qui contient le reste) 0x30 pour la convertion ASCII
 
	xchg eax, edx		; échanger eax et edx
 
	stosb 				; stocker le contenu de al dans la variable avec stosb
 
	mov eax, edx		; mettre le contenu de edx dans eax 
 
	xor edx, edx		; mettre edx à 0
 
	cmp eax, 10			; on compare eax a 10, eax > 10 ?
 
	jge operation 		; saut conditionnel jump if greater equal, saut a l'étiquette operation si eax > 10
 
	add eax, 0x30		; on ajoute a ecx 30h pour la convertion ASCII
 
	stosb
 
	mov eax, 4
	mov ebx, 1
 
	mov ecx, total
	mov edx, 3
	int 0x80
 
	xor eax, eax
 
	;Fin du programme
	mov eax, 1
	mov ebx, 0
	int 0x80
 
 
segment .bss
 
total 		resb 	3

Pour tes exercices voici mes réponses :

1er exercice annexe : de combien d'octets as-tu besoin pour ce cas précis
2ème : pour pouvoir afficher n'importe quel nombre 32 bits, combien d'octet dois tu réserver.

1) Je pense que 3 octets sont suffisant 1 octet par chiffre.

2) Pour pouvoir afficher n'importe quel nombre 32 bits il faut selon moi environ 4 Giga octets , car sur 32bits on peut stocker des nombres allant de −2,147,483,648 (−2^31) jusqu'a 2,147,483,647 (2^31 − 1) (merci wikipedia), donc une "largeur" d'environ 4 milliards, soit 4 milliards d'octets (comme je part du principe qu'il faut un octet par chiffre) on arrive environ à 4 Giga octets pour stocker le tout.

Voila je pense avoir répondu a toute tes questions et je touche presque le but, je sais pas comment te remercier vraiment c'est top de m'aider comme ça.

Je me repenche sur le code en debut de soirée si j'arrive a afficher 732 je posterais la solution.

Encore merci.

Addition et affichage du resultat.

x86 32-bits / 64-bits Assembleur

Discussions similaires

Partager

Partager