Newsgroup: it.comp.lang.c
Titolo: Come inizializzare una union?

Devo inizializzare una union globale del tipo:
union u {
   tipo1 x;
   tipo2 y;
};
Se inizializzo una union u con una costante di tipo1 in questo modo:
union u u_mia = { cost_di_tipo1 };
non ci sono problemi.
Ma se invece scrivessi:
union u u_mia = { cost_di_tipo2 };
nel migliore dei casi con il compilatore del DJGPP ottengo un warning (tipo
incompatibile
nell'inizializzazione) oppure un errore (inizializzazione non valida) a
seconda dei tipi assegnati alla union (SIC!).
Dov'e' l'errore? E in ogni caso qual'e' la forma standard utilizzata per
inizializzare una union (in tutti i manuali del C che ho consultato non
c'era accenno al problema)?
Ciao e grazie a tutti per l'attenzione.

};
Hai provato a fare union u.x = valore_di_tipo_1; ?
Occhio che nella union condividi lo stesso spazio sia per x che per y,
quindi se inizializzi x a un valore e poi leggi y in y troverai il
valore di x (probabilmente distorto se x e y non erano dello stesso
tipo).
Mox

 Hai provato a fare union u.x = valore_di_tipo_1; ?
Provai...provai...ottengo  "Error: parse error before '.' token."
D'altronde se pensi alla analogia tra struct e union ti rendi conto che una
scrittura del genere e'abbastanza contradditoria: non puoi inizializzare un
elemento di una struct se non hai prima almeno dichiarato la struct stessa.
Comunque inizio a pensare che il problema sia del compilatore.
Ho compilato senza ottenere errori ne' warnings:
union union_mia {
   char s[8];
   int x;
};
union union_mia u = { "ciao" };
( e non ottengo errori ne' warnings anche con  union union_mia u = { 12 }; )
Se invece inverto le due righe della dichiarazione della union
union union_mia {
     int x;
     char s[8];
 };
union union u_mia u = { "ciao"}
da' un warning in compilazione ( "inizialization makes integer from pointer
without a cast.")... boh!:-<
Vorra' dire che mi terro' i warnings...

 ha scritto nel
messaggio news:a43417$a60$1...@pegasus.tiscalinet.it...

Come era ovvio, chi ti ha risposto ha fatto un piccolo
errore: dopo
 union u {/*...*/};
il codice corretto era:
 union u istanzaDiU.x=valore_tipo_1;
o forse
 union u istanzaDiU;
 istanzaDiU.x=valore_tipo_1;
č evidente che non puoi assegnare a un membro di u un
valore, essendo u un tipo.
in realtŕ nel C99 e anche in gcc, e quindi in DJGPP, esiste
il costrutto
 union u istanzaDiU= {.x=valore_tipo_1};
cercandolo nella guida non l'ho trovato, e forse mi sbaglio,
ma prova; ho trovato questo:
struct foo {int a; char b[2];} structure;
structure = ((struct foo) {x + y, 'a', 0});
Per trovarlo, avvia info.exe e scegliendo gcc->C
Extensions->Constructor Expressions
nota successiva: ho trovato quello che ti dicevo, detto
"Labeled Elements in Initializers"(sempre con info su C
Extensions):
struct point { int x, y; };
 struct point p = { .y = yvalue, .x = xvalue };
//riconosciuto in C99
esiste anche
 struct point p = { y: yvalue, x: xvalue };
ma questa sintassi non č stata inserita nel C99, cosě meglio
non usarla, dato che equivale a quella di sopra.
Viene anche detto chiaramente che entrambe le sintassi sono
adatte anche alle union.
Altra sintassi di GCC/DJGPP, non C99, č questa:
union foo { int i; double d; };
int x;
double y;
union foo u;
...
u = (union foo) x  // equivale a   u.i = x
u = (union foo) y  // equivale a  u.d = y
questo "Cast to union"(sempre con info su C Extensions) č
utilizzabile ovunque, anche come parametro:
void hack (union foo);
...
hack ((union foo) x);
--
Paolo Giarrusso

 ma prova; ho trovato questo:
Come hai scritto nel seguito del post si trova in
GCC->C Extensions->Designated Inits
Il chiaro esempio da te citato e':
union foo { int i; double d; };
union foo f  = { .d = 4 };
E' inutile dire che questo risolve i problemi in fase di compilazione che
avevo ( e infatti non lo dico...;-).
for ( i=0, i< 1000; i++)
   printf ("Grazie! ")

valore, essendo u un tipo.
Stai infierendo? Fai bene :)
Mox