Wann würde jemand eine Gewerkschaft benutzen? Ist es ein Überbleibsel aus den Tagen nur mit C?

Ich habe gelernt, bekomme aber keine Gewerkschaften. Jeder C- oder C ++ - Text, den ich durchlaufe, führt sie ein (manchmal im Vorbeigehen), aber sie geben in der Regel nur sehr wenige praktische Beispiele dafür, warum oder wo sie verwendet werden sollen. Wann wären Gewerkschaften in einem modernen (oder sogar alten) Fall nützlich? Meine einzigen beiden Vermutungen wären das Programmieren von Mikroprozessoren, wenn Sie nur sehr wenig Platz zum Arbeiten haben oder wenn Sie eine API (oder ähnliches) entwickeln und den Endbenutzer dazu zwingen möchten, nur eine Instanz mehrerer Objekte / Typen zu haben einmal. Sind diese beiden Vermutungen überhaupt richtig?

Gewerkschaften werden normalerweise mit der Gesellschaft eines Diskriminators verwendet: eine Variable, die angibt, welches der Felder der Gewerkschaft gültig ist. Angenommen, Sie möchten eine eigene Variante erstellen :

struct my_variant_t {
    int type;
    union {
        char char_value;
        short short_value;
        int int_value;
        long long_value;
        float float_value;
        double double_value;
        void* ptr_value;
    };
};

Dann würden Sie es verwenden wie:

/* construct a new float variant instance */
void init_float(struct my_variant_t* v, float initial_value) {
    v->type = VAR_FLOAT;
    v->float_value = initial_value;
}

/* Increments the value of the variant by the given int */
void inc_variant_by_int(struct my_variant_t* v, int n) {
    switch (v->type) {
    case VAR_FLOAT:
        v->float_value += n;
        break;

    case VAR_INT:
        v->int_value += n;
        break;
    ...
    }
}

Dies ist eigentlich eine ziemlich verbreitete Redewendung, insbesondere bei Visual Basic-Interna.

Ein reales Beispiel finden Sie in der SDL_Event-Union von SDL . ( aktueller Quellcode hier ). Da ist eintype oberen Rand der Union Feld, und dasselbe Feld wird in jeder SDL_ * -Ereignisstruktur wiederholt. Um das richtige Ereignis zu behandeln, müssen Sie den Wert des typeFelds überprüfen .

Die Vorteile sind einfach: Es gibt einen einzigen Datentyp, mit dem alle Ereignistypen ohne unnötigen Speicher verarbeitet werden können.

Ich finde C ++ - Gewerkschaften ziemlich cool. Es scheint, dass die Leute normalerweise nur an den Anwendungsfall denken, in dem man den Wert einer Union-Instanz "an Ort und Stelle" ändern möchte (was anscheinend nur dazu dient, Speicherplatz zu sparen oder zweifelhafte Konvertierungen durchzuführen).

In der Tat können Gewerkschaften als Software-Engineering-Tool von großer Bedeutung sein, selbst wenn Sie den Wert einer Gewerkschaftsinstanz niemals ändern .

Anwendungsfall 1: das Chamäleon

Mit Gewerkschaften können Sie eine Reihe beliebiger Klassen unter einer Bezeichnung zusammenfassen, was nicht ohne Ähnlichkeiten mit dem Fall einer Basisklasse und ihren abgeleiteten Klassen ist. Was sich jedoch ändert, ist, was Sie mit einer bestimmten Union-Instanz tun können und was nicht:

struct Batman;
struct BaseballBat;

union Bat
{
    Batman brucewayne;
    BaseballBat club;
};

ReturnType1 f(void)
{
    BaseballBat bb = {/* */};
    Bat b;
    b.club = bb;
    // do something with b.club
}

ReturnType2 g(Bat& b)
{
    // do something with b, but how do we know what's inside?
}

Bat returnsBat(void);
ReturnType3 h(void)
{
    Bat b = returnsBat();
    // do something with b, but how do we know what's inside?
}

