Warum brauchen wir C-Unions?

Wann sollten Gewerkschaften verwendet werden? Warum brauchen wir sie?

Unions werden oft verwendet, um zwischen den binären Darstellungen von Ganzzahlen und Floats zu konvertieren:

union
{
  int i;
  float f;
} u;

// Convert floating-point bits to integer:
u.f = 3.14159f;
printf("As integer: %08x\n", u.i);

Obwohl dies gemäß dem C-Standard ein technisch undefiniertes Verhalten ist (Sie sollten nur das zuletzt geschriebene Feld lesen), verhält es sich in praktisch jedem Compiler auf wohldefinierte Weise.

Unions werden manchmal auch verwendet, um Pseudopolymorphismus in C zu implementieren, indem einer Struktur ein Tag gegeben wird, das angibt, welche Art von Objekt sie enthält, und dann die möglichen Typen miteinander vereint werden:

enum Type { INTS, FLOATS, DOUBLE };
struct S
{
  Type s_type;
  union
  {
    int s_ints[2];
    float s_floats[2];
    double s_double;
  };
};

void do_something(struct S *s)
{
  switch(s->s_type)
  {
    case INTS:  // do something with s->s_ints
      break;

    case FLOATS:  // do something with s->s_floats
      break;

    case DOUBLE:  // do something with s->s_double
      break;
  }
}

Dies ermöglicht die Größe von struct S nur 12 Bytes statt 28 sein.

Unions sind besonders nützlich bei der Embedded-Programmierung oder in Situationen, in denen ein direkter Zugriff auf die Hardware/den Speicher erforderlich ist. Hier ein triviales Beispiel:

typedef union
{
    struct {
        unsigned char byte1;
        unsigned char byte2;
        unsigned char byte3;
        unsigned char byte4;
    } bytes;
    unsigned int dword;
} HW_Register;
HW_Register reg;

Dann können Sie wie folgt auf die Registrierung zugreifen:

reg.dword = 0x12345678;
reg.bytes.byte3 = 4;

Endianness (Bytereihenfolge) und Prozessorarchitektur sind natürlich wichtig.

Eine weitere nützliche Funktion ist der Bit-Modifikator:

typedef union
{
    struct {
        unsigned char b1:1;
        unsigned char b2:1;
        unsigned char b3:1;
        unsigned char b4:1;
        unsigned char reserved:4;
    } bits;
    unsigned char byte;
} HW_RegisterB;
HW_RegisterB reg;

Mit diesem Code können Sie direkt auf ein einzelnes Bit in der Register-/Speicheradresse zugreifen:

x = reg.bits.b2;

Die Systemprogrammierung auf niedriger Ebene ist ein vernünftiges Beispiel.

IIRC, ich habe Unions verwendet, um Hardwareregister in die Komponentenbits aufzuschlüsseln. Sie können also auf ein 8-Bit-Register zugreifen (wie es damals war 😉 in die Komponentenbits.

(Ich habe die genaue Syntax vergessen, aber …) Diese Struktur würde es ermöglichen, auf ein Steuerregister als control_byte oder über die einzelnen Bits zuzugreifen. Es wäre wichtig sicherzustellen, dass die Bits für eine gegebene Endianness auf die richtigen Registerbits abgebildet werden.

typedef union {
    unsigned char control_byte;
    struct {
        unsigned int nibble  : 4;
        unsigned int nmi     : 1;
        unsigned int enabled : 1;
        unsigned int fired   : 1;
        unsigned int control : 1;
    };
} ControlRegister;

Ich habe es in einigen Bibliotheken als Ersatz für die objektorientierte Vererbung gesehen.

Z.B

        Connection
     /       |       \
  Network   USB     VirtualConnection

Wenn Sie möchten, dass die “Klasse” von Connection eine der oben genannten ist, können Sie Folgendes schreiben:

struct Connection
{
    int type;
    union
    {
        struct Network network;
        struct USB usb;
        struct Virtual virtual;
    }
};

Beispielverwendung in libinfinity: http://git.0x539.de/?p=infinote.git;a=blob;f=libinfinity/common/inf-session.c;h=3e887f0d63bd754c6b5ec232948027cbbf4d61fc;hb=HEAD#l74

Vereinigungen ermöglichen es Datenmitgliedern, die sich gegenseitig ausschließen, denselben Speicher zu teilen. Dies ist sehr wichtig, wenn Speicher knapper ist, wie z. B. in eingebetteten Systemen.

Im folgenden Beispiel:

union {
   int a;
   int b;
   int c;
} myUnion;

Diese Vereinigung nimmt den Platz eines einzelnen int ein, anstatt 3 separate int-Werte. Wenn der Benutzer den Wert von festlegt aund legen Sie dann den Wert von fest bwürde es den Wert von überschreiben a da beide den gleichen Speicherplatz teilen.

Viele Verwendungen. Mach einfach grep union /usr/include/* oder in ähnlichen Verzeichnissen. Die meisten Fälle union ist eingewickelt struct und ein Mitglied der Struktur teilt mit, auf welches Element in der Union zugegriffen werden soll. Zum Beispiel Kasse man elf für reale Implementierungen.

Das ist das Grundprinzip:

struct _mydata {
    int which_one;
    union _data {
            int a;
            float b;
            char c;
    } foo;
} bar;

switch (bar.which_one)
{
   case INTEGER  :  /* access bar.foo.a;*/ break;
   case FLOATING :  /* access bar.foo.b;*/ break;
   case CHARACTER:  /* access bar.foo.c;*/ break;
}

