Stampare numeri a 32 bit

di il
20 risposte

Stampare numeri a 32 bit

Di nuovo ciao a tutti!
Ho ripreso in mano Assembly dopo un esame di mezzo...Essendo comunque alle prime armi con il 386 ho provato a modificare alcune funzioni che già avevo implementato in cui devo utilizzare i registri a 32 bit...
Per ora prendo in input un numero da 32 bit e lo stampo, due funzioni di partenza per controllare che almeno la base del mio programma sia solida prima di implementare le altre funzioni richieste...
Il fatto è che se inserisco da tastiera 12345 mi stampa in output dei numeri senza alcun senso...

Ora...ammesso che la funzione di lettura da tastiera funzioni correttamente...questa stampa potrebbe essere adatta a stampare un registro esteso?!
STAMPA_NUM1     PROC  NEAR

				XOR EDX, EDX
				MOV EAX,NUMERO		;metto in EAX il numero da stampare
				XOR EBX, EBX		;azzero il registro per il dividendo
				XOR	CX,CX			;azzero il registro per il contatore delle cifre
                MOV EBX, 10         ;imposta il divisore

   MEMONUM1:   	
                DIV  EBX			;divido per 10
                PUSH DX             ;salvo il resto
				XOR  DX,DX          ;azzero DX
                INC  CX             ;incremento il contatore cifre
                CMP  EAX, 0         ;devo ripetere?
                JNZ MEMONUM1

                 
   STAMPANUM1: 	POP DX              ;riprende i numeri come LIFO
                MOV AX, DX          ;metto in AX numero da stampare
                CALL STAMPA_NUMERO   ;stampo
                LOOP STAMPANUM1      ;ripeto

	STOP1:		RET             	;Ritorno alla procedura chiamante
STAMPA_NUM1     ENDP
La DIV dovrebbe salvarmi il risultato della divisione in EAX e il resto in EDX giusto?! Ma dividendo ogni volta per 10 il mio resto è un numero che comunque ci sta nella sola parte DX del registro esteso corrispondente quindi io ho pensato di poter fare PUSH e POP solo del registro DX...
Il fatto è che da quanto ho trovato in rete non mi sembra che con PUSH e POP si possano usare registri a 32bit nel 386 e questa mi sembra l'unica via...
Parto a chiedere da questa perchè è quella che mi lascia più dubbi e se è sbagliata questa ovviamente non ho modo di controllare il numero che prendo in input...