Es scheint, dass der Programmierer sicher sein muss, welche Art von Inhalt eine bestimmte Union-Instanz hat, wenn er sie verwenden möchte. Dies ist in der fobigen Funktion der Fall . Wenn eine Funktion jedoch eine Union-Instanz als übergebenes Argument erhalten würde, wie dies goben der Fall ist , weiß sie nicht, was sie damit tun soll. Gleiches gilt für Funktionen, die eine Union-Instanz zurückgeben, sieheh : Woher weiß der Aufrufer, was sich darin befindet?

Wenn eine Union-Instanz niemals als Argument oder als Rückgabewert übergeben wird, hat sie zwangsläufig ein sehr eintöniges Leben mit Aufregung, wenn der Programmierer seinen Inhalt ändert:

Batman bm = {/* */};
Baseball bb = {/* */};
Bat b;
b.brucewayne = bm;
// stuff
b.club = bb;

Und das ist der (un) beliebteste Anwendungsfall von Gewerkschaften. Ein weiterer Anwendungsfall ist, wenn eine Union-Instanz etwas enthält, das Ihnen den Typ angibt.

Anwendungsfall 2: "Schön, Sie kennenzulernen, ich bin objectvon Class"

Angenommen, ein Programmierer hat sich dafür entschieden, eine Union-Instanz immer mit einem Typdeskriptor zu koppeln (ich überlasse es dem Ermessen des Lesers, sich eine Implementierung für ein solches Objekt vorzustellen). Dies macht den Zweck der Union selbst zunichte, wenn der Programmierer Speicher sparen möchte und die Größe des Typdeskriptors in Bezug auf die der Union nicht vernachlässigbar ist. Nehmen wir jedoch an, dass es entscheidend ist, dass die Union-Instanz als Argument oder als Rückgabewert übergeben wird, wenn der Angerufene oder Anrufer nicht weiß, was sich darin befindet.

Dann muss der Programmierer a schreiben switch Kontrollflussanweisung , um Bruce Wayne von einem Holzstab oder etwas Ähnlichem zu unterscheiden. Es ist nicht schlecht, wenn es nur zwei Arten von Inhalten in der Union gibt, aber offensichtlich skaliert die Union nicht mehr.

Anwendungsfall 3:

Wie die Autoren einer Empfehlung für den ISO C ++ - Standard bereits 2008 formulierten,

Viele wichtige Problemdomänen erfordern entweder eine große Anzahl von Objekten oder begrenzte Speicherressourcen. In diesen Situationen ist es sehr wichtig, Platz zu sparen, und eine Gewerkschaft ist oft der perfekte Weg, dies zu tun. In der Tat ist ein häufiger Anwendungsfall die Situation, in der eine Gewerkschaft während ihres Lebens niemals ihr aktives Mitglied wechselt. Es kann so konstruiert, kopiert und zerstört werden, als wäre es eine Struktur, die nur ein Mitglied enthält. Eine typische Anwendung hierfür wäre die Erstellung einer heterogenen Sammlung nicht verwandter Typen, die nicht dynamisch zugewiesen werden (möglicherweise sind sie direkt in einer Karte oder in Mitgliedern eines Arrays erstellt).

Und nun ein Beispiel mit einem UML-Klassendiagramm:

Die Situation im Klartext: Ein Objekt der Klasse A kann Objekte jeder Klasse unter B1, ..., Bn und höchstens eines von jedem Typ haben, wobei n eine ziemlich große Zahl ist, sagen wir mindestens 10.

Wir möchten A keine Felder (Datenelemente) hinzufügen, wie folgt:

private:
    B1 b1;
    .
    .
    .
    Bn bn;

weil n variieren kann (wir möchten möglicherweise Bx-Klassen zum Mix hinzufügen) und weil dies ein Durcheinander mit Konstruktoren verursachen würde und weil A-Objekte viel Platz beanspruchen würden.

