Newsgroup: it.comp.lang.c
Titolo: puntatori e allocazione memoria

Scrivendo
int *pi;
pi = (int*) malloc (2*sizeof (int));
i 2*4 byte dove vengono allocati? Mi spiego:
con int *pi ottengo una variabile con indirizzo del tipo -1073743432
(perchè quel meno poi?). Quando alloco memoria, come  fa il
compilatore a rendermeli disponibili? Forse sceglie locazioni di
memoria libere per 2*4 byte, diciamo di indirizzi 10243464 e 10243468,
prende questi indirizzi e fa in modo che attraverso *pi e *(pi+1)
puntino a queste, in modo che possa utilizzarle? 
Poi ancora, perchè con &pi ottengo l'indirizzo sopra detto e con &pi+1
ottengo -1073743428, cioè mi accorgo che alloca memoria
*all'indietro*? No so se qualcuno possa saperlo...Dicendo una
stupdaggine, per caso quella quantità di byte sono stati per così dire
riservati per essere allocati mano mano al puntatore, se ve ne fosse
necessità?
Saluti,
Giovanni.

compilatore a rendermeli disponibili? 
Non e' il compilatore ad allocare memoria, ma il sistema
operativo.  malloc() si limita a richiamare l'API del
sistema operativo per l'allocazione di memoria (sotto
Windows, per esempio, VirtualAlloc) e, quindi, si affida
alla gestione della memoria HEAP del sistema operativo.
Il numero negativo dipende dal fatto che stai visualizzando
un numero troppo grande per essere contenuto in un intero
(sotto Windows, un puntatore puo' andare da 0x00000000 a
0xFFFFFFFF).
--
Andrea Laforgia - walkietalkie(at)
libero.it
http://www.geocities.com/AndreaLaforgia

0xFFFFFFFF).
Ho capito, ti ringrazio.
Saluti,
Giovanni.

Ma quello pseudo ragionamento che avanzavo era lontanamente corretto?
Precisato che e' il sistema operativo che alloca memoria e
non il compilatore, il principio seguito dal s.o. puo' anche
essere molto semplice.
Il sistema stabilisce, cioe', che una certa porzione di
memoria piu' o meno grande e' destinata all'allocazione da
parte dei programmi (la cosiddetta memoria heap) e quindi
fornisce al programma la quantita' di memoria richiesta
marcandola come occupata.
Prosegue cosi' fino all'esaurimento della stessa (nel qual
caso malloc() restituisce NULL).
Per esempio, supponi che il sistema operativo abbia deciso
di destinare la memoria che va dall'indirizzo 0x00001000
all'indirizzo 0x0000FFFF all'allocazione di memoria da parte
dei programmi (e' quindi la memoria HEAP del sistema).
Se un programma compie una malloc() chiedendo 100 byte, il
sistema occupera' la porzione di memoria da 0x00001000 a
0x00001063 e restituira' come risultato di malloc() il
valore 0x00001000 (ovvero l'indirizzo della prima
locazione).
Se il programma compie una seconda malloc() chiedendo 1000
byte, il sistema occupera' la porzione di memoria da
0x00001064 a 0x00008291 e restituira' come risultato di
malloc() il valore 0x00001064, ecc... ecc...


 ha scritto nel messaggio
news:3ba4dd8...@news.tin.it...


 ha scritto nel
messaggio news:9o5ebr$m4c$1...@lacerta.tiscalinet.it...

Mi scuso per il messaggio inviato per errore e vengo al
dunque: perché usi &pi? pi contiene già un indirizzo,
l'indirizzo di una coppia di int nel tuo caso; se tu usi
pi+1 ottieni un puntatore al secondo int; se tu usi &pi
ottieni un puntatore a pi che a sua volta è un puntatore a
un int; &pi+1 significa "ottieni un puntatore al puntatore
posto dopo pi", cioè significa "dammi l'indirizzo di pi (non
quello contenuto in pi!) e aumentalo di 4(un puntatore
occupa 4 byte quando si è a 32 bit, come nel tuo caso)".
--
Paolo Giarrusso

perché usi &pi? 
Perchč, come spiegato nel post, cercavo di capire come mi venvano rese
disponibili le locazioni di memoria, in che ordine e secondo quali
criteri.
Saluti,
Giovanni.