20 Risposte

  • Re: Stampare numeri a 32 bit

    Scusa ma perchè non usi delle variabili locali come appoggio o i registri edi e esi al posto di complicarti la vita con push e pop?
    comunque la tecnica più semplice per stampare un numeo a 32bit e la seguente:
    scorpora il numero da 32bit i due numeri da 16 bit
    numero dd ?
    menosign dw ?
    piusign dw ?
    mov dword ptr numero,(numero che voglio stampare)
    xor eax,eax
    xor ecx,ecx
    add ax,word ptr numero[0] ;somma ax ai 2 byte meno significativi di numero
    add cx,word ptr numero[2] ; sommo cx ai 2 byte più significativi
    mov word ptr menosign,ax
    mov word ptr pisign,cx
    adesso che hai i numeri sorporati in 16 bit e molto facile stamparli.
    un altra tecnica chepotresti usare senza usare variabili locali e la seguente:
    divisioni successive per 10,100,1000 etc etc
    consiste nel trovare il numero di cifre del numero.
    poi con un semplice ciclo ti calcoli il divisore
    e poi dividi per il numeo calcolato.
    rendi stampabile i quoziente e lo stampi.
    moltiplichi il quoziente calcolato con il divisore calcolato
    sottrai al numero originale quest'ultimo calcolo
    ripeti il tutto fin quando le cifre non sono finite
    per farti capire segui questo esempio:
    numero da stampare 12345678 mettilo in esi o edi cifre = 8 mettilo in cx (cosi in un unico loop risolvi il problema)
    divisore calcolato = 10000000
    eax = 12345678 ebx =10000000 div ebx dopo eax=1 ti stampi il carattere
    esi - (ebx * quoziente calcolato)= 2345678 cifre alias cx-1 = 7
    eax = esi ebx=1000000 div ebx dopo eax=2 ti stampi il carattere
    esi - (ebx * quoziente calcolato)= 345678 cifre alias cx-1 = 6
    e cosi via fino a che cx non sia uguale a 0
    per quanto riguarda il calcolo del moltiplicatore basta che fai:
    mov ebx,10
    mov eax,1
    mov ecx,0
    calcolo: cmp esi,eax jl procedi
    mul ebx
    inc ecx
    jmp calcolo
    se non sai come fare o hai qualche dubbio chiedi pure.
  • Re: Stampare numeri a 32 bit

    Prima di tutto...grazie mille!
    Il motivo per cui usavo lo stack, oltre al fatto che anche negli assegnamenti precedenti facevo così, è che essendo LIFO mi tornava molto utile perchè inserivo i numeri in ordine inverso dividendo sempre per 10 il numero da stampare e quello me li restituiva nell'ordine corretto per la stampa...

    Ma va beh...ho provato a implementare il secondo metodo che mi hai consigliato visto che è più simile a quello che usavo io ma il programma si impalla e non capisco il perchè...
    Io ho scritto così...
    La cosa che non mi convince è il JL nel codice che mi hai scritto tu...se il numero da stampare è 12345678 il divisore da me calcolato è 1000000, ed il secondo è minore del primo quindi non so se è corretto fatto così...
    STAMPA_NUM1		PROC NEAR
    				
    				MOV	 ESI, NUMERO
    				
    	INIT:		MOV	 EBX, 10		;Calcolo del divisore corretto
    				MOV	 EAX, 1			;qui salvo il divisore
    				MOV  ECX, 0			;conto le cifre
    	CALCOLO:	CMP  ESI, EAX		;se il divisore è già maggiore del mio numero
    				JL	 PROCEDI		;procedo
    				MUL	 EBX			;moltiplico per 10, risultato in EAX
    				INC	 ECX			;incremento il numero delle cifre
    				JMP  CALCOLO		;ripeto
    				
    	PROCEDI:	MOV	 EBX, EAX		;metto il divisore calcolato in un altro registro
    				MOV  EAX, ESI		;in EAX metto il numero da stampare
    				DIV	 EBX			;ottengo la cifra più significativa del numero da stampare
    				CALL STAMPA_NUMERO	;stampo il numero che ho in EAX
    				MUL  EBX			;ebx*quoziente calcolato in eax
    				SUB  ESI, EAX		;al numero sottraggo la parte già stampata
    				DEC  ECX			;decremento il numero delle cifre
    				CMP  ECX,0
    				JA	 INIT
    				
    				RET
    STAMPA_NUM1		ENDP
    Si impalla subito al primo ciclo e non stampa assolutamente nulla...di solito è un problema di salti sbagliati quando mi capitano cose del genere ma non saprei quale è sbagliato...riusciresti a darci un'occhiata per favore?!
  • Re: Stampare numeri a 32 bit

    Doppio...scusate! E' per far notare il cambiamento nel caso qualcuno abbia già letto il post qui sopra...

    Avevo notato che messo come prima non poteva funzionare perchè ogni volta ricalcolavo anche il numero delle cifre...quindi ho pensato di modificare la parte di PROCEDI inserendovi il calcolo del nuovo divisore, praticamente dividendolo per 10 ogni volta in modo da decrementarlo...
    A parte questo...il codice è diventato così e il problema è lo stesso di prima
    STAMPA_NUM1		PROC NEAR
    				
    				MOV	 ESI, NUMERO
    				
    	INIT:		MOV	 EBX, 10		;Calcolo del divisore corretto
    				MOV	 EAX, 1			;qui salvo il divisore
    				MOV  ECX, 0			;conto le cifre
    	CALCOLO:	CMP  ESI, EAX		;se il divisore è già maggiore del mio numero
    				JL	 PROCEDI		;procedo
    				MUL	 EBX			;moltiplico per 10, risultato in EAX
    				INC	 ECX			;incremento il numero delle cifre
    				JMP  CALCOLO		;ripeto
    				
    	PROCEDI:	MOV	 EBX, EAX		;metto il divisore calcolato in un altro registro
    				MOV  EAX, ESI		;in EAX metto il numero da stampare
    				DIV	 EBX			;ottengo la cifra più significativa del numero da stampare
    				CALL STAMPA_NUMERO	;stampo il numero che ho in EAX
    				MUL  EBX			;ebx*quoziente calcolato in eax
    				SUB  ESI, EAX		;al numero sottraggo la parte già stampata
    				MOV	 EAX, EBX		;rimetto il divisore in EAX
    				MOV	 EBX, 10		;devo calcolare il nuovo divisore, avrà uno zero in meno del precedente
    				DIV	 EBX			;in EAX ho il nuovo divisore
    				DEC  ECX			;decremento il numero delle cifre
    				CMP  ECX,0
    				JA	 PROCEDI
    				
    				RET
    STAMPA_NUM1		ENDP
  • Re: Stampare numeri a 32 bit

    Data la quantità limitata di stack necessario, la soluzione push/pop mi sembra molto semplice e gestibile.

    Hai compilato con TASM? Fornisci il codice completo e compilabile che dò un'occhiata.
  • Re: Stampare numeri a 32 bit

    Con tasm32 compilo e linko con tlink...ho messo la direttiva .386 all'inizio del codice...

    Ho tolto la funzione che ho scritto stamattina e ho rimesso la mia iniziale con lo stack...così compila, linka e va ma non stampa il numero corretto...ripeto, vista la mia scarsa abilità con l'assembly potrebbe esserci un errore anche nella funzione ATOI di lettura del numero ma senza stampa non me ne rendo conto

    Tutto il codice è questo:
    ;TITLE  -  Esercitazione di Calcolatori Elettronici
    .386
    ;Definizione costanti
    PAGINA    	EQU   	00h
    HT  		EQU   	09h
    LF   		EQU   	0Ah
    CR		    EQU   	0Dh
    ;
    BIOS_VIDEO	    EQU	10H
    SET_VIDEO_MODE 	EQU	00h 	;in AH
    MODO_TESTO	    EQU	03H	    ;in AL
    ;
    SET_CURSOR	EQU	02h 	;in AH
    W_CHR_TTY	EQU	0Eh  	;in AH
    ;
    DOS		        EQU	21H
    R_KEY_CHR 	    EQU	01H
    PRINT_STRING	EQU	09H
    R_KEY_CHR_NE 	EQU	07h 
    
    DSEG            SEGMENT PARA PUBLIC 'DATA'
    TITOLO          DB  'Assegnamento 3 - Calcolatori Elettronici$'
    ISTR_1			DB	'Inserire un numero minore di 1000000: $'
    ISTR_2			DB	'Inserire un numero minore di 200: $'
    NCIFRE			DW	00h
    TEMP	      	DB  16 DUP(?)
    NUMERO			DD	00h
    DSEG			ENDS
    
    STACKM            SEGMENT PARA STACK 'STACK'  ;Viene allocata una zona di
                      DB      64 DUP('12345678')  ; memoria per lo Stack: in
    STACKM            ENDS                        ; tutto 64*8 bytes.
    
    
                      ASSUME CS:CSEG,DS:DSEG,SS:STACKM
    CSEG              SEGMENT PARA PUBLIC 'CODE'
    
    ;---------------------------------------------------------------------;
    ;                   Corpo principale del programma                    ;
    ;---------------------------------------------------------------------;
    
    MAIN            	PROC  FAR
    					PUSH  DS              ;Istruzioni da lasciare SEMPRE
    					MOV   AX,00h          ; al principio dei programmi!
    					PUSH  AX              ;
    					CALL  INIZIALIZZAZIONE
    CICLO_PRINCIPALE:	CALL  PROMPT_1
    					CALL  ATOI_A
    					CALL  STAMPA_NUM1
    					CALL  PROMPT_2
    					
    					RET
    MAIN			  	ENDP
    
    ;---------------------------------------------------------------------;
    ;                   Procedura di inizializzazione                     ;
    ;                                                                     ;
    ; REGISTRI UTILIZZATI: AX, DX, DS                                     ;
    ;---------------------------------------------------------------------;
    
    INIZIALIZZAZIONE  PROC  NEAR
                      MOV   AX,DSEG         ;Inizializzazione segmento dati
                      MOV   DS,AX           ; tramite il registro AX.
    
                      MOV   AH,SET_VIDEO_MODE  ;Servizio BIOS 'Set Video Mode':
                      MOV   AL,MODO_TESTO  	   ; modo testo 80 x 25, colori
                      INT   BIOS_VIDEO         ;
    
                      MOV   DX,0315h        ;Imposta riga (DH) e colonna (DL)
                      CALL  SPOSTA_CURSORE  ;Muove il cursore nella pos scelta
    
                      MOV   DX,OFFSET TITOLO ;Sceglie la stringa (DS:DX)
                      CALL  STAMPA_STRINGA  ; e la stampa.
    
                      MOV   DX,0606h        ;Imposta riga (DH) e colonna (DL)
                      CALL  SPOSTA_CURSORE  ;Muove il cursore nella pos scelta
                      RET                   ;Ritorno alla procedura chiamante
    INIZIALIZZAZIONE  ENDP
    
    ;---------------------------------------------------------------------;
    ;              Procedura per stampare il messaggio iniziale           ;
    ;                                                                     ;
    ; REGISTRI UTILIZZATI: DX, AH                                         ;
    ;---------------------------------------------------------------------;
    
    PROMPT_1        PROC  NEAR
                    MOV   DX,OFFSET ISTR_1 ;Sceglie la stringa (DS:DX)
                    CALL  STAMPA_STRINGA  ; e la stampa.
                    RET                   ;Ritorno alla procedura chiamante
    PROMPT_1        ENDP
    
    PROMPT_2        PROC  NEAR
                    MOV   DX,OFFSET ISTR_2 ;Sceglie la stringa (DS:DX)
                    CALL  STAMPA_STRINGA  ; e la stampa.
                    RET                   ;Ritorno alla procedura chiamante
    PROMPT_2        ENDP
    
    ;---------------------------------------------------------------------;
    ;   Procedura per leggere un numero e memorizzarlo in NUMERO_1        ;
    ;                                                                     ;
    ;  REGISTRI UTILIZZATI: AX, BX, CX, SI                                ;
    ;---------------------------------------------------------------------;
    
    ATOI_A		    PROC  NEAR
        INIT_A:     XOR   CX,CX           ;Azzero i registri
    				XOR   BX,BX           ;
    				XOR   AX,AX           ;
    				   
    				MOV   SI,0            ;Mi posiziono nella prima locazione dell'array
        START_A:	MOV   AH, R_KEY_CHR	  ;Servizio DOS 'Read Keyboard Char'
                    INT   DOS             		   
    		        CMP   AL,13           ;Se hai inserito il tasto invio
    				JE    FINELETT_A      ;hai finito di inserire il numero e finisce la lettura
    				CMP   AL, '0'         ;Se non hai inserito un numero
    				JB    ERR_A           ;hai commesso un errore
    				CMP   AL, '9'         ;''
    				JA    ERR_A           ;''
         
    	MEM_A: 	   	SUB   AL,'0'          ;sottraggo per trasformare il char in un numero
    		        MOV   BYTE PTR TEMP[SI],AL ;lo inserisco nell'array alla posizione puntata
    			    INC   SI              ;Incremento l'indice dell'array
    			    INC   CX              ;Incremento il contatore delle cifre
                    JMP   START_A		  ;devo ripetere il ciclo	
        FINELETT_A:	MOV	  TEMP[SI+1],'$' ;Inserisco il carattere di fine stringa dopo l'ultima cifra inserita
    
                    XOR   EAX,EAX           ;Azzero i registri
    				XOR   EDX,EDX
    				XOR   EBX,EBX
    				MOV   SI, OFFSET TEMP  ;passiamo l'offset per ricavare l'indirizzo
    	CICLO_A:	MOV   EAX, DWORD PTR[BX+SI]
    	            XOR   AH,AH
    				CMP   EAX,'$'          ;Confronto per verificare se ci si trova alla fine della stringa
    				JE    FINE_A          ;se sono alla fine salto a FINE_1
    				CMP   CX, 1           ;Confronto se il numero totale delle cifre inserite è uguale a 1
    				JE    FINE_A          ;se sì, salto a FINE_1
    				ADD   EAX,[NUMERO]   ;Sommo NUMERO in AX
    				MOV   EDX, 10          
    				MUL   EDX        ;Moltiplico NUMERO_1 per 10
    				DEC   CX              ;Decremento CL (solo in caso di CL>1)
    				INC   BX              ;incremento l'indice dell'array
    				MOV  [NUMERO],EAX    ;Sommo(sovvrascrivendo) il numero moltiplicato in NUMERO_1
    				JMP   CICLO_A         ;Ripeto il ciclo, fino ad avere CL=1
    				   
        ERR_A: 		;CALL	PROMPT_ERR
    				CALL	PROMPT_1
    				JMP		INIT_A
    				   
    	FINE_A:		ADD   [NUMERO],EAX    ;Sovrascrivo AX in NUMERO_1
    				   
    			    RET
    ATOI_A		    ENDP
    
    ;---------------------------------------------------------------------;
    ;         Procedura per stampare un numero a 32 bit					  ;
    ;                                                                     ;                                        ;
    ;---------------------------------------------------------------------;
    
    STAMPA_NUM1     PROC  NEAR
    
    				XOR EDX, EDX
    				MOV EAX,[NUMERO]		;metto in EAX il numero da stampare
    				XOR EBX, EBX		;azzero il registro per il dividendo
    				XOR	CX,CX			;azzero il registro per il contatore delle cifre
                    MOV EBX, 10         ;imposta il divisore
    
       MEMONUM1:   	
                    DIV  EBX			;divido per 10
                    PUSH DX             ;salvo il resto
    				XOR  DX,DX          ;azzero DX
                    INC  CX             ;incremento il contatore cifre
                    CMP  EAX, 0         ;devo ripetere?
                    JNZ MEMONUM1
    
                     
       STAMPANUM1: 	POP DX              ;riprende i numeri come LIFO
                    MOV AX, DX          ;metto in AX numero da stampare
                    CALL STAMPA_NUMERO   ;stampo
                    LOOP STAMPANUM1      ;ripeto
    
    	STOP1:		RET             	;Ritorno alla procedura chiamante
    STAMPA_NUM1     ENDP
    
    ;---------------------------------------------------------------------;
    ;         Procedura per stampare un numero da 0 a 9                   ;
    ;                                                                     ;
    ; PARAMETRI: il numero e' memorizzato in AL                           ;
    ; VARIABILI: il numero della pagina e` memorizzato in PAGINA          ;
    ; REGISTRI UTILIZZATI: AX, BL                                         ;
    ;---------------------------------------------------------------------;
    
    STAMPA_NUMERO     PROC  NEAR
                      ADD   AL,'0'          ;La base da cui partire e' '0'
                      MOV   AH,W_CHR_TTY    ;Servizio BIOS 'Write Char in TTY'
    										;che stampa il carattere
    STAMP:            INT   BIOS_VIDEO
                      RET                   ;Ritorno alla procedura chiamante
    STAMPA_NUMERO     ENDP
    
    ;---------------------------------------------------------------------;
    ;                   Procedura per spostare il cursore                 ;
    ;                                                                     ;
    ; PARAMETRI: le coordinate della posizione del cursore sono memoriz-  ;
    ;            zate nel registro DX: DH riga, DL colonna.               ;
    ; VARIABILI: il numero della pagina e` memorizzato in PAGINA          ;
    ; REGISTRI UTILIZZATI: AH, BH                                         ;
    ;---------------------------------------------------------------------;
    
    SPOSTA_CURSORE    PROC  NEAR   
                      MOV   BH,PAGINA       ;Pagina video attiva.
                      MOV   AH,SET_CURSOR	;Servizio BIOS 'Set Cursor
                      INT   BIOS_VIDEO      ; Position'
                      RET                   ;Ritorno alla procedura chiamante
    SPOSTA_CURSORE    ENDP
    
    ;---------------------------------------------------------------------;
    ;                  Procedura per stampare una stringa                 ;
    ;                                                                     ;
    ; PARAMETRI: l'indirizzo della stringa e` memorizzato in DS:DX        ;
    ; REGISTRI UTILIZZATI: AH, DX                                         ;
    ;---------------------------------------------------------------------;
    
    STAMPA_STRINGA    PROC  NEAR 
                      MOV   AH,PRINT_STRING ;Servizio DOS 'Print String'; la
                      INT   DOS             ; stringa e' puntata da DS:DX.
                      RET                   ;Ritorno alla procedura chiamante
    STAMPA_STRINGA    ENDP
    
    
    CSEG              ENDS
                      END  MAIN
  • Re: Stampare numeri a 32 bit

    Se provi inserendo

    MOV EAX,1234

    nella sub di stampa vedrai che funziona. Quindi il problema sta prima, nell'input del numero.
  • Re: Stampare numeri a 32 bit

    In particolare, il carattere $ finale non serve (hai il registro CX che ti indica il numero di cifre) e la parte che va da

    FINELETT_A

    a

    ATOI_A ENDP

    è sbagliata. Se la sostituisci semplicemente con queste poche righe, risolvi (le righe sono così semplici che non te le spiego neanche)
    
    FINELETT_A: XOR SI,SI
                XOR EAX,EAX
    	         CMP CX,0
    	         JZ OUT_A
    			
    CICLO_A:	 MOV EDX,10          
                MUL EDX        
    		      XOR EBX,EBX
    		      MOV BL,BYTE PTR [TEMP+SI]
                ADD EAX,EBX
                INC SI
                LOOP CICLO_A         
    			
    OUT_A:	   MOV NUMERO,EAX
    		      RET
    			
    ERR_A:      ;CALL   PROMPT_ERR
                CALL   PROMPT_1
                JMP      INIT_A
    ATOI_A          ENDP
    
  • Re: Stampare numeri a 32 bit

    Grazie!! Grazie!! Grazie!!
    Ora l'ho guardata un pò di fretta perchè avevo poco tempo ma domani me la guardo meglio, comunque funziona e non so che altro dirti...grazie veramente!
  • Re: Stampare numeri a 32 bit

    Di nulla ... spero che studierai bene il codice (che è semplice e per questo interessante) ...

    P.S. @smalldragon ... mi sembra che per trattare valori a 32 bit con CPU a 32 bit, quella di separare il valore in due pezzi a 16 bit è proprio una cosa assurda ...
  • Re: Stampare numeri a 32 bit

    Si, si ho appena finito ed è veramente semplice come ragionamento! Hai inserito anche l'uso del loop che io non ho mai in mente e decremento sempre con l'istruzione apposta per poi fare un CMP!

    Perfetto! Ho sistemato un pò il mio codice in modo da avere due funzioni che mi chiamano la routine di lettura e di stampa così non ho codice duplicato e salvo e stampo in variabili diverse e ora procedo con la funzione che è lo scopo del programma che devo fare! Spero di non trovare troppi intoppi...

    Grazie mille per il prezioso aiuto!
  • Re: Stampare numeri a 32 bit

    P.s:@oregon
    non esiste una sola soluzione ad un problema ma più soluzioni
    nessuna assurdita perchè ad esempio 12345678
    metti in un registro a 16bit 1234 ed in un altro 5678
    utilizzando poi i registri a 8 bit avrai 12 34 56 78
    che poi divisi per 10 nel ordine giusto ottieni lo scorporo dei numeri.
    come procedimento e più lungo ma e solo un metodo.
    ed io ce ne ho forniti almeno 2 per farlo scegliere.
    cosa che se si può bisogna sempre offrire.
  • Re: Stampare numeri a 32 bit

    smalldragon ha scritto:


    p.s:@oregon
    non esiste una sola soluzione ad un problema ma più soluzioni
    Certo, non ho mai detto che c'è *una* sola soluzione ma che, in determinate circostanze, alcune soluzioni sono assurde.

    A parte il fatto che non hai fatto un po' di debugging del codice fornito, non hai visto che il problema non stava nella stampa ma nella conversione ASCII binario della atoi.
    nessuna assurdita perchè ad esempio 12345678
    metti in un registro a 16bit 1234 ed in un altro 5678
    utilizzando poi i registri a 8 bit avrai 12 34 56 78
    che poi divisi per 10 nel ordine giusto ottieni lo scorporo dei numeri.
    L'assurdità sta proprio qui. Perché mai fare questo giro (o peggio, quello delle divisioni/moltiplicazioni) se disponi di CPU a 32 bit, registri a 32 bit e microcodice per una semplice divisione a 32 bit? Perché dire che con push/pop ci si complica la vita quando lo scopo primario di quell'esercizio è proprio sfruttare lo "stack" facendo imparare il concetto di LIFO ai programmatori?

    come procedimento e più lungo
    E in questo sta l'assurdità e il problema principale dei tuoi suggerimenti. Hai una CPU a 32 bit e la usi come una ad 8 ...
  • Re: Stampare numeri a 32 bit

    P.s:@oregon
    l'esercizio sullo stack sarebbe comunque salvo anche con questo metodo.
    anzi insegnerebbe a memorizzare anche unità più piccole del registro a 32 bit ampliando le conoscescenze rispetto a quanto era previsto.
    poi il cercare metodologie alternative al uso dello stack quali ad esempio uso di variabili e molteplici registi ne fa capire il vero vantaggio rispetto al classico usa lo stack e il problema si risolve!
    ma per imparare l'uso dello stack cosi come di ogni struttura informatica bisognerebbe spiegarne non solo i meccanismi ma anche gli svantaggi che essa ha.
    e poi era semplicemente un metodo di risoluzione cosi come ce ne sono tanti altri nulla di più e nulla di meno nessuna assurdità e poi avere una o più scelte fa si che le persone possano trovare sia la loro strada che la loro conoscenza nonchè capire i propri errori.
    comunque ogni uno alla fine resterà della propria idea.
    quindi nessuna polemica e buona giornata.
  • Re: Stampare numeri a 32 bit

    smalldragon ha scritto:


    p.s:@oregon
    l'esercizio sullo stack sarebbe comunque salvo anche con questo metodo.
    E come, se suggerisci di non utilizzare push/pop ?
    poi il cercare metodologie alternative al uso dello stack quali ad esempio uso di variabili e molteplici registi ne fa capire il vero vantaggio rispetto al classico usa lo stack e il problema si risolve!
    Beh, scusa se te lo dico ancora, ma non capisco quello che dici. Suggerisci una cosa "sbagliata" per far capire quanto era giusta la soluzione "giusta"? Boh ...
    ma per imparare l'uso dello stack cosi come di ogni struttura informatica bisognerebbe spiegarne non solo i meccanismi ma anche gli svantaggi che essa ha.
    E quali sarebbero gli svantaggi in un problema che ha tutto da guadagnare nell'uso dello stack ?
    quindi nessuna polemica e buona giornata.
    Figurati non c'entrano le polemiche, era solo per capire perché per andare da Roma a Milano tu suggerisca di passare per New York - Mosca giustificando il fatto che esistono tante "strade" per arrivare alla mèta. Mah ...

    Buona giornata anche a te.
Devi accedere o registrarti per scrivere nel forum
20 risposte