Wir könnten einen verrückten Container mit void*Zeigern auf BxObjekte mit Casts verwenden, um sie abzurufen, aber das ist flüchtig und so im C-Stil ... aber was noch wichtiger ist, das würde uns die Lebensdauer vieler dynamisch zugeordneter Objekte überlassen, die verwaltet werden müssen.

Stattdessen kann Folgendes getan werden:

union Bee
{
    B1 b1;
    .
    .
    .
    Bn bn;
};

enum BeesTypes { TYPE_B1, ..., TYPE_BN };

class A
{
private:
    std::unordered_map<int, Bee> data; // C++11, otherwise use std::map

public:
    Bee get(int); // the implementation is obvious: get from the unordered map
};

Um den Inhalt einer Union-Instanz abzurufen data, verwenden Sie a.get(TYPE_B2).b2und dergleichen, wobei asich eine Klasseninstanz befindet A.

Dies ist umso leistungsfähiger, als die Gewerkschaften in C ++ 11 uneingeschränkt sind. Weitere Informationen finden Sie im oben verlinkten Dokument oder in diesem Artikel .

Ein Beispiel ist der eingebettete Bereich, in dem jedes Bit eines Registers etwas anderes bedeuten kann. Beispielsweise können Sie durch die Vereinigung einer 8-Bit-Ganzzahl und einer Struktur mit 8 separaten 1-Bit-Bitfeldern entweder ein Bit oder das gesamte Byte ändern.

Herb Sutter schrieb vor ungefähr sechs Jahren in GOTW , mit Schwerpunkt :

"Aber denken Sie nicht, dass Gewerkschaften nur ein Überbleibsel aus früheren Zeiten sind. Gewerkschaften sind vielleicht am nützlichsten, um Platz zu sparen, indem sie Daten überlappen lassen, und dies ist in C ++ und in der heutigen modernen Welt immer noch wünschenswert . Zum Beispiel einige der meisten fortgeschrittenes C ++Standardbibliotheksimplementierungen in der Welt verwenden jetzt genau diese Technik, um die "Optimierung kleiner Zeichenfolgen" zu implementieren, eine großartige Optimierungsalternative, die den Speicher innerhalb eines Zeichenfolgenobjekts selbst wiederverwendet: Bei großen Zeichenfolgen speichert der Speicherplatz innerhalb des Zeichenfolgenobjekts den üblichen Zeiger auf die dynamische zugewiesene Puffer- und Reinigungsinformationen wie die Größe des Puffers; Bei kleinen Zeichenfolgen wird stattdessen derselbe Speicherplatz wiederverwendet, um den Inhalt der Zeichenfolge direkt zu speichern und eine dynamische Speicherzuweisung vollständig zu vermeiden. Weitere Informationen zur Optimierung kleiner Zeichenfolgen (und zu anderen Optimierungen und Pessimierungen von Zeichenfolgen in beträchtlicher Tiefe) finden Sie unter .... "

Ein weniger nützliches Beispiel finden Sie in der langen, aber nicht schlüssigen Frage gcc, striktes Aliasing und Casting durch eine Gewerkschaft .

Ein Anwendungsfall, den ich mir vorstellen kann, ist folgender:

typedef union
{
    struct
    {
        uint8_t a;
        uint8_t b;
        uint8_t c;
        uint8_t d;
    };
    uint32_t x;
} some32bittype;

Sie können dann auf die separaten 8-Bit-Teile dieses 32-Bit-Datenblocks zugreifen. Bereiten Sie sich jedoch darauf vor, möglicherweise von Endianness gebissen zu werden.

Dies ist nur ein hypothetisches Beispiel. Wenn Sie jedoch Daten in einem Feld in solche Komponenten aufteilen möchten, können Sie eine Union verwenden.

Es gibt jedoch auch eine Methode, die endian-sicher ist:

