Newsgroup: it.comp.lang.c
Titolo: domanda sul casting di puntatori

Salve,
ho riscontrato un comportamento che non riesco a spiegarmi quando invoco
una funzione che ha come parametri dei puntatori di un certo
tipo,facendo il casting su un altro tipo.
Nel mio caso,ho definito 2 struct,che hanno entrambe un campo next che
e' un puntatore ad una struct del medisimo tipo.
La funzione,modellata per funzionare colla struct piu'
piccola,semplicemente concatena due struct.
Se invocata senza casting,la funzione f fa effettivamente il suo
dovere,ma il compilatore genera un warning;se inserisco un cast,come
mostrato nel codice,non funziona piu' nulla perche' in p2 (parametro
attuale) viene messo un indirizzo diverso da quello voluto,mentre (!!!)
in p1 continua ad esserci quello giusto.
Come mai un casting va a modificare il valore di una variabile?
Non dovrebbe influenzare solo la dereferenziazzione?
Il breve codice e' il seguente:
--------------------------------------
#include <stdio.h>
typedef struct OBJ{
struct OBJ *next;
int value;
} obj;
typedef struct ST1{
struct ST1 *next;
}st1;
void f(st1 *p1,st1 *p2);
main(void){
        int k;
        obj arr[10];
        arr->value=0;
        (arr+1)->value=1;
        printf("Valore arr: %x\n",arr);
        printf("Valore arr+1: %x\n",arr+1);
        f(arr,arr+1); 	/* f((st1 *)arr,(st1 *)arr+1);*/
        k=arr->next->value;
	puts("Le 2 variabili dovrebbero avere lo stesso valore:");
        printf("%d\n",k);
        printf("%d\n",arr[1].value);
}
void f(st1 *p1,st1 *p2){
        p1->next=p2;
        printf("Valore p1: %x\n",p1);
        printf("Valore p2: %x\n",p2);
}             
------------------------------------
-- 
**************************************
Duke Of Hell - Lord Of Chaos
Computer Science Undergraduate Student
http://www.cs.unibo.it/~tasso
**************************************

 wrote:
[ snip ]
CT>Se invocata senza casting,la funzione f fa effettivamente il suo
CT>dovere,ma il compilatore genera un warning;se inserisco un cast,come
CT>mostrato nel codice,non funziona piu' nulla perche' in p2 (parametro
CT>attuale) viene messo un indirizzo diverso da quello voluto,mentre (!!!)
CT>in p1 continua ad esserci quello giusto.
Hai scritto male il cast: avresti dovuto usare
	f((st1 *)arr, (st1 *)(arr+1));
[ snip ]
CT>        printf("Valore arr: %x\n",arr);
Qui e nel seguito avresti dovuto usare '%p' per stampare il
valore del puntatore.
[ snip ]
CT>        printf("%d\n",arr[1].value);
	   return 0;
CT>}
Ciao ciao,
Andrea
-- 
"...Unix, MS-DOS, and Windows NT (also known as the Good, the Bad, and 
 the Ugly)."
(by Matt Welsh)

Come mai un casting va a modificare il valore di una variabile?
Quale compilatore utilizzi ?
Con il DJGPP l'output del programma che segue e' questo :
(nota che ho cambiato i %x dei printf() in %p)
Valore arr: 1b9f8c
Valore arr+1: 1b9f94
Valore p1: 1b9f8c
Valore p2: 1b9f94
Le 2 variabili dovrebbero avere lo stesso valore:
1
1
---------------------------------------------------------
#include <stdio.h>
typedef struct OBJ{
                     struct OBJ *next ;
                     int value ;
} obj ;
typedef struct ST1 {
                     struct ST1 *next ;
} st1 ;
void f ( st1 *p1, st1 *p2 ) ;
int main( void ){
        int k ;
        obj arr[10] ;
        arr->value = 0 ;
        (arr+1)->value = 1 ;
        printf ( "Valore arr: %p\n", arr ) ;
        printf ( "Valore arr+1: %p\n", arr+1 ) ;
        f ( (st1*) arr, (st1*) (arr+1) ) ;
        k = arr->next->value ;
	puts ( "Le 2 variabili dovrebbero avere lo stesso valore:" ) ;
        printf ( "%d\n", k ) ;
        printf ( "%d\n", arr[1].value ) ;
        return 0 ;
}
void f( st1 *p1, st1 *p2){
        p1->next = p2 ;
        printf( "Valore p1: %p\n", p1 ) ;
        printf( "Valore p2: %p\n", p2 ) ;
}             
--
Andrea Laforgia        (
andrea_...@bigfoot.com
)

 Non dovrebbe influenzare solo la dereferenziazzione?.........
Ti informo che il casting non influenza solo la dereferenziazione,"comoda a volte a
togliere delle warning", ma ha il compito di trasformare un tipo di dato in un
altro. f     (     (st1 *)arr,    (st1 *)arr+1    ); e' ben diverso da
 f     (     (st1 *)arr,    (st1 *)(arr+1)    );
(st1 *)arr+1        =    arr castato a (st1 *) +1    =    arr+sizef(st1)
(st1 *)(arr+1)     =     (arr +1) castato a (st1 *) =    (arr+sizeof(arr)) castato a
(st1 *)
Ciao.
--
Posted from 
mta01-acc.tin.it
 [212.216.176.32]
via Mailgate.ORG Server - 
http://www.mailgate.org