[C++] deallocare memoria in una funzione

[toraz]

se c'è una cosa che ho imparato è di non porsi domande... perchè facilemnte non si troverà la risposta
ma io imperterrito continuo a pormele e imperterrito non riesco a trovare risposte... cmq... venendo al dunque ho poc'anzi scritto per fare qualche prova non so bene di che genere questa funzione del tutto inutile

int* foo( int number )
{
  int* array = new int[ 10 ];
  int index;
  
  for ( index = 0; index < 10; index++ )
    array [ index ] = index * number;
  
  delete [] array;
  return array;
}

ok... si lo so... è una funzione idiota ma non è questo il punto... quello che mi sto domandando è... io con l'istruzione

delete [] array;

ho deallocato l'array com'è possibile che venga restituito un puntatore a un array che ho già bello che deallocato?!? temo di essermi perso qualche pezzo qua e la e non ho capito una mazza... qualcuno avrebbe voglia di spiegarmi a grandi linee cosa succede dentro alla funzione di cui sopra e come mai tutto funziona come dovrebbe?!?... bizzarro... non dev'esserci tanta gente che si lamenta che tutto funziona!

[Angioletto]

Sto studiando anche io le variabili dinamiche, ma ancora non ho esattamente capito la deallocazione...Cioè,non mi è chiaro cosa fa..
Probabilmente restituisce quei registri di memoria al sistema operativo, senza però alterarne il contenuto: sarebbe una operazione inutile, ti pare??
Quindi alla fine della funzione, array punta ad un'area di memoria deallocata, ma che ancora contiene i valori di quel vettore, ma solo perchè nel frattempo il sistema operativo non ha avuto bisogno di quella memoria..
Diciamo che devi ritenerti fortunato se tutto funziona..

Ho avuto anche io un problema del genere, ma ho deallocato alla fine del main: non credo sia però una soluzione giusta!!
In effetti quando chiamo una fuzione, il programma chiamante dovrebbe strafregarsene di cosa combina il sottoprogramma chiamato!!!

Penso di aver individuato il problema, ma ancora non ho compreso la giust soluzione!!!

Bisogna sbatterci la testa ancora un pò

[toraz]

Originariamente inviato da Angioletto
Probabilmente restituisce quei registri di memoria al sistema operativo, senza però alterarne il contenuto: sarebbe una operazione inutile, ti pare??

mah... in linea di principio dovrebbe funzionare che quando tu allochi della memoria il sistema operativo riserva quella memoria per il programma che l'ha allocata il quale dentro ci scrive quello che vuole... deallocando la memoria questa non viene modificata ma viene solamente detto al sistema operativo "senti... sta roba non mi serve più... fanne un po quello che vuoi!"... almeno... credo che funzioni così.

Originariamente inviato da Angioletto
Quindi alla fine della funzione, array punta ad un'area di memoria deallocata, ma che ancora contiene i valori di quel vettore, ma solo perchè nel frattempo il sistema operativo non ha avuto bisogno di quella memoria..
Diciamo che devi ritenerti fortunato se tutto funziona..

giusto... mi sembra sensata la cosa... ma a questo punto mi viene da farmi una domanda... se io all'interno di una funzione volessi allocare dinamicamente della memoria come faccio poi a rilasciarla al sistema in un caso del genere (ovvero quando la funzione deve restituire il puntatore alla memoria allocata)?!? viene deallocata automaticamente quando l'esecuzione esce dalla funzione oppure devo preoccuparmene io?!? e se sono io che devo preoccuparmene come devo fare?!?... aiuto... mi si sta inguazzabugliando il cervello!

[Angioletto]

Sicuramente te ne devi preoccupare tu..
Anche se ti trovi all'interno di un sottoprogramma, con l'operatore new la memoria non ti viene data sullo stack, ma nell'heap!!
Alla chiusura del sottoprogramma vengono cancellate solo le variabili sullo stack (sono dette variabili automatiche): l'altra memoria devi deallocarla tu!!!
Purtroppo in c++ funziona così....

Il problema l'ho risolto deallocando nel main, a cui ho passato il puntatore..ma credo sia una soluzione un pò sporca!!
Ci penserò...ma non ti assicuro tempi brevi!!! :master:

[Angioletto]

Ho posto la stessa domanda sul newsgroup della mia università, mi ha risposto il professore

Questa era la mia domanda:

Suppongo di avere una funzione fatta in questo modo:

int*  nome_funzione( int  )
{
  int* array = new int[ 10 ];
  .....
  .....
  return array;
}

In pratica gli passo un intero (ma è solo un esempio!), e a partire da quel
parametro mi costruisce un array. La funzione mi alloca dinamicamente
l'array e alla fine lo passa (tramite puntatore) al programma chiamante..

Dove devo deallocare l'array?
-> credo non avrebbe senso nella funzione: non posso deallocare qualcosa
che poi deve essere ancora utilizzato!!
-> se poi lo faccio nel programma chiamante, quest'ultimo dovrebbe sapere
come lavora a funzione, cioè dovrebbe essere a conoscenza del fatto che
l'array è stato allocato dinamicamente..e non credo sia una soluzione
pulita!!

Allora?!?

Questa è stata la risposta:

>int*  nome_funzione( int  )
> {
>   int* array = new int[ 10 ];
>   .....
>   .....
>   return array;
> }

Questo è un "pattern" molto più comune di quanto si potrebbe pensare.

> Dove devo deallocare l'array?
> -> credo non avrebbe senso nella funzione: non posso deallocare
> qualcosa che poi deve essere ancora utilizzato!!

Su questo non c'è dubbio.

> -> se poi lo faccio nel programma chiamante, quest'ultimo dovrebbe
> sapere come lavora a funzione, cioè dovrebbe essere a conoscenza del
> fatto che l'array è stato allocato dinamicamente..e non credo sia una
> soluzione pulita!!

E' una soluzione pulita solo se il chiamante _sa bene_ che la funzione
alloca dinamicamente un oggetto.

E' vero, ci siamo detti tante volte che il chiamante deve ignorare l'implementazione di una funzione e limitarsi solo a conoscerne il prototipo. In certi casi, come quello di sopra, però, il servizio offerto da una funzione è proprio quello di creare un oggetto in base a certe regole (proprio come la funzione CostruisciLista() del nostro esercizio
ListaOrdinata; le regole in quel caso le fissava l'utente). Questo tipo di funzioni si chiamano Factory (fabbrica) e, di solito, hanno il nome che inizia per Create... (CreateList, CreateWidget, CreateComponent, etc...)proprio per ricordare al chiamante che stanno costruendo qualcosa che andrà poi distrutto. Questo comportamento deve ovviamente essere documentato da chi scrive (e documenta) la funzione.

Problema risolto!!!

:metallica

[toraz]

Originariamente inviato da Angioletto
Problema risolto!!!

:metallica

yeah!... grazie mille!