uint32_t x;
uint8_t a = (x & 0xFF000000) >> 24;

Zum Beispiel, da diese binäre Operation vom Compiler in die richtige Endianness konvertiert wird.

Einige Verwendungszwecke für Gewerkschaften:

• Bereitstellung einer allgemeinen Endianness-Schnittstelle für einen unbekannten externen Host.
• Bearbeiten Sie Gleitkommadaten der fremden CPU-Architektur, z. B. das Akzeptieren von VAX G_FLOATS von einer Netzwerkverbindung und das Konvertieren dieser zur Verarbeitung in IEEE 754 Long Reals .
• Bieten Sie einen einfachen Bit-Twiddling-Zugriff auf einen übergeordneten Typ.

union {
      unsigned char   byte_v[16];
      long double     ld_v;
 }

Mit dieser Deklaration ist es einfach, die Hex-Byte-Werte von a anzuzeigen, das long doubleVorzeichen des Exponenten zu ändern, festzustellen, ob es sich um einen Denormalwert handelt, oder eine lange Doppelarithmetik für eine CPU zu implementieren, die dies nicht unterstützt usw.

• Speicherplatz sparen, wenn Felder von bestimmten Werten abhängig sind:

  class person {  
      string name;  
  
      char gender;   // M = male, F = female, O = other  
      union {  
          date  vasectomized;  // for males  
          int   pregnancies;   // for females  
      } gender_specific_data;
  }

• Grep die Include-Dateien zur Verwendung mit deinem Compiler. Sie finden Dutzende bis Hunderte von Anwendungen von union:

  [wally@zenetfedora ~]$ cd /usr/include
  [wally@zenetfedora include]$ grep -w union *
  a.out.h:  union
  argp.h:   parsing options, getopt is called with the union of all the argp
  bfd.h:  union
  bfd.h:  union
  bfd.h:union internal_auxent;
  bfd.h:  (bfd *, struct bfd_symbol *, int, union internal_auxent *);
  bfd.h:  union {
  bfd.h:  /* The value of the symbol.  This really should be a union of a
  bfd.h:  union
  bfd.h:  union
  bfdlink.h:  /* A union of information depending upon the type.  */
  bfdlink.h:  union
  bfdlink.h:       this field.  This field is present in all of the union element
  bfdlink.h:       the union; this structure is a major space user in the
  bfdlink.h:  union
  bfdlink.h:  union
  curses.h:    union
  db_cxx.h:// 4201: nameless struct/union
  elf.h:  union
  elf.h:  union
  elf.h:  union
  elf.h:  union
  elf.h:typedef union
  _G_config.h:typedef union
  gcrypt.h:  union
  gcrypt.h:    union
  gcrypt.h:    union
  gmp-i386.h:  union {
  ieee754.h:union ieee754_float
  ieee754.h:union ieee754_double
  ieee754.h:union ieee854_long_double
  ifaddrs.h:  union
  jpeglib.h:  union {
  ldap.h: union mod_vals_u {
  ncurses.h:    union
  newt.h:    union {
  obstack.h:  union
  pi-file.h:  union {
  resolv.h:   union {
  signal.h:extern int sigqueue (__pid_t __pid, int __sig, __const union sigval __val)
  stdlib.h:/* Lots of hair to allow traditional BSD use of `union wait'
  stdlib.h:  (__extension__ (((union { __typeof(status) __in; int __i; }) \
  stdlib.h:/* This is the type of the argument to `wait'.  The funky union
  stdlib.h:   causes redeclarations with either `int *' or `union wait *' to be
  stdlib.h:typedef union
  stdlib.h:    union wait *__uptr;
  stdlib.h:  } __WAIT_STATUS __attribute__ ((__transparent_union__));
  thread_db.h:  union
  thread_db.h:  union
  tiffio.h:   union {
  wchar.h:  union
  xf86drm.h:typedef union _drmVBlank {

Gewerkschaften sind nützlich, wenn Sie mit Daten auf Byte-Ebene (niedriger Ebene) arbeiten.

Eine meiner jüngsten Anwendungen war die Modellierung von IP-Adressen, die wie folgt aussieht:

// Composite structure for IP address storage
union
{
    // IPv4 @ 32-bit identifier
    // Padded 12-bytes for IPv6 compatibility
    union
    {
        struct
        {
            unsigned char _reserved[12];
            unsigned char _IpBytes[4];
        } _Raw;

        struct
        {
            unsigned char _reserved[12];
            unsigned char _o1;
            unsigned char _o2;
            unsigned char _o3;
            unsigned char _o4;    
        } _Octet;    
    } _IPv4;

    // IPv6 @ 128-bit identifier
    // Next generation internet addressing
    union
    {
        struct
        {
            unsigned char _IpBytes[16];
        } _Raw;

        struct
        {
            unsigned short _w1;
            unsigned short _w2;
            unsigned short _w3;
            unsigned short _w4;
            unsigned short _w5;
            unsigned short _w6;
            unsigned short _w7;
            unsigned short _w8;   
        } _Word;
    } _IPv6;
} _IP;

Ein Beispiel, wenn ich eine Gewerkschaft verwendet habe:

class Vector
{
        union 
        {
            double _coord[3];
            struct 
            {
                double _x;
                double _y; 
                double _z;
            };

        };
...
}

Dadurch kann ich als Array oder als Elemente auf meine Daten zugreifen.

Ich habe eine Union verwendet, damit die verschiedenen Begriffe auf denselben Wert verweisen. Bei der Bildverarbeitung kann es verwirrend werden, ob ich an Spalten oder der Breite oder der Größe in X-Richtung gearbeitet habe. Um dieses Problem zu lösen, verwende ich eine Gewerkschaft, damit ich weiß, welche Beschreibungen zusammenpassen.

   union {   // dimension from left to right   // union for the left to right dimension
        uint32_t            m_width;
        uint32_t            m_sizeX;
        uint32_t            m_columns;
    };

    union {   // dimension from top to bottom   // union for the top to bottom dimension
        uint32_t            m_height;
        uint32_t            m_sizeY;
        uint32_t            m_rows;
    };

Gewerkschaften sorgen für Polymorphismus in C.

Eine brillante Verwendung von Union ist die Speicherausrichtung, die ich im PCL-Quellcode (Point Cloud Library) gefunden habe. Die einzelne Datenstruktur in der API kann auf zwei Architekturen abzielen: CPU mit SSE-Unterstützung sowie CPU ohne SSE-Unterstützung. Zum Beispiel: Die Datenstruktur für PointXYZ ist

typedef union
{
  float data[4];
  struct
  {
    float x;
    float y;
    float z;
  };
} PointXYZ;

Die 3 Schwimmer sind mit einem zusätzlichen Schwimmer für die SSE-Ausrichtung gepolstert. So für

PointXYZ point;

Der Benutzer kann entweder auf point.data [0] oder point.x (abhängig von der SSE-Unterstützung) zugreifen, um beispielsweise auf die x-Koordinate zuzugreifen. Weitere ähnliche Details zur besseren Verwendung finden Sie unter folgendem Link: PCL-Dokumentation PointT-Typen

Das unionSchlüsselwort, das noch in C ++ 03 ^{1 verwendet wird} , ist größtenteils ein Rest der C-Tage. Das auffälligste Problem ist, dass es nur mit POD ¹ funktioniert .

Die Idee der Gewerkschaft ist jedoch immer noch vorhanden, und tatsächlich verfügen die Boost-Bibliotheken über eine gewerkschaftsähnliche Klasse:

boost::variant<std::string, Foo, Bar>

Welches hat die meisten Vorteile der union(wenn nicht alle) und fügt hinzu:

• Fähigkeit, Nicht-POD-Typen korrekt zu verwenden
• statische Sicherheit

In der Praxis wurde gezeigt, dass es einer Kombination von union+ entspricht enum, und es wurde ein Benchmark durchgeführt, dass es genauso schnell war (während boost::anyes mehr zum Bereich von gehört dynamic_cast, da es RTTI verwendet).

¹ Gewerkschaften wurden in C ++ 11 ( uneingeschränkte Gewerkschaften ) aktualisiert und können jetzt Objekte mit Destruktoren enthalten, obwohl der Benutzer den Destruktor manuell aufrufen muss (für das derzeit aktive Gewerkschaftsmitglied). Es ist immer noch viel einfacher, Varianten zu verwenden.

Aus dem Wikipedia-Artikel über Gewerkschaften :

Der Hauptnutzen einer Union besteht darin , Platz zu sparen , da so viele verschiedene Typen im selben Raum gespeichert werden können. Gewerkschaften sorgen auch für groben Polymorphismus . Es gibt jedoch keine Überprüfung der Typen, daher muss der Programmierer sicherstellen, dass in verschiedenen Kontexten auf die richtigen Felder zugegriffen wird. Das relevante Feld einer Vereinigungsvariablen wird typischerweise durch den Zustand anderer Variablen bestimmt, möglicherweise in einer umschließenden Struktur.

Eine gängige C-Programmiersprache verwendet Unions, um das auszuführen, was C ++ als reinterpret_cast bezeichnet, indem sie einem Feld einer Union zugewiesen und aus einem anderen gelesen wird, wie dies in Code erfolgt, der von der Rohdarstellung der Werte abhängt.

In den frühesten Tagen von C (z. B. wie 1974 dokumentiert) hatten alle Strukturen einen gemeinsamen Namespace für ihre Mitglieder. Jeder Mitgliedsname war einem Typ und einem Offset zugeordnet. Wenn "wd_woozle" ein "int" bei Offset 12 wäre p, p->wd_woozlewäre ein Zeiger eines beliebigen Strukturtyps äquivalent zu *(int*)(((char*)p)+12). Die Sprache erforderte, dass alle Mitglieder aller Strukturtypen eindeutige Namen haben, mit der Ausnahme, dass die Wiederverwendung von Mitgliedsnamen ausdrücklich zulässig war, wenn jede Struktur, in der sie verwendet wurden, sie als gemeinsame Anfangssequenz behandelte.

Die Tatsache, dass Strukturtypen promisku verwendet werden konnten, ermöglichte es, dass sich Strukturen so verhalten, als ob sie überlappende Felder enthalten. Zum Beispiel gegebene Definitionen:

struct float1 { float f0;};
struct byte4  { char b0,b1,b2,b3; }; /* Unsigned didn't exist yet */

Code könnte eine Struktur vom Typ "float1" deklarieren und dann "Mitglieder" b0 ... b3 verwenden, um auf die einzelnen Bytes darin zuzugreifen. Wenn die Sprache so geändert wurde, dass jede Struktur einen separaten Namespace für ihre Mitglieder erhielt, brach Code, der auf der Fähigkeit beruhte, auf verschiedene Arten auf Dinge zuzugreifen, zusammen. Die Werte zum Trennen von Namespaces für verschiedene Strukturtypen reichten aus, um eine Änderung des Codes zu erfordern, aber der Wert solcher Techniken reichte aus, um eine Erweiterung der Sprache zu rechtfertigen, um sie weiterhin zu unterstützen.

Code, der geschrieben wurde, um die Fähigkeit zu nutzen , um die Speicherung innerhalb einer zuzugreifen , struct float1als ob es sich um eine wurden struct byte4durch Zugabe einer Erklärung an die Arbeit in der neuen Sprache gemacht werden könnten: union f1b4 { struct float1 ff; struct byte4 bb; };, Objekte als Typ deklarieren union f1b4;statt struct float1und Ersetzen Zugriffen auf f0, b0, b1, usw. mit. ff.f0, bb.b0, bb.b1usw. Zwar gibt es bessere Möglichkeiten , einen solchen Code sind , haben unterstützt werden können, die unionwar Ansatz zumindest etwas bearbeitbar, zumindest mit C89-Ära Interpretationen der Aliasing - Regeln.

Nehmen wir an, Sie haben n verschiedene Arten von Konfigurationen (nur eine Reihe von Variablen, die Parameter definieren). Mithilfe einer Aufzählung der Konfigurationstypen können Sie eine Struktur definieren, die die ID des Konfigurationstyps sowie eine Vereinigung aller verschiedenen Konfigurationstypen enthält.

Auf diese Weise können Sie überall dort, wo Sie die Konfiguration übergeben, anhand der ID bestimmen, wie die Konfigurationsdaten interpretiert werden sollen. Wenn die Konfigurationen jedoch sehr groß wären, müssten Sie nicht für jeden potenziellen Typ parallele Strukturen haben, die Speicherplatz verschwenden.

Ein jüngster Schub für die bereits erhöhte Bedeutung der Gewerkschaften wurde durch die in der jüngsten Version des C-Standards eingeführte strikte Aliasing-Regel gegeben .

Sie können Gewerkschaften verwenden, um zu tippen, ohne den C-Standard zu verletzen.
Dieses Programm hat ein nicht spezifiziertes Verhalten (weil ich das angenommen habe floatund unsigned intdie gleiche Länge habe), aber kein undefiniertes Verhalten (siehe hier ).

#include <stdio.h> 

union float_uint
{
    float f;
    unsigned int ui;
};

int main()
{
    float v = 241;
    union float_uint fui = {.f = v};

    //May trigger UNSPECIFIED BEHAVIOR but not UNDEFINED BEHAVIOR 
    printf("Your IEEE 754 float sir: %08x\n", fui.ui);

    //This is UNDEFINED BEHAVIOR as it violates the Strict Aliasing Rule
    unsigned int* pp = (unsigned int*) &v;

    printf("Your IEEE 754 float, again, sir: %08x\n", *pp);

    return 0;
}

Ich möchte ein gutes praktisches Beispiel für die Verwendung von union hinzufügen - das Implementieren eines Formelrechners / -interpreten oder das Verwenden einer Art davon bei der Berechnung (zum Beispiel möchten Sie modifizierbare Teile Ihrer Computerformeln zur Laufzeit verwenden - Gleichungen numerisch lösen - einfach beispielsweise). Daher möchten Sie möglicherweise Zahlen / Konstanten verschiedener Typen (Ganzzahlen, Gleitkommazahlen, sogar komplexe Zahlen) wie folgt definieren:

struct Number{
enum NumType{int32, float, double, complex}; NumType num_t;
union{int ival; float fval; double dval; ComplexNumber cmplx_val}
}

Sie sparen also Speicher und was noch wichtiger ist: Sie vermeiden dynamische Zuweisungen für wahrscheinlich extreme Mengen (wenn Sie viele zur Laufzeit definierte Zahlen verwenden) kleiner Objekte (im Vergleich zu Implementierungen durch Klassenvererbung / Polymorphismus). Interessanter ist jedoch, dass Sie mit dieser Art von Struktur immer noch die Kraft des C ++ - Polymorphismus nutzen können (wenn Sie beispielsweise ein Fan von Double Dispatching sind;). Fügen Sie einfach einen "Dummy" -Schnittstellenzeiger zur übergeordneten Klasse aller Zahlentypen als Feld dieser Struktur hinzu und zeigen Sie auf diese Instanz anstelle von / zusätzlich zum Rohtyp, oder verwenden Sie gute alte C-Funktionszeiger.

struct NumberBase
{
virtual Add(NumberBase n);
...
}
struct NumberInt: Number
{
//implement methods assuming Number's union contains int
NumberBase Add(NumberBase n);
...
}
struct NumberDouble: Number
{
 //implement methods assuming Number's union contains double
 NumberBase Add(NumberBase n);
 ...
}
//e.t.c. for all number types/or use templates
struct Number: NumberBase{
 union{int ival; float fval; double dval; ComplexNumber cmplx_val;}
 NumberBase* num_t;
 Set(int a)
 {
 ival=a;
  //still kind of hack, hope it works because derived classes of   Number    dont add any fields
 num_t = static_cast<NumberInt>(this);
 }
}

Sie können also Polymorphismus anstelle von Typprüfungen mit switch (type) verwenden - mit speichereffizienter Implementierung (keine dynamische Zuordnung kleiner Objekte) - wenn Sie dies benötigen.

Von http://cplus.about.com/od/learningc/ss/lowlevel_9.htm :

Die Verwendung von Gewerkschaften ist selten. Auf den meisten Computern sind die Größe eines Zeigers und eines Int normalerweise gleich. Dies liegt daran, dass beide normalerweise in ein Register in der CPU passen. Wenn Sie also einen Zeiger schnell und schmutzig auf ein int oder auf andere Weise umwandeln möchten, deklarieren Sie eine Union.

union intptr {   int i;   int * p; }; 
union intptr x; x.i = 1000; 
/* puts 90 at location 1000 */ 
*(x.p)=90; 

Eine andere Verwendung einer Union besteht in einem Befehl oder Nachrichtenprotokoll, in dem Nachrichten unterschiedlicher Größe gesendet und empfangen werden. Jeder Nachrichtentyp enthält unterschiedliche Informationen, aber jeder hat einen festen Teil (wahrscheinlich eine Struktur) und ein variables Teilbit. So können Sie es implementieren.

struct head {   int id;   int response;   int size; }; struct msgstring50 {    struct head fixed;    char message[50]; } struct

struct msgstring80 {struct head fixed; char message [80]; }
struct msgint10 {struct head fixed; int message [10]; } struct msgack {struct head fixed; int ok; } union messagetype {
struct msgstring50 m50; struct msgstring80 m80; struct msgint10 i10; struct msgack ack; }}

In der Praxis ist es sinnvoll, nur die aussagekräftigen Daten und nicht den verschwendeten Speicherplatz zu senden, obwohl die Gewerkschaften gleich groß sind. Ein msgack ist nur 16 Byte groß, während ein msgstring80 92 Byte groß ist. Wenn also eine Messagetypvariable initialisiert wird, wird das Größenfeld entsprechend dem Typ festgelegt. Dies kann dann von anderen Funktionen verwendet werden, um die richtige Anzahl von Bytes zu übertragen.

Gewerkschaften bieten die Möglichkeit, verschiedene Arten von Daten in einem einzigen Speicherbereich zu bearbeiten, ohne maschinenunabhängige Informationen in das Programm einzubetten. Sie sind analog zu Variantendatensätzen in Pascal

Nehmen wir als Beispiel an, wie es in einem Compiler-Symboltabellenmanager zu finden ist, dass eine Konstante ein int, ein float oder ein Zeichenzeiger sein kann. Der Wert einer bestimmten Konstante muss in einer Variablen des richtigen Typs gespeichert werden. Für die Tabellenverwaltung ist es jedoch am bequemsten, wenn der Wert dieselbe Speichermenge belegt und unabhängig von seinem Typ an derselben Stelle gespeichert wird. Dies ist der Zweck einer Union - eine einzelne Variable, die einen von mehreren Typen rechtmäßig enthalten kann. Die Syntax basiert auf Strukturen:

union u_tag {
     int ival;
     float fval;
     char  *sval;
} u;

Die Variable u ist groß genug, um den größten der drei Typen aufzunehmen. Die spezifische Größe ist implementierungsabhängig. Jeder dieser Typen kann u zugewiesen und dann in Ausdrücken verwendet werden, solange die Verwendung konsistent ist