Newsgroup: it.comp.lang.c
Titolo: [Forse-OT] Indirizzi di memoria per gli array

Non so se questo thread possa essere OT e me ne scuso da ora nel caso lo
sia.
Studiando gli array ho notato che il compilatore riserva (è il compilatore
che riserva aree di memoria e indirizzi, giusto?) delle aree di memoria
contigue agli elementi di un array (e.g., array[0] = 0xbffff670, array[1] =
0xbffff671, array[2] = 0xbffff672, ecc...).
Dichiarando più array di, per esempio, 3 elementi ciascuno, vengono
riservate 3 aree di memoria contigue e poi, per riservare memoria per
l'array successivo, si verifica un salto all'indietro di dieci
indirizzi dall'indirizzo del primo elemento dell'array precedente. Così:
array1[0] = 0xbffff670
array1[1] = 0xbffff671
array1[2] = 0xbffff672
array2[0] = 0xbffff660
array2[1] = 0xbffff661
array2[2] = 0xbffff662
array3[0] = 0xbffff650
array3[1] = 0xbffff651
array3[2] = 0xbffff652
C'è un motivo per cui vengono assegnati gli indirizzi in questo modo?
Perchè vengono assegnati agli array in ordine discendente (70-60-50-...)?
Sono stato molto chiaro a spiegarlo, ma spero che con l'esempio si sia
capito cosa intendo.

> Sono stato molto chiaro a spiegarlo, 
Volevo dire che NON sono stato chiaro... :)

 ---MEGACUT---
   .~.      xin\@IRCNet (mostly xin\aWAy 24/7 ghgh)
   /V\      Email: NOSPAM!
  // \\     Anemir,Alarik,Marty,Araon,Balimir@ClessidraMUD - CdL -
 /(   )\    ICQ UIN: 63088554
  ^`~'^     "Somewhere inside my childhood witnessed my heart die" -
2Pac
-- 
/"\   
\ /    ASCII Ribbon Campaign
 \     Against HTML Mail and News
/ \  
--
"A coward dies a thousand deaths a soldier dies but once..." - 2Pac

> Last In First Out
Ridotto all'osso... :) Ma è quanto basta. Grazie per il chiarimento, vado 
subito a documentarmi al riguardo!

Perchè se nel codice scrivo:
char variabile1;
int variabile2;
printf("variabile 1 = %p\n", variabile1);
printf("&variabile 1 = %p\n\n", &variabile1);
printf("variabile 2 = %p\n", variabile2);
printf("&variabile 2 = %p\n\n", &variabile2);
mi da il seguente output?
variabile 1 = 0x8
&variabile 1 = 0xbffff67f
variabile 2 = 0xbffff688
&variabile 2 = 0xbffff678
Probabilmente non ho ben capito che funzione ha & in questo contesto (o
forse non l'ho capito e basta, qualunque sia il contesto :) ). Soprattutto
perchè variabile1 ha come indirizzo 0x8 mentre tutte le altre no?

 &variabile 2 = 0xbffff678
Indirizzo di memoria in cui e' allocata la variabile "variabile2"
Era questo che ti serviva?
Ciao,
Ema

 Indirizzo di memoria in cui e' allocata la variabile "variabile2"
Perchè è come se fossero due variabili distinte? L'indirizzo di memoria in
cui è allocata la variabile è in 0xbffff678 mentre il valore contenuto
dalla variabile è 0xbffff688? Mi sembra strano. Probabilmente questo
"perchè" è dovuto a una mia ignoranza per quanto riguarda l'operatore &.

 "perchè" è dovuto a una mia ignoranza per quanto riguarda l'operatore &.
Non sono due variabili distinte. Semplicemente la variabile2 contiene 
SPAZZATURA. quindi stamparla con %p equivale a stampare il suo contenuto 
in esadecimale... ne più ne meno. &variabile2 invece è il puntatore di 
variabile2.
Posso fare delle ipotesi...
Stai allocando le variabili sullo stack, e questo spiega gli indirizzi 
decrescenti, magari prima di allocare variabile2, il tuo codice aveva 
posto e poi rimosso un valore temporaneo che per puro "culo" era un 
indirizzo. Quando hai allocato variabile2, è stato semplicemente preso 
un intero sulla cima dello stack, ma non è stato INIZIALIZZATO, quindi 
ti sei ritrovato qualcosa che in un precedente momento era un indirizzo. 
Se cambi compilatore od opzioni di compilazione, magari avrai risultati 
diversi! Però devi assumere che UNA VARIABILE NON INIZIALIZZATA CONTIENE 
UN VALORE SPAZZATURA. NON DEVI FARE IPOTESI SUL CONTENUTO.
Ok
Ciao

 gli zeri iniziali.
Faccio ancora un pò di confusione. La variabile1 non l'ho inizializzata. 
Se ho capito bene da quello che hai scritto dopo, non essendo stata
inizializzata, la variabile1 contiene un valore "spazzatura", per cui qui
mi è capitato che contenesse un 8, ma può contenere qualsiasi altra cosa
"a discrezione del compilatore". E' giusto?

 "a discrezione del compilatore". E' giusto?
Yep!
g.

 g.
olèèèè!!!! :)
Grazie dei chiarimenti

 capito cosa intendo.
é dovuto al funzionamento dello schema interno di un processo...
ad ogni processo č associata un'area dati e un'area stack
ora cerco di fare un disegnino di un processo in memoria, spero si
capisca...
|----------|
|    stack   |   <----- l'area stack cresce verso il basso
|               |
|----------|
|               |
|   vuoto   |    <----- questo spazio č destinato a contenere stack e dati
|               |
|----------|
|               |    <----- l'area dati cresce verso l'alto
|   dati       |
|----------|
|codice     |
|----------|
ora dato che stack puň crescere solo verso il basso, e dato che tutte le
volte che dichiari un array questo va a finire nell'area stack il passo č
semplice...
mettiamo che la fine dell'area stack sia nella posizione 1000, dichiaro un
array che occupa lo spazio da 990 a 1000, quindi inizia in pos 990, il
successivo inizia in 980 e cosě via...
spero di essere stato chiaro :)
Ciao