[c++] Domanda su puntatori e memoria

[monelli]

Ho una classe Test

dove è dichiarato:

un puntatore int *ptr;
Il costruttore ptr=new int(1);
Il distruttore delete ptr;

Ora facendo:

Test a;

Creo l'oggetto a lo alloco nello stack, e sarebbe un puntatore che punta ad un int che si trova nell' heap. Corretto?

Test b(a)

Il costruttore di copia, non essendo definito da me è definito in automatico dal compilatore: alloca l'oggetto b nello stack, questo è di nuovo un puntatore che punta allo stesso int di prima?

In pratica a e b sono oggetti che contengono un puntatore allo stesso int nello heap.

Se io chiamo il distruttore di b... questo cancella lo spazio allocato nello heap e quindi il puntatore dell'oggetto a perde consistenza giusto???

Secondo... Ho un ciclo
for(i=0;i<10;i++)
{
Test a;
}

In pratica creo e distruggo 10 volte l'oggetto a giusto??? Quando chiudo la parentesi graffa del ciclo for viene chiamato in automatico il distruttore di a giusto???

Grazie (Scusate ho dimenticato le parentesi nel titolo ma non posso più modificarlo)

[Gimli[2BV!2B]]

Tu hai esposto a parole cosa c'è scritto in Test::Test() e Test::~Test(), vero?

Con codice di questo tipo si ha l'inizializzazione di una zona di memoria nello heap durante la chiamata al costruttore.
Creando una copia dell'oggetto con il costruttore di copia di default (se non lo hai definito ne viene creato uno standard) verrà semplicemente copiato il contenuto delle variabili membro (in questo caso un puntatore) e si avrà un nuovo oggetto che conterrà un puntatore che punterà alla stessa zona di memoria.
Distruggendo uno dei due oggetti si andrà a liberare questa memoria.
Però attenzione! Per un periodo di tempo indefinito tutto funzionerà tranquillamente.

Ad un certo punto (potrebbe anche non succedere...) quella zona di memoria libera verrà riutilizzata ed il dato sarà modificato, oppure l'oggetto superstite modificherà i nuovi dati che saranno memorizzati in quel punto.
Il programma si comporterà in modo incomprensibile dando errori casuali e sempre diversi...

La necessità di creare oggetti di questo tipo capita raramente, in questi casi è spesso necessario definire costruttore di copia, distruttore ed overloading di vari operatori per poter utilizzare l'oggetto con la stessa comodità e sicurezza degli oggetti che non allocano heap.

Riguardo agli oggetti all'interno del loop, ne verrà creato e distrutto uno nuovo per ogni ciclo. Se possibile è preferibile evitarlo...

[monelli]

Ok grazie capito tutto chiaro...
Ancora una domandina su un altro argomento:

Ho una funzione f

f()
{
EnterCriticalSection(&cs); //1
n++;
EnterCriticalSection(&cs); //2
i++;
LeaveCriticalSection(&cs);
}

La sezione critica cs è definita altrove e già inizializzata.

Chiamo da 1 thread la funzione f()... Il programma si blocca???
Io direi che la 1 e la 2 non bloccano perchè sono nello stesso thread giusto?

Ora se ho più thread che chiamano la funzione f() il tutto funziona??? O solo un thread riesce ad eseguire la f() perchè chiamo 2 volte la enter e una sola la leave???

[cionci]

Si dovrebbe bloccare perché c'è già un thread in sezione critica, cioà lui.
Poi in teoria si potrebbe evitare...dipende un po' da come è implementata la sezione critica.

Se fosse una semplice mutex potrebbe anche avere senso. Magari il thread si blocca sulla prima chiamata in attesa che un altro thread esegua una signal sulla mutex, per poi entrare in sezione critica per modificare i che è una variabile condivisa.

Da quello che mi ricordo le critical section non permettono questo meccanismo.

[monelli]

Mi riferisco ad una critical section di win32 definita così:

CRITICAL_SECTION cs;

[cionci]

After a thread has ownership of a critical section, it can make additional calls to EnterCriticalSection or TryEnterCriticalSection without blocking its execution. This prevents a thread from deadlocking itself while waiting for a critical section that it already owns. The thread enters the critical section each time EnterCriticalSection and TryEnterCriticalSection succeed. A thread must call LeaveCriticalSection once for each time that it entered the critical section.

http://msdn.microsoft.com/en-us/library/ms682608(VS.85).aspx

[monelli]

Grande grazie del link... Effettivamente ho appena provato ed è così!

Comunque tutto dipende dal fatto che la critical section è stata implementata così su win32... Magari su un altro sistema con altre librerie si comporta in modo diverso.