Newsgroup: it.comp.lang.c
Titolo: Newbie e allocazione di memoria

Salve,
sono un newbie proprio all'inizio, ho una domanda banale da porvi:
come mai bisogna allocare la memoria e liberarla quando ne abbiamo fatto
uso?
Ovvero, come mai considerando che oggi giorno abbiamo centinaia di Mb a
disposizione
dobbiamo ancora pensare all'allocazione della memoria?
E' per prevenire eventuali errori di programmazione?
Meglio ottimizzare la memoria e sapere l'uso che se ne fà?
Non insultatemi ma non avendo fatto nessuna scuola di programmazione ma solo
iniziato a studiare
dei libri sul C, non viene spiegato molto questa cosa....almeno per quanto
ho letto.
Se avete dei link che spiegano il tutto, gradisco cosi' mi faccio un po' di
cultura....
Scusate l'ignoranza e grazie.

 Non insultatemi
E perche' mai dovrei? ;)
Ciao e buono studio.
Marcello

 riesca a trovare sufficiente spazio, senza occuparne troppo.
Non è propriamente così.  L'allocazione dinamica è un'operazione di
dialogo con il sistema operativo, non con il compilatore.  Questo
significa che non viene predisposto *nulla*, a priori.  E' il motivo
per cui un'operazione con malloc() può anche fallire, ovvero non
riuscire a trovare sufficiente memoria disponibile per "allocare"
l'oggetto.
Ovviamente, i casi in cui malloc() fallisce vengono raramente
riscontrati nella pratica, perché sicuramente prima di arrivare ad
avere memoria insufficiente per una allocazione, il sistema avrà
cominciato a strisciare come una lumaca e qualcuno, probabilmente,
l'avrà già riavviato.

 che produce.
Se volessi spiegare meglio questo punto... Quello che dici non mi e'
chiaro.
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 
Nessun problema. Tutti sono ignoranti prima di imparare.
-- 
                Roberto Nunnari -software engineer-
                     mailto:
ro...@nunnisoft.ch
 
http://www.nunnisoft.ch
   Residenza Boschetto 12           tel/fax: 
+41-91-6046511
   6935 Bosco Luganese        """    mobile: 
+41-76-3208561
   Switzerland               (o o)
========================oOO==(_)==OOo========================

 chiaro.
AFAIK, la continua allocazione e liberazione della memoria produce una 
eccessiva deframmentazione della stessa.
Viste le enormi capacita' delle attuali memorie, diventa preferibile 
conoscere in anticipo l'ammontare dello spazio massimo che occupera' una 
certa applicazione (quando e' possibile, ovvio) e riservarglielo, 
piuttosto che subire le conseguenze di una eccessiva deframmentazione 
della memoria.
Marcello

 che produce.
Marcello, credo tu abbia molta confusione....
- L'allocazione dinamica non dice nulla al compilatore, il fatto che sia
dinamica (run-time) significa che il compilatore ha gia' fatto il suo
lavoro...e' tardi per tirarlo in ballo!
- L'allocazione "indica" solo quanta memoria "verra'" utilizzata... fa un
pochini di piu' ;-)
- La liberazione mi auguro non stia diventando piu' rara... spero ti stia
riferendo al garbage collection che e' pero' un discorso a parte.
- Sempre meno conveniente? Ancora una volta spero tu ti stia riferendo al
garbage collection. Per la frammetazione dipende tutto dal "memory
management system".
Scusa se approfondisco poco ma il discorso che mi hai portato a fare e'
quasi OT.
Tommy

Tommy wrote:
Ho gia' risposto a Angelo Paolitto ammettendo l'errore.
:(
Per quanto riguarda la questione ai limiti dell'OT, probabilmente, 
sapevo male. Mi informero' meglio.
Marcello

 eccessiva deframmentazione della stessa.
s/deframmentazione/frammentazione/ ;)
Quello che dici e` teoricamente corretto  ma, in pratica, il problema si
pone solo in  casi molto "limite" come, ad esempio,  la programmazione a
livello di kernel o in assenza di memoria virtuale.
malloc/free  sono  delle  astrazioni  che  permettono  al  programmatore
di  ignorare  i  dettagli dell'architettura  sottostante  (come  appunto
l'eventuale frammentazione della memoria) ed  e` quindi meglio usarli in
maniera "naturale", usando una  chiamata per ogni allocazione. Considera
questi spezzoni di codice:
struct foo {
        ...
};
struct bar {
        ...
};
struct foo *f;
struct bar *b;
/* esempio 1 */
f = malloc(sizeof(struct foo) + sizeof(struct bar));
if (!f)
        whine("Peecee on fire!\n");
b = (struct bar *)(f + 1);
...
free(f);
/* esempio 2 */
f = malloc(sizeof(struct foo));
...
b = malloc(sizeof(struct bar));
...
free(b);
free(f);
Quale dei  due risulta piu`  chiaro? Ad una lettura superficiale  non e`
affatto chiaro che b sia  allocata dinamicamente e potrebbe sembrare che
non venga  liberata. L'allocazione unica non  e` sbagliata [1]  in senso
assoluto,  ma  il  secondo  esempio e`  (IMNSHO)  piu`  leggibile,  piu`
mantenibile e meno error-prone.
Kronos
[1] L'allocazione in  un unico colpo di una struttura  dati ed eventuali
strutture ad essa  correlate e` molto frequente a livello  di kernel (lo
faccio anch'io),  ma in  questo caso  la scelta  e` motivata  da *reali*
problemi di frammentazione e prestazioni.
-- 
Home: 
http://kronoz.cjb.net
"Di tutte le perversioni sessuali, la castita` e` la piu` strana".
Anatole France

 :(
scusa, ho letto quel post solo dopo aver risposto.
Tommy

Tommy wrote:

Di nulla Tommy.
Cmq l'osservazione ci stava tutta.
Ho detto veramente una gran cavolata.
:(
Marcello

 problemi di frammentazione e prestazioni.
Capito.
Thanks.
Marcello