Anonyme Vereinigung innerhalb der Struktur nicht in c99?

Hier ist ein sehr vereinfachter Code des Problems, das ich habe:

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;
}

Und was ich nicht verstehe ist folgendes:

$ 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’

Verwenden GCC ohne -std Option kompiliert den obigen Code ohne Probleme (und der ähnliche Code funktioniert ziemlich gut), aber es scheint so c99 lässt diese Technik nicht zu. Warum ist das so und ist es möglich, es zu machen? c99 (oder c89, c90) kompatibel? Vielen Dank.

Anonyme Unions sind eine GNU-Erweiterung, nicht Teil einer Standardversion der C-Sprache. Sie können -std=gnu99 oder ähnliches für c99+GNU-Erweiterungen verwenden, aber es ist am besten, richtiges C zu schreiben und sich nicht auf Erweiterungen zu verlassen, die nichts als syntaktischen Zucker liefern …

Bearbeiten: Anonyme Gewerkschaften wurden in C11 hinzugefügt, sodass sie jetzt ein Standardbestandteil der Sprache sind. Vermutlich GCCs -std=c11 lässt Sie sie verwenden.

Ich finde diese Frage etwa anderthalb Jahre nach allen anderen, daher kann ich eine andere Antwort geben: Anonyme Strukturen sind nicht im C99-Standard, aber im C11-Standard. GCC und Clang unterstützen dies bereits (der C11-Standard scheint die Funktion von Microsoft aufgehoben zu haben, und GCC bietet seit einiger Zeit Unterstützung für einige MSFT-Erweiterungen).

Nun, die Lösung bestand darin, die Instanz der Union zu benennen (die als Datentyp anonym bleiben kann) und diesen Namen dann als Proxy zu verwenden.

$ 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;
 }

Jetzt kompiliert es als c99 ohne Probleme.

$ cc -std=c99 us.c 
$ 

Hinweis: Ich bin mit dieser Lösung sowieso nicht glücklich.

Nur zur Klärung von anonym struct oder anonym union.

C11

6.7.2.1 Struktur- und Vereinigungsspezifizierer

Ein namenloses Mitglied dessen Typbezeichner ein Strukturbezeichner mit ist
keine Markierung heißt ein anonyme Struktur; ein namenloses Mitglied dessen Typbezeichner ein Union-Bezeichner mit ist keine Markierung heißt ein anonyme Vereinigung. Die Mitglieder einer anonymen Struktur oder Vereinigung werden als Mitglieder der enthaltenden Struktur oder Vereinigung betrachtet. Dies gilt rekursiv, wenn die enthaltende Struktur oder Union ebenfalls anonym ist.

C99 Es gibt keine anonyme Struktur oder Union

Vereinfacht: Typbezeichner Kennung { Deklarationsliste } Stichworte ;

• Typbezeichner: struct oder union;
• Kennung: optional, Ihr benutzerdefinierter Name für die struct oder union;
• Deklarationsliste: Mitglieder, Ihre Variablen, anonym struct und anonym union
• Stichworte: Optional. Wenn Sie eine haben typedef vor dem Typbezeichnerdas Stichworte Alias ​​sind und nicht Stichworte.

Es ist eine anonyme struct oder anonym union nur wenn es keinen Bezeichner und kein Tag hat und in einem anderen existiert struct oder union.

struct s {
    struct { int x; };     // Anonymous struct, no identifier and no tag
    struct a { int x; };   // NOT Anonymous struct, has an identifier 'a'
    struct { int x; } b;   // NOT Anonymous struct, has a tag 'b'
    struct c { int x; } C; // NOT Anonymous struct
};

struct s {
    union { int x; };     // Anonymous union, no identifier and no tag
    union a { int x; };   // NOT Anonymous union, has an identifier 'a'
    union { int x; } b;   // NOT Anonymous union, has a tag 'b'
    union c { int x; } C; // NOT Anonymous union
};

typedef hell: wenn du eine hast typedef Der Tag-Teil ist kein Tag mehr, sondern ein Alias ​​für diesen Typ.

struct a { int x; } A; // 'A' is a tag
union a { int x; } A;  // 'A' is a tag

// But if you use this way
typedef struct b { int x; } B; // 'B' is NOT a tag. It is an alias to struct 'b'
typedef union b { int x; } B;  // 'B' is NOT a tag. It is an alias to union 'b'

// Usage
A.x = 10; // A tag you can use without having to declare a new variable

B.x = 10; // Does not work

B bb; // Because 'B' is an alias, you have to declare a new variable
bb.x = 10;

Das Beispiel unten ändert sich einfach struct zum unionfunktioniert genauso.

struct a { int x; }; // Regular complete struct type
typedef struct a aa; // Alias 'aa' for the struct 'a'

struct { int x; } b; // Tag 'b'
typedef struct b bb; // Compile, but unusable.

struct c { int x; } C; // identifier or struct name 'c' and tag 'C'
typedef struct { int x; } d; // Alias 'd'
typedef struct e { int x; } ee; // struct 'e' and alias 'ee'

Union muss einen Namen haben und wie folgt deklariert werden:

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

UPair X;
X.int_n.value = 12;

Eine andere Lösung besteht darin, den gemeinsamen Header-Wert (enum node_type type) in jede Struktur und machen Sie Ihre Struktur der obersten Ebene zu einer Union. Es ist nicht gerade “Don’t Repeat Yourself”, aber es vermeidet sowohl anonyme Vereinigungen als auch unbequem aussehende Proxy-Werte.

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;
}

Wenn ich mir 6.2.7.1 von C99 anschaue, sehe ich, dass die Kennung optional ist:

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

Ich habe auf und ab gesucht und kann keinen Hinweis darauf finden, dass anonyme Gewerkschaften gegen die Spezifikation verstoßen. Das ganze Suffix -opt zeigt in diesem Fall an, dass das Ding identifier ist gemäß 6.1 optional.