Unione anonima all'interno di struct non in c99?

Question

qui è molto codice di problema semplificato ho:

 
enum node_type { 
    t_int, t_double 
}; 

struct int_node { 
    int value; 
}; 

struct double_node { 
    double value; 
}; 

struct node { 
    enum node_type type; 
    union { 
     struct int_node int_n; 
     struct double_node double_n; 
    }; 
}; 

int main(void) { 
    struct int_node i; 
    i.value = 10; 
    struct node n; 
    n.type = t_int; 
    n.int_n = i; 
    return 0; 
} 

E quello che non undestand è questo:

 
$ cc us.c 
$ cc -std=c99 us.c 
us.c:18:4: warning: declaration does not declare anything 
us.c: In function ‘main’: 
us.c:26:4: error: ‘struct node’ has no member named ‘int_n’ 

Utilizzando GCC senza -std opzione compila codice di cui sopra senza problemi (e la codice simile funziona abbastanza bene), ma sembra che c99 non consenta questa tecnica. Perché è così ed è possibile rendere c99 (o c89, c90) compatibile? Grazie.

Answer 1

Unione deve avere un nome e essere dichiarati in questo modo:

union UPair { 
    struct int_node int_n; 
    struct double_node double_n; 
}; 

UPair X; 
X.int_n.value = 12; 

Answer 2

unioni anonime sono un'estensione GNU, non fa parte di alcuna versione standard del linguaggio C. È possibile utilizzare -std = gnu99 o qualcosa di simile per le estensioni C99 + GNU, ma è meglio scrivere corretta C e non fare affidamento sulle estensioni che forniscono altro che zucchero sintattico ...

Edit: sono stati aggiunti sindacati anonimi in C11, quindi sono ora una parte standard della lingua. Presumibilmente GCC -std=c11 consente di utilizzarli.

Answer 3

Bene, la soluzione era denominare l'istanza dell'unione (che può rimanere anonima come tipo di dati) e quindi utilizzare tale nome come proxy.

 
$ diff -u old_us.c us.c 
--- old_us.c 2010-07-12 13:49:25.000000000 +0200 
+++ us.c  2010-07-12 13:49:02.000000000 +0200 
@@ -15,7 +15,7 @@ 
    union { 
    struct int_node int_n; 
    struct double_node double_n; 
- }; 
+ } data; 
}; 

int main(void) { 
@@ -23,6 +23,6 @@ 
    i.value = 10; 
    struct node n; 
    n.type = t_int; 
- n.int_n = i; 
+ n.data.int_n = i; 
    return 0; 
} 

Ora compila come c99 senza problemi.

 
$ cc -std=c99 us.c 
$ 

Nota: io non sono contento di questa soluzione in ogni caso.

Answer 4

Guardando 6.2.7.1 di C99, sto vedendo che l'identificatore è opzionale:

  struct-or-union-specifier: 
        struct-or-union identifier-opt { struct-declaration-list } 
        struct-or-union identifier 

      struct-or-union: 
        struct 
        union 

      struct-declaration-list: 
        struct-declaration 
        struct-declaration-list struct-declaration 

      struct-declaration: 
        specifier-qualifier-list struct-declarator-list ; 

      specifier-qualifier-list: 
        type-specifier specifier-qualifier-list-opt 
        type-qualifier specifier-qualifier-list-opt 

Sono stato su e giù per la ricerca, e non riesce a trovare alcun riferimento alle unioni anonime essere contro la spec. L'intero suffisso -opt indica che la cosa, in questo caso, identifier è facoltativa in base a 6.1.

Answer 5

Sto trovando questa domanda circa un anno e mezzo dopo che tutti gli altri hanno fatto, quindi posso dare una risposta diversa: le strutture anonime non sono nello standard C99, ma sono nello standard C11. GCC e clang già supportano questo (lo standard C11 sembra aver rimosso la funzionalità da Microsoft, e GCC ha fornito supporto per alcune estensioni MSFT per qualche tempo).

Answer 6

Un'altra soluzione consiste nel mettere il valore di intestazione comune (enum node_type type) in ogni struttura e rendere la struttura di livello superiore un'unione. Non è esattamente "Do not Repeat Yourself", ma evita sia le unioni anonime che i valori proxy dall'aspetto scomodo.

enum node_type { 
    t_int, t_double 
}; 
struct int_node { 
    enum node_type type; 
    int value; 
}; 
struct double_node { 
    enum node_type type; 
    double value; 
}; 
union node { 
    enum node_type type; 
    struct int_node int_n; 
    struct double_node double_n; 
}; 

int main(void) { 
    union node n; 
    n.type = t_int; // or n.int_n.type = t_int; 
    n.int_n.value = 10; 
    return 0; 
}