Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
No, è passato troppo tempo da quando lo ho letto, ma credo si riferisse al fatto che alcuni sistemi hanno file di paging, partizioni di swap o sistemi simili.......
Ovviamente lo stack è unico, e le allocazioni da parte di malloc e new non sono fatte su stack, ma emulare l'heap è tutt'altro che impossibile...
Son contento di vedere che anche se mi esprimo in modo sicuramente impreciso avevo in testa le cose corrette. I dubbi me li ha scatenati la frase che ho citato dalle dispense del corso, perché m'è sembrata un po' ambigua. Accertato che è solo una questione di fraintendimento di alcuni termini e che la memoria allocata dinamicamente non viene liberata per magia, ora sono ragionevolmente più sicuro (e un po' deluso, perché sarebbe stata una gradita scoperta). Grazie.
Tornando a new e malloc... da letture delle quali non so citare la fonte (molto probabilmente Guida al linguaggio C++ di H. Schildt) ricordo affermazioni che sostenevano che...
1. new e delete sono operatori, mentre malloc/calloc e free sono funzioni
2. new in pratica è un malloc/calloc che chiama il costruttore dell'oggetto creato subito dopo l'allocazione (malloc/calloc non chiama un bel niente, alloca e basta)
3. delete è in pratica un free che chiama il distruttore dell'oggetto prima di eliminarlo (free non chiama un bel niente, dealloca e basta)
4. bisogna evitare come la peste di usare free con un puntatore "ricevuto" da new e di usare delete su un puntatore ricevuto da malloc/calloc (questa non l'ho mai capita, anche se mi son sempre adeguato)
5. si possono usare new e malloc/calloc, così come free e delete, in uno stesso programma ma rispettando assolutamente 4.
6. se malloc/calloc fallisce restituisce NULL, mentre se new fallisce non è così (per questo prima di usare new inizializzo preventivamente e prudentemente tutti i puntatori su NULL)
7. non si deve usare free su un puntatore NULL, mentre è innocuo "cancellare" un puntatore NULL con delete (in effetti non succede nulla)
8. i puntatori ottenuti da NULL sono automaticamente del tipo corretto, quelli ottenuti da malloc/calloc sono dei puntatori "generici" di tipo *void (da cui la necessità del cast se si usano in contesto C++)
Ho elencato in ordine sparso, man mano che le cose mi venivano in mente, e avrò certamente lasciato fuori qualcosa. Al di là delle dimenticanze, è tutto esatto?
Insisto perché la gestione della memoria dinamica mi tiene sempre un po' sulle spine dal momento che dà luogo a problemi che vanno dal crash plateale a errori sottili e dagli effetti dilazionati ma a volte non meno gravi che per me non è così facile individuare. Insomma, lo ritengo un punto sul quale è bene essere più sicuri possibile.
Ah, la mia affermazione sul modo in cui Windows alla chiusura d'un processo "fa fuori" tutto quel che è stato lasciato indietro è corretta? Anche questo penso sia un punto importante, e la mia affermazione nel commento precedente era preceduta da quell'inquietante "per quel che ne so"...
Ultima modifica effettuata da AldoBaldo il 24/08/2015 alle 9:07
ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
Ora sappiamo che llvm usa unmalloc (visual studio non si sa e la libc++ di g++ dovrei cercarla), che anche new ritorna void*, esattamente come malloc, e che l'unico motivo per cui delete su NULL non crasha è perchè viene fatto un controllo:
Codice sorgente - presumibilmente C/C++
void
operator delete(void* ptr) _NOEXCEPT
{
if (ptr)
::free(ptr);
}
"4. bisogna evitare come la peste di usare free con un puntatore "ricevuto" da new e di usare delete su un puntatore ricevuto da malloc/calloc (questa non l'ho mai capita, anche se mi son sempre adeguato) "
Questo per due ragioni: non per tutti i compilatori la runtime è uguale a questa, e quindi allocano via malloc e liberano con free. E poi perchè se liberi un oggetto con free il distruttore non viene chiamato.
"si possono usare new e malloc/calloc, così come free e delete, in uno stesso programma ma rispettando assolutamente 4. "
Si ma è brutto.
"Ah, la mia affermazione sul modo in cui Windows alla chiusura d'un processo "fa fuori" tutto quel che è stato lasciato indietro è corretta? Anche questo penso sia un punto importante, e la mia affermazione nel commento precedente era preceduta da quell'inquietante "per quel che ne so"..."
http://stackoverflow.com/questions/1232262/memory-leak-in- ... il tizio che risponde alla persona che fa la domanda dice che vari sistemi operativi eliminano la memoria utilizzata dalla tua applicazione quando questa termina. Comunque la seconda risposta mi piace tantissimo: affidarsi al so affichè sia lui a rimediare ai tuoi memory leaks comporta due svantaggi: non sai se il so lo farà, perchè non è un comportamento standard, hai memoria inutilizzata e inallocabile durante l'esecuzione del tuo programma....
Ultima modifica effettuata da TheDarkJuster il 24/08/2015 alle 13:15
Vuoi che la memoria si liberi da solo all'uscita del tuo programma semplicemente chiamando un funzione? Bene:
copia operator new e chiamalo autoDeleteNew. Subito dopo aver allocato memoria copia il puntatore da ritornare in una lista di void e ritorna il puntatore.
A questo punto hai una lista (organizzala come vuoi: a stack, a vector, a doubly linked list, a linked list ecc....), sempre aggiornata con tutti gli indirizzi iniziali di tutti i blocchi di memoria allocata. Puoi usare questa lista per cancellare ricorsivamente tutta la memoria quando la suddetta funzione viene chiamata.
Altri bonus possono essere: 1. memorizzi anche la dimensione del blocco di memoria sulla lista, così puoi fare heapSizeOf() sul tuo puntatore e scoprire la lunghezza in byte. Ovviamente heapSizeOf è una funzione che devi definire tu.
2. copiare delete, cambiare il nome alla tua copia e fare in modo che quando della memoria viene eliminata viene rimossa dalla lista sopracitata.
Ecco, ora sai come aggiungere l'autodelete della memori allocata alla fine del programma. Ora poi sbizzarrirti a provare un po' di cose nuove
TheDarkJuster, il metodo che hai descritto è intrigante, ma... ne vale la pena? Forse in programmi di dimensioni elefantiache, ma sicuramente non nelle piccole sciocchezze che metto insieme io. In ogni caso, sappi che ho preso nota e che prima o poi proverò a implementarlo. Se faccio esplodere qualche galassia a causa dei tuoi suggerimenti ti ritengo direttamente responsabile!
ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
Ok, se con l'auto deallocazione della memoria fai esplodere una galassia ti do il permesso di dare la colpa a me . In pratica quello che ti ho consigliato di fare è un piccolissimo e inutile (ma estensibile) garbage collector.
Per gestire automaticamente la memoria in C++ idiomatico di solito si cerca di non allocarla con new, si usano i containers della STL che fanno da soli.
Se proprio bisogna allocare memoria (ad esempio per sfruttare il polimorfismo, metodi virtuali ecc) l'ultima tendenza è quella di usare i cosiddetti smart pointers (shared_ptr & company).
E non bisogna mischiare free/malloc con new/delete perché non necessariamente gli ultimi usano internamente i primi (anzi, in genere si ridefiniscono proprio affinché usino un custom allocator, magari a sua volta basato su malloc).
