Was sind die Vorteile unbenannter Strukturen/Vereinigungen in C?

Question

fand ich einen Code als ähnliche Demo implementiert unten ..

struct st 
{ 
int a; 
struct 
{ 
int b; 
}; 
}; 

6,58 Unbenannt struct/union Felder gezeigt in structs/unions

von ISO C11 erlaubt As.

Aber was sind Vorteile davon?

Da ich sowieso die Datenelemente in gleicher Weise zugreifen können, wie

int main() 
{ 
struct st s; 
s.a=11; 
s.b=22; 
return 0; 
} 

auf gcc 4.5.2 mit,

gcc -Wall demo.c -o demo 

und keine Fehler,

Answer 1

Es muss nicht eine anonyme Struktur innerhalb einer Struktur sein, die ich nicht sehr nützlich finde: Dies wird in der Regel nur das Layout geringfügig ändern, indem mehr Padding eingeführt wird, mit anderen sichtbaren Effekten (im Vergleich zu Inlining der Mitglieder von die Kind-Struktur in die Eltern-Struktur).

Ich denke, dass der Vorteil von anonymen struct/unions ist woanders: Sie können verwendet werden, um eine anonyme Struktur innerhalb einer Union oder einer anonymen Union innerhalb einer Struktur zu platzieren.

Beispiel:

union u 
{ 
    int i; 
    struct { char b1; char b2; char b3; char b4; }; 
}; 

Answer 2

Der Vorteil ist, ziemlich offensichtlich, oder? Es erspart dem Programmierer einen Namen! Seit naming things is hard ist es nett, dass es möglich ist, dies zu vermeiden, wenn es keinen wirklichen Bedarf gibt.

Es ist auch ein ziemlich klares Signal, dass diese struct lokal ist und nirgendwo anders, aber im Kontext des Seins ein Feld in der übergeordneten Struktur, die wirklich verwendet wird, wirklich schön Informationen, da es reduziert die Möglichkeit unnötiger Kopplung .

Betrachten Sie es als static; Es beschränkt die Sichtbarkeit der inneren struct auf die äußere, in ähnlicher Weise (aber nicht natürlich äquivalent), wie static die Sichtbarkeit von globalen Symbolen auf die Kompilierungseinheit beschränkt, in der sie erscheinen.

Answer 3

Ich lief in einen großen Nutzen von anonymen union. Seien Sie jedoch gewarnt, dies ist keine Geschichte für schwache Nerven, noch ist es eine empfohlene Praxis. In einem älteren C-Programm von Hunderten von Quellcodedateien gibt es eine globale Variable, eine struct, die eine struct als Mitglied enthielt. So ist die Typdefinition für die globale Variable sah etwas, was wie:

typedef struct { 
    LONG  lAmount; 
    STRUCTONE largeStruct; // memory area actually used for several different struct objects 
    ULONG  ulFlags; 
} STRUCTCOMMON; 

Die struct, STRUCTONE, war einer von mehreren großen structs aber die anderen waren alle kleiner als STRUCTONE zum Zeitpunkt der Code geschrieben wurde. Dieser Speicherbereich largeStruct wurde also als union verwendet, aber ohne die entsprechenden Quellanweisungen. Stattdessen wurden verschiedene struct Variablen in diesen Bereich unter Verwendung von memcpy() kopiert.Um das Ganze noch schlimmer zu machen, geschah dies manchmal durch den tatsächlichen Namen der globalen Variablen und manchmal durch einen Zeiger auf die globale Variable.

Wie in der Regel passiert, wie die Zeit fortschreitet letzten Änderungen führten zu einer der anderen Strukturen die größte. Und ich war damit konfrontiert, dass ich durch hundert Dateien gehen musste, um herauszufinden, wo diese verwendet wurden, zusammen mit all den verschiedenen Aliasen und allem anderen.

Und dann erinnerte ich mich an anonyme Gewerkschaften. So modifizierte ich die typedef, die folgenden sein:

typedef struct { 
    LONG  lAmount; 
    union { 
     // anonymous union to allow for allocation of largest space needed 
     STRUCTONE largeStruct; // memory area actually used for several different struct objects 
     STRUCTTHREE largerStruct; // memory area for even larger struct 
    }; 
    ULONG  ulFlags; 
} STRUCTCOMMON; 

Und dann alles neu kompiliert.

So all die Tage der Quellcode-Überprüfung und Regressionstests, auf die ich mich unglücklich freute, sind nicht mehr notwendig.

Und ich kann jetzt den Prozess der langsamen Änderung der Quelle mit dieser globalen beginnen, um diese Quelle zu moderneren Standards auf meinem eigenen Zeitplan zu bringen.