Pagina 1 di 1
[c++] relazione tra visibilità e memoria
Inviato: mer 24 ott 2007, 17:42
da gallows
Mi chiedevo come funzionasse la gestione di memoria in relazione agli
scope.
Ad esempio:
Codice: Seleziona tutto
void f(bool flag)
{
// ...
if (flag)
for (int i=0; i<8; i++) {
// ...
}
// ...
}
Considerato un compilatore generico senza ottimizzazioni attivate, la
creazione di "i" in memoria avviene quando si arriva al ciclo for ()
oppure lo spazio viene creato nello stack della funzione semplicemente
quando viene invocata? In pratica, lo scope ha a che fare con la
gestione della memoria? Se sì, come penso, in che modo viene allocato
lo spazio di sizeof(int) per i? Sopra lo stack riservato a f() ?
Quando "usciamo" dal ciclo for () le risorse di i vengono liberate?
Oppure tutto ciò viene fatto all'uscita della funzione?
Grazie,
s.
Inviato: mer 24 ott 2007, 19:01
da lamarozzo
Secondo me lo standard fissa univocamente le regole per quanto riguarda lo scope delle variabili. Come venga invece implementato in memoria è strettamente legato al compilatore. Quello che verosimilmente si può dire del codice d'esempio che hai riportato è che:
*) una volta invocata la funzione f() sulla stack viene allocata la memoria per le variabili automatiche. Anche la variabile i.
*) se provi ad accedere alla variabile 'i' prima del blocco 'for' il compilatore ti restituisce l'errore di scope.
*) tutte le risorse vengono liberate solo all'uscita della funzione. Anche perchè se io annido due cicli è inverosimile che ogni volta che si esegue il ciclo interno tutte le variabili automatiche vengano distrutte e poi ricreate (sarebbe uno spreco di CPU).
Se non fosse così sarei curioso di saperlo anch'io. A presto.
Inviato: mer 24 ott 2007, 19:21
da lamarozzo
Aggiunta. Ho scritto il seguente codice:
Codice: Seleziona tutto
int i;
for (i=0;i<10;i++)
{
if (i%2==0)
{
int k;
k=3;
}
if (i%3==0)
{
int k;
k=3;
}
}
e con il debugger sono andato a vedere gli indirizzi di memoria delle due variabili k.
Il risultato è che la prima variabile k mantiene sempre il suo indirizzo di memoria, e così anche la seconda variabile k. Ho inserito le operazioni di modulo in modo tale che per diversi valori di 'i' a volte viene creata la prima k (numeri pari), a volte la seconda, a volte entrambe. Se le variabili k venissero aggiunte sullo stack solo all'interno dei blocchi la prima k e la seconda k, al variare di i, si dovrebbero scambiare gli indirizzi. Cosa che non avviene.
Spero che il post sia leggibile con tutte queste k
A presto.
Inviato: mer 24 ott 2007, 19:54
da gallows
Forse viene usato un registro del processore? Di 'ste cose a basso livello purtroppo non me ne intendo molto...
*) tutte le risorse vengono liberate solo all'uscita della funzione. Anche perchè se io annido due cicli è inverosimile che ogni volta che si esegue il ciclo interno tutte le variabili automatiche vengano distrutte e poi ricreate (sarebbe uno spreco di CPU).
Ottima osservazione!
Sostanzialmente mi chiedevo se a livello della memoria cambi qualcosa nel diminuire la visibilità di una variabile. Ci sarebbe da chiedere nella mailing list di g++, anche perché temo, come hai detto tu, che lo standard C++ non dia nessuna direttiva per l'implementazione.
Inviato: gio 25 ott 2007, 0:05
da lamarozzo
Io penso che a livello di memoria non ci sia una dipendenza dallo scope (parlo sempre però di variabili all'interno di una stessa funzione). Piuttosto il compilatore, quando deve tradurre il nome delle variabili in indirizzi di memoria, effettua un check controllando che la variabile sia stata dichiarata nel particolare blocco di codice: in caso negativo si ferma segnalando l'errore di sintassi; in caso positivo "sostituisce" alla variabile l'indirizzo di memoria sullo stack che le è stata assegnata al momento della chiamata alla funzione.
Comunque un salto sulla mailing list di cpp si può fare. Una volta ho postato una domanda pensando di segnalare un bug e mi hanno risposto con molta delicatezza, senza farmi pesare il fatto che era proprio una domanda da niubbo!
