Newsgroup: it.comp.lang.c
Titolo: Dichiarazione e Inizializzazione Ciclica di varaibili

Vorrei sapere se alla fine di ogni iterazione del ciclo while le
variabili dichiarate all'interno vengono DISTRUTTE (o disallocate)
oppure questo codice tende ad intasarmi la memoria fin quando nno
termina tutta la funzione.
Ecco il codice di esempio
void MIA_FUNZIONE() {
int i=0;
While (i!=5) {
     //altro codice
     char testo[20];
    //altro codice
i++;
}
} //FINE FUNZIONE

thedog ha scritto:

Stai ridichiarando la stessa variabile, sei sicuro che sia utile?
La variabile è certamente non visibile all'esterno del while; sul fatto
che venga deallocata propendo per il no, perché dovrebbe far parte dello 
stack frame della funzione. Dando un'occhiata all'asm prodotto dal 
compilatore (PellesC su un x86):
_f:
push ebp
mov ebp,esp
sub esp,24
mov dword [ebp+(-4)],0
jmp near @3
@2:
mov byte [ebp+(-24)],48
inc dword [ebp+(-4)]
@3:
cmp dword [ebp+(-4)],5
jne near @2
mov dword [ebp+(-4)],0
@1:
mov esp,ebp
pop ebp
ret
Puoi notare che vengono riservati per le variabili locali solo 24 byte
sullo stack: 4 per 'i' e 20 per una sola istanza di 'testo'. Entrambe le
variabili "vivono" fino alla fine della funzione.
Se vedi roba che non c'entra col tuo codice C: ho messo testo[0]='0';
dopo la dichiarazione e i=0; dopo il while giusto per aggiungere
operazioni e vedere se il compilatore incrementava lo stack pointer
"deallocando" la variabile.
Non so se con altri compilatori o su altri sistemi, il comportamento sia
lo stesso.
Ciao.

Ciao Cane (io sono TheDog... quindi siamo li...) ;-))
Credo che tu sia stato molto chiaro ma ti chiedo conferma di quello che
ho capito anche perhè credo che hai indirettamente confermato la mia
teoria. Io volevo sapere se dopo la terza iterazione la memoria
consumata a testo corrispone a 60 caratteri...
tralasciando l'utilità del codice, volevo sapere se facendo andare
questo ciclo con numeri grandissimi finivo per arrivare all'ultima
iterazione con la ram piena di allocazioni a vuoto oppure se ad ogni
battuta di ciclo lui va ascrivere sempre sugli stessi byte
inizializzati per la prima iterazione.
Da quello che mi dici devo capire che usa sempre gli stessi byte,
quindi dopo 3 iterazioni la memoria utilizzata è sempre 20 caratteri e
non 60.
Ho capito bene??
Grazie 1000!
Ciao! (cioè BAU! o WOOFF!!! )
cane ha scritto:


thedog ha scritto in it.comp.lang.c:

Prima di tutto ricordatevi di quotare il messaggio originale _prima_ della
risponsta, altrimenti non si capisce più niente.
Eseguendo il ciclo molte molte, non si alloc memoria in più ogni ciclo,
quindi puoi stare tranquillo.
Però non c'è alcuna garanzia che il contenuto di testo[] venga preservato
tra un ciclo e il successivo, e nemmeno che l'indirizzo di testo[] sia
sempre lo stesso in ogni ciclo. Devi pensare testo come "variabile locale"
al blocco su cui cicli, e ogni volta che fai un ciclo allochi e liberi
tutto (come se le graffe del blocco fossero equivalenti alle graffe di una
funzione).


Eh, grazie; scrivilo _dopo_ il listato che hai aggiunto "='0'":). Volevo 
solo avvisarvi che siete incappati nell'opera dell'ottimizzatore. Per vedere 
ciò che, in realtà, dovrebbe succedere nel blocco di istruzioni associato al 
while, dovresti disabilitare l'ottimizzatore e così potrai notare che 
l'array di 20 caratteri verrà allocato quando è scritto in C e disallocato 
al termine del blocco (se nulla cambia bp la possibilità che venga 
riallocato nella stessa zona dello stack è altissima). L'ottimizzatore lo 
alloca una tantum perché allocare e disallocare sarebbe stato inutile. Non 
ho provato, ma ho come l'impressione che non lo avessi inizializzato, 
l'ottimizzatore non l'avrebbe nemmeno allocato.
Scusate l'intromissione..
..un saluto.
Maxime 

Papavero Rosso ha scritto:

Ok, scusate, ora quoto in alto.
FINALMENTE! GRAZIE!! era proprio quello che voelvo sapere, cioè alla
fine di ogni iterazione la memoria viene disallocata... non mi importa
un fico secco di che fine faccia il testo dell'iterazione precedente...
era solo per sapere se effettivamente quel tipo di codice poteva
portare svantaggi fondamentali a livello di memoria. Visto che non è
così, è tutto ok
GRAZIE 10000000000 A TUTTI!!! 
Ciao!