Newsgroup: it.comp.lang.c
Titolo: Puntatori a strutture

Ciao a tutti,
mi e' venuta in mente una curiosita' ma prima di perdere ore in debugging 
volevo capire se sto pensando una stupidata.
Ho due strutture dati (struct) identiche che per motivi logici hanno nomi 
diverse.
In una procedura devo utilizzare funzioni sui campi delle strutture nella 
stessa sequenza indipendemente che siano di una o dell'altra struttura.
Per non duplicare il tutto mi chiedevo se posso usare un puntatore voi con 
cast dinamico.
Mi spiego con un esempio in pseudo codice che forse e' meglio.
struct a{
  char *dati;
}
struct b{
  char *dati;
}
void *p;
if(a)
  (struct a *) p=puntatore alla struttura a in uso
else
  (struct b *) p=puntatore alla struttura b in uso
faiqualcosa(p->dati)
Si puo' fare?
Grazie
-- 
 ************** (.)_(.)  **************
 Un amico è uno che sa tutto di te e,
 nonostante questo, gli piaci
(E. Hobbard) 

 Grazie
typedef struct{
   char* dati;
} tipo_fuffa;
tipo_fuffa a,b;
tipo_fuffa* pointer_fuffa;
if(a) //vabbe' qui devi poi mettere qualcosa di sensato
{
   pointer_fuffa = &a;
}
else
{
   pointer_fuffa = &b;
}
oppure ho capito male io?
cmq questo:
(struct a *) p=puntatore alla struttura a in uso;
non credo si possa fare, se proprio (ma non sono sicuro che funzioni,
a me il void* fa venire l'orticaria ;) ):
  p = (void *)&a;
Ciao Jack

Ciao Jack
Ciao e grazie


 sto usando.
non si puo' fare neanche questo perche' essendo un tipo void non conosce 
piu' gli elementi della struttura a cui puntava e quindi non posso 
richiamare p->dati
Uff, mi tocca duplicare righe :-)
Ciao



ciao,
non sono sicuro di avere capito cosa ti serve e ho pochissimo tempo 
(ergo non posso leggere attentamente).
Ti posto solo un piccolo codice che (spero) ti possa aiutare.
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
         struct a {
                 char *dati;
         };
         struct b {
                 char *dati;
         };
         void *ptr;
         struct a var_a;
         struct b var_b;
         var_a.dati = calloc(10, sizeof(char));
         sprintf(var_a.dati, "ciao A");
         var_b.dati = calloc(10, sizeof(char));
         sprintf(var_b.dati, "ciao B");
         printf("a: %s\nb: %s\n", var_a.dati, var_b.dati);
         ptr = &var_a;
         printf("ptr: %s\n", ((struct a *)ptr)->dati);
         ptr = &var_b;
         printf("ptr: %s\n", ((struct b *)ptr)->dati);
	return 0;
}
ciao
riki

 Si puo' fare?
Sì, come ti ho descritto sopra.
Secondo me la cosa migliore è eliminare una struttura ed usare solo
l'altra. Se vuoi mantenere la differenza "logica" puoi usare i
typedefs:
struct a {
};
typedef struct a tipo1;
typedef struct a tipo2;
in questo modo le funzioni prenderanno tipo1 o tipo2, ma useranno
sempre la stessa struttura: se un giorno decirai di differenziare le
due, basterà cambiare il typedef.
Ciao!

 riki
hai scritto lo stesso programma di test che ho fatto io per vedere se si 
poteva fare ma non ho pensato al cast sul printf :-(


typedef struct a tipo2;
Non posso farlo a costo zero ma a questa soluzione non avevo pensato. Mi 
piace.
Ciao
-- 
 ************** (.)_(.)  **************
 Un amico č uno che sa tutto di te e,


 ma te lo sconsiglio vivamente per motivi che certamente immagini.
Io non li immagino, quali?

 Io non li immagino, quali?
beh, vari... il primo (che mi è venuto in mente) e più ovvio è che
quando andrai finalmente a cambiare la struttura i codice sarà
magicamente "rotto" pur essendo formalmente corretto ;-) E quando hai
un programma non funzionante che il compilatore accetta è molto più
difficile andare a pescare gli "errori".
In realtà personalmente come regola di base ho quella che mi diede un
mio vecchio capo: "se c'è un cast esplicito è già sbagliato" :-)
Probabilmente lui proveniva da linguaggi fortemente tipizzati (ADA?) e
ovviamente non è possibile eliminare tutti i cast da un programma C,
ma il loro abuso è sicuramente controproducente... io li vedo molto
come un modo di dire al compilatore "hey tranquillo, so quel che
faccio!", ma mentre il compilatore si comporta sempre nello stesso
modo (si spera), le idee delle persone cambiano, e in quel momento
avere uno strumento che ti segnali le incongruenze risparmia ore di
fatica dura.
Per esempio col metodo dei typedef è facile andare a pescare le
funzioni che vogliono la nuova struttura come parametro ed isolarle.
Ciao!