puntatori e array..argh!!

[r0x]

Bah, a me non fotte nulla di ciò che dicono i prof., e soprattutto quelli di informatica (a parte RARISSIMI casi).. Premetto che io qui sto dando una mia opinione e magari mi sbaglio, ma datemi motivazioni valide per contraddirmi..

La memoria statica è quella alla quale contribuiscono le variabili GLOBALI non allocate con malloc() o simili, perché vengono inserite nel segmento dati (accezione forse un po' obsoleta) del programma, e non può essere allocata/deallocata.

Se solo alcune persone (non generalizzo affatto) invece che dire "il prof. ha detto" si curassero di applicare un po' di teoria alla pratica, capendo cosa sia uno stack invece di fare solo gli esercizietti "aggiungi un elemento allo stack", "inverti le posizioni dello stack" tipici dei corsi universitari (ne so qualcosa), forse si accorgerebbero che lo stack non è una risorsa statica. Tanto per fare un paragone *vicino*.. secondo voi una linked list è una risorsa statica? Ecco, lo stack fondamentalmente è identico ad una linked list, solo che cambiano le modalità di inserimento/deinserimento degli elementi, nient'altro. Come fa, quindi, ad essere statico?

L'heap è diverso dallo stack perché è meglio che ci sia un preciso "memory manager" che si occupi di allocarne/deallocarne la memoria. E questo perché l'heap è una memoria caotica, sparsa, che non segue un preciso criterio nell'allocazione/deallocazione dei blocchi. Ma cosa cambia? Cambia solo che non c'è un meccanismo trasparente come push/pop ma ci saranno le funzioni di libreria malloc()/free(), o se volete gli operatori new/delete, che si curano di allocare la memoria solamente se non utilizzata e integra (e anche di molti altri aspetti). Ma l'uso è lo stesso.

Altro punto: come fate a dire che lo stack è memoria statica se viene usato per allocare le variabili locali delle funzioni??? Ma sapete quanti push/pop il vostro programma esegue per ogni fottuta chiamata di funzione??? Non penso che una memoria statica sia in grado di fare ciò..

Cmq meglio il solito schemino esemplificativo:

int globale; // allocata nel segmento dati
int* heap1 = new int; // allocata sull'heap

void funzione()
{
	int locale; // allocata su uno stack locale (enter)

	{
		int piuLocale; // allocata su uno stack locale (enter)
	} // 'piuLocale' qui viene deallocata insieme allo stack locale

	int* heap2 = new int; // allocata sull'heap, come heap1
} // 'locale' qui viene deallocata insieme allo stack locale

// 'heap1' ed 'heap2' non vengono deallocate automaticamente

Più chiaro di così..

E ora ditemi la vostra, e non "tizio dice", "caio m'ha detto".. :tongue:

Ciao.

N.B.: un'infarinatura di assembly non vi farebbe male, ma non parlo con ChReAn perché lui penso sia molto più preparato di me.. :tongue:

[afurly]

Valium caro,
io ho solo scritto una cosa per contribuire alla discussione,
ho dato parecchi esami e i libri dicevano così,
poi se sbagliavano non lo so................

comunque stai calmo............

[r0x]

No ma io sto calmissimo, il fatto è che avevo dovuto togliere le faccine perché non mi mandava il post, quindi le ho tolte tutte e pareva un post sostenuto.. Il punto è che il tuo post scritto così com'è non è un gran contributo alla discussione..

[zorz]

..non volevo creare una guerra..ce ne sono già troppe in giro ,però a questo punto vorrei, visto che siamo su un forum e visto che in esso sono presenti dei moderatori, la risposta..:dhò
ok con r0x per lo schema..ma credo che il termine 'statica',usato nei libri e anche sul sito stesso di HTML, sta ad indicare che la memoria allocata non può essere deallocata, mentre quella dinamica sì.. :quipy:
ciao, Zorz

[r0x]

Precisiamo: io mi riferisco alla visione dello stack da parte di un programma, la staticita` di uno stack al limite puo` riguardare la dimensione allocata dall`OS per il processo, che e` fissa.

La deallocazione da uno stack e` l`operazione pop, ed e` una procedura lineare che sposta sp (stack pointer, parlo di x86) di 2 bytes (o esp di 4)

La deallocazione dall`heap e` in genere piu` complessa, perche` si deve preoccupare di informare il sistema che la memoria allocata in precedenza puo` invece ricominciare ad essere utilizzata per altri scopi. In genere se ne occupa il sistema operativo.

Deallocare non significa eliminare memoria, s`intenda.

Inoltre ti ripeto che tutte le variabili locali allocate (push) sullo stack vengono deallocate all`uscita di una funzione o di un blocco (pop).

Solo le variabili globali non posso essere deallocate fino alla fine del programma, perche` infatti non sono allocate sullo stack, ma lo stack di per se` e` una risorsa dinamica, in quanto cambia continuamente il suo stato.

..