Hier ist ein Beispiel für eine Vereinigung aus meiner eigenen Codebasis (aus dem Gedächtnis und umschrieben, damit es möglicherweise nicht genau ist). Es wurde verwendet, um Sprachelemente in einem von mir gebauten Interpreter zu speichern. Zum Beispiel der folgende Code:

set a to b times 7.

besteht aus folgenden Sprachelementen:

• Symbol[set]
• Variable[a]
• Symbol[to]
• Variable[b]
• Symbol[times]
• Konstante[7]
• Symbol[.]

Sprachelemente wurden definiert als ‘#define‘Werte also:

#define ELEM_SYM_SET        0
#define ELEM_SYM_TO         1
#define ELEM_SYM_TIMES      2
#define ELEM_SYM_FULLSTOP   3
#define ELEM_VARIABLE     100
#define ELEM_CONSTANT     101

und die folgende Struktur wurde verwendet, um jedes Element zu speichern:

typedef struct {
    int typ;
    union {
        char *str;
        int   val;
    }
} tElem;

dann war die Größe jedes Elements die Größe der maximalen Vereinigung (4 Bytes für den Typ und 4 Bytes für die Vereinigung, obwohl dies typische Werte sind, die tatsächlich Größen hängen von der Implementierung ab).

Um ein “Set”-Element zu erstellen, würden Sie Folgendes verwenden:

tElem e;
e.typ = ELEM_SYM_SET;

Um eine „Variable[b]”-Element würden Sie verwenden:

tElem e;
e.typ = ELEM_VARIABLE;
e.str = strdup ("b");   // make sure you free this later

Um eine „konstante[7]”-Element würden Sie verwenden:

tElem e;
e.typ = ELEM_CONSTANT;
e.val = 7;

und Sie könnten es leicht erweitern, um Gleitkommazahlen (float flt) oder rationale (struct ratnl {int num; int denom;}) und andere Arten.

Die Grundvoraussetzung ist, dass die str und val sind im Speicher nicht zusammenhängend, sie überlappen sich tatsächlich, also ist es eine Möglichkeit, eine andere Sicht auf denselben Speicherblock zu bekommen, wie hier dargestellt, wo die Struktur am Speicherort basiert 0x1010 und ganze Zahlen und Zeiger sind beide 4 Bytes:

       +-----------+
0x1010 |           |
0x1011 |    typ    |
0x1012 |           |
0x1013 |           |
       +-----+-----+
0x1014 |     |     |
0x1015 | str | val |
0x1016 |     |     |
0x1017 |     |     |
       +-----+-----+

Wenn es nur in einer Struktur wäre, würde es so aussehen:

       +-------+
0x1010 |       |
0x1011 |  typ  |
0x1012 |       |
0x1013 |       |
       +-------+
0x1014 |       |
0x1015 |  str  |
0x1016 |       |
0x1017 |       |
       +-------+
0x1018 |       |
0x1019 |  val  |
0x101A |       |
0x101B |       |
       +-------+