Allocazione dinamica di memoria con C

[CheCk_OUTSIDE]

Salve ragazzi.. ho una domanda un po' particolare a cui non ho trovato risposta, e mi chiedevo se qualcuno di voi poteva darmi qualche delucidazione..

La domanda riguarda l'onnipotente linguaggio C.. uno dei linguaggi piu' conosciuti al mondo direi..

La mia domanda e' relativa alla gestione della memoria dinamica tramite le funzioni malloc e free.
Quello che vorrei capire e'..

Perche' quando devo allocare dello spazio con malloc devo passargli la quantita' di memoria che mi serve, mentre quando vado a deallocarla con free non serve??

O meglio, so che questo e' possibile perche' il C gestisce la memoria dinamica tenendo traccia della dimensione allocata per ogni variabile.. quello che mi chiedo piu' precisamente e':
Perché al C non costa nulla ricordarsi la dimensione della memoria allocata dinamicamente con malloc? Ossia, perche' non optare su una soluzione simile a quella del Pascal, che ti obbliga a dirgli la quantita' di memoria da deallocare??

Grazie mille in anticipo a chiunque si faccia anke solo la para di leggere tutto questo..

CheCk_OuTSidE

[Ikitt]

Originariamente inviato da CheCk_OUTSIDE
Perche' quando devo allocare dello spazio con malloc devo passargli la quantita' di memoria che mi serve, mentre quando vado a deallocarla con free non serve??

Dipende da com'e` gestito l'allocatore della libreria standard, nel senso che (se non altro per limiti di interfaccia, ormai) l'allocatore non ha bisogno di quell'informazione.

Non poche implementazioni tengono traccia dei blocchi di memoria allocata mediante lista concatenata, all'atto della free() questa lista viene scansionata cercando la corrispondenza tra il puntatore. In questo caso l'informazione della dimensione del blocco e` ridondante.

C'e` una grandissima letteratura in merito, e dato che non sono certo esperto in merito, sebbene l'argomento mi interessi parecchio, non posso che rimandarti alla suddetta per approfondimenti.

Perché al C non costa nulla ricordarsi la dimensione della memoria allocata dinamicamente con malloc?

Non e` che non costa nulla, e` che quell'informazione e` ridondante se fornito alla free(). Almeno nelle implementazioni che ho visto.

Ossia, perche' non optare su una soluzione simile a quella del Pascal, che ti obbliga a dirgli la quantita' di memoria da deallocare??

Scelte dell'implementatore originale, credo :master:

[anx721]

visto che l'informazione è ridondante è meglio non farla specificare al programmatore, perchè

programmatore che gestisce la memoria == bugs nei programmi

[CheCk_OUTSIDE]

Forse non mi sono spiegato correttamente..
quello che mi interessava sapere e' perche' e' stata fatta una scelta del genere?

L'ipotesi di limitare i "danni" direi e' molto buona.. ma pensavo ci fosse qualcosa di piu' formale.

Cmq grazie per l'interessamento!!

Per Ikitt.. dove posso trovare letteratura al riguardo??

Grazie...
CheCk_OuTSidE

[neryo]

Originariamente inviato da anx721
visto che l'informazione è ridondante è meglio non farla specificare al programmatore, perchè

programmatore che gestisce la memoria == bugs nei programmi

quoto....
Chiaramente in programmi di grosse dimensioni nn ci si puo ricordare di tutte le dimensione di tutte le allocazioni... e non sarebbe nemmeno comodo. Questo comporterebbe problemi se il programmatore decidesse di deallocare piu memoria di quanto ne avesse richiesta precedentemente..
Il C comunque alloca sempre di piu di quello che viene richiesto esplicitamente e chiaramente le strutture dati sono complesse perche' richiedono memorizzazione di variabili come anche puntatori visto che non sempre la memoria allocata e' contigua..

[Ikitt]

Originariamente inviato da CheCk_OUTSIDE
quello che mi interessava sapere e' perche' e' stata fatta una scelta del genere?

#define SUPPOSIZIONE_DA_VERIFICARE 1
#ifdef SUPPOSIZIONE_DA_VERIFICARE
Che io sappia, non c'e` molta scelta nell'implementazione di un'allocatore di memoria per blocchi di dimensione variabile. Nel senso, la struttura dati di solito e` una variazione sul tema della lista di elementi, dove ogni elemento memorizza la coppia
indirizzo_base_area, dimensione_area.
Utilizzando questo schema per l'allocatore, al deallocatore non rimane molta liberta` di manovra, nel senso che questo libera tutto il chunk indicato (e allora l'informazione sulla dimensione e` ridondante), oppure ne libera solo una parte. La prima scelta e` quella piu` semplice da gestire, presumo che proprio questa semplicita` abbia influenzato gli stesori della libreria standard del C.
#endif // SUPPOSIZIONE_DA_VERIFICARE

Per Ikitt.. dove posso trovare letteratura al riguardo??

Google e` abbastanza una miniera, anche se la maggior parte della documentazione si sofferma piu` sugli studi delle prestazioni degli allocatori in se piuttosto che sulla teoria su cui, mi pare, non e` che ci sia un'enormita di cui scrivere.
Un esempio di un paio di allocatori (che dovrei studiare meglio, mannaggia ):
http://samba.org/ftp/unpacked/junkcode/talloc/
http://gee.cs.oswego.edu/dl/html/malloc.html

[CheCk_OUTSIDE]

Avevo pensato anch'io ad una motivazione del genere..
Ma vedendo come nel pascal la dimensione di deallocazione fosse a scapito del programmatore, mi sono fatto un paio di domande...
Cmq grazie.. vado ad aumentare la mia cultura sui link che mi hai postato!!

Ciao!!!

[Le0n]

Originariamente inviato da CheCk_OUTSIDE Perche' quando devo allocare dello spazio con malloc devo passargli la quantita' di memoria che mi serve, mentre quando vado a deallocarla con free non serve??

avendo studiato un po di C sarei tentato a dirti che quando allochi memoria con malloc sai già la dimensione che intendi riservare (infatti dal man malloc si nota che la definizione della funzione è "void *malloc(size_t size);" ->funzione che accetta un numero size_t e restituisce un puntatore) mentre la funzione free (sempre dal man si ottiene "void free(void *ptr);" ovvero una funzione che non restituisce nulla e accetta in ingresso un puntatore) serve solo a liberare memoria allocata dal puntatore definito in precedenza...

non dimentichiamoci che i dati allocati possono essere segmentati in più parti (un po come i dati su disco fisso) e quindi se si andassero a liberare manualmente un blocco di memoria contigua si cancellerebbero anche dati che non dovevano fare quella fine (o almeno in quel momento)...non so se ho reso l'idea...

ps se non hai linux e ti vuoi comunque leggere le varie pagine man basta che vai su google e cerchi "man xxx"

Hasta!

[byaur]

Originariamente inviato da Le0n
avendo studiato un po di C sarei tentato a dirti che quando allochi memoria con malloc sai già la dimensione che intendi riservare (infatti dal man malloc si nota che la definizione della funzione è "void *malloc(size_t size);" ->funzione che accetta un numero size_t e restituisce un puntatore) mentre la funzione free (sempre dal man si ottiene "void free(void *ptr);" ovvero una funzione che non restituisce nulla e accetta in ingresso un puntatore) serve solo a liberare memoria allocata dal puntatore definito in precedenza...

non dimentichiamoci che i dati allocati possono essere segmentati in più parti (un po come i dati su disco fisso) e quindi se si andassero a liberare manualmente un blocco di memoria contigua si cancellerebbero anche dati che non dovevano fare quella fine (o almeno in quel momento)...non so se ho reso l'idea...

ps se non hai linux e ti vuoi comunque leggere le varie pagine man basta che vai su google e cerchi "man xxx"

Hasta!

si osservazioni giuste, sia quella che free accetta un puntatore e sia, che è la conseguenza di questo, il discorso dopo. è naturale l'allocatore prenda la dimensione e quindi allochi uno spazio di memoria atto a contenere i giusti dati. questa allocazione può anche essere "frammentata" e quindi sarebbe rischioso fare la free con la dimensione del blocco da deallocare-> si potrebbero andare a intaccare zone di memoria che non riguardano questo processo...

ciao