[Tech] Ancora non va :(

[Franco Bagnoli]

On Wed, 9 Jun 2004, Valerio Montagnani wrote:

> On Wed, 9 Jun 2004 13:27:23 +0200 (CEST)
> "Marco Ermini" <markoer@markoer.org> wrote:
> 
> > 
> > Valerio, hai presente che lo star (*) significa cose diverse se lo usi per
> > dichiarare una variabile o per indicare il valore puntato da un puntatore
> > giusto?
> > 
> 
> A questo punto credo di aver confuso anche il mio nome:
> 
> * a una variabile mi restituisce il valore contenuto in quella cella di memoria
> * al valore puntato da un puntatore restituisce il valore contenuto nella variabile a cui punta la variabile puntata dal secondo puntatore:
> 
> *a contiene 4
> 
> *b che punta *a mi rende 4. 
> 

diciamo: 

int a; /* traduzione: è intero quello che sta nella 'cella' chiamata 'a' 
*/

a=4;  /*a contiene 4*/ 

Ricorda che la memoria è vista come un grande nastro. 'a' è una maniera di 
indicare simbolicamente un indirizzo di memoria. al momento della 
compilazione (nei vecchissimi sistemi tipo dos) o al momento di partire al 
posto di 'a verrà usata una locazione di memoria, diciamo 12345. Nelle 
locazioni  12345, 12346, 12347, 12348 (in int è 4 byte 
normalmente) 
il programma scrive '4'

int * b; /* trad: è intero quello che è contenuto nella cella il cui 
indirizzo sta nella 'cella' chiamata 'b' */ 

al posto di 'b' verrà sostituito diciamo 3452. 

b = &a;  /* se ora stampo *b ottengo 4 */

in 3452, 3453, 3454, 3455 viene scritto '12345' (l'insirizzo di a)

a=5; /*  se ora stampo *b ottengo 5 */

int *c; 

diciamo che 'c' è 3422

c = (int *) malloc(10*sizeof(int));

quando il processore incontra questa istruzione, riserva da qualche parte 
10 int, diciamo 6600--6640 (40 bytes), e mette 6600 nelle 4 celle a 
partire da c (3422--3425)

c[0] = 1; 

il programma traduce in: *(c+0)=1, quindi *(6600)=1 e scrive 1 in 
6600-6603

c[5] =2

il programma traduce in: *(c+5)=1, quindi *(6620)=1 e scrive 1 in 
6600-6603. Nota che ha sommato 20 e non 5, perché lui sa, grazie alla 
dichiarazione, che c è un puntatore a int, quindi ogni volta che deve 
incrementare c somma 4. 

int ** c; /* è intero quello che è puntato da ciò che è puntato da c */

c = (int **) malloc(5*sizeof(int*));
for (i=0; i<5; i++) {
	c[i] = (int *) malloc(10*sizeof(int));
}

c contiene l'indirizzo di una zona di memoria in cui (nei 20 byte 
successivi) ci sono 5 numeri. Ognuno di 
questi viene interpretato come l'indirizzo di un'altra locazione di 
memoria in cui, nei 40 bytes seguenti, ci staranno 10 int. 

e così via.

Oppure 

c = (int *) malloc (50*sizeof(int));

c contiene l'indirizzo di una zona di memoria in cui, nei 200 byte 
successivi, ci staranno 50 int, a te vederli come una matrice.

Questo si può fare anche a più dimensioni, 

c[x][y][z] (int *** c)

oppure 

c[(x*nx+y)*ny+z] (int *c)

(normalmente in C si scrivono gli indici alla rovescia: 

c[z][y][x]

)







-- 
Franco Bagnoli (franchino) <bagnoli@dma.unifi.it> 
virtual location: Dipartimento di Energetica "S. Stecco"
ultra-virtual affiliation: Centro Dinamiche Complesse (CSDC-Firenze)
real location: Dip. Matematica Applicata "G. Sansone", Universita' Firenze,
Via S. Marta, 3 I-50139 Firenze, Italy. Tel. +39 0554796422, fax: +39 055471787