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

Ich finde C++ Gewerkschaften ziemlich cool. Es scheint, dass die Menschen in der Regel denke nur an die use-case, wo man will, ändern Sie den Wert eines union-Instanz "in-place" (die, wie es scheint, nur dazu dient, den Speicher zu speichern oder auszuführen zweifelhaft Konvertierungen).

In der Tat, der Gewerkschaften, von großer Kraft, wie eine software-engineering-tool auch wenn Sie nie ändern Sie den Wert einer union-Instanz.

Anwendungsfall 1: das Chamäleon

Mit den Gewerkschaften, Sie neu zu gruppieren einer Anzahl von beliebigen Klassen unter einer Bezeichnung, die nicht ohne ähnlichkeiten mit dem Fall von einer Basis-Klasse und Ihrer abgeleiteten Klassen. Was ändert sich, jedoch ist das, was Sie tun und nicht tun können, die mit einer bestimmten union-Instanz:

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

Scheint es, dass der Programmierer sich sicher sein, den Typ des Inhalts einer angegebenen union Instanz, wenn er es benutzen möchte. Es ist der Fall in der Funktion f oben. Allerdings, wenn eine Funktion erhalten einen union-Instanz als argument übergeben, wie es der Fall mit g oben, dann würde es nicht wissen, was zu tun. Das gleiche gilt für Funktionen, die Rückkehr einer union-Instanz finden Sie unter h: wie will der Anrufer wissen, was drin ist?

Wenn ein union-Instanz wird nie als argument übergeben oder als Rückgabewert, dann ist es bestimmt noch ein sehr eintöniges Leben, mit Spitzen von Aufregung, wenn der Programmierer entscheidet, seinen Inhalt zu ändern:

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

Und das ist die (un -) beliebte Falle der Gewerkschaften. Ein anderer Anwendungsfall ist, wenn ein union-Instanz kommt mit etwas, das erzählt Sie Ihren Typ.

Use case 2: "Schön, Sie zu treffen, ich bin object von Class"

Angenommen, ein Programmierer gewählt, um immer paar bis ein union-Instanz mit Typ-Deskriptor (ich überlasse es dem Leser frei, sich vorstellen, eine Implementierung für ein solches Objekt). Diese Niederlagen der Zweck der union selbst wenn das, was der Programmierer will, um Speicherplatz zu sparen und die Größe des type-descriptor ist nicht unerheblich in Bezug auf diese von der union. Aber nehmen wir an, dass es von entscheidender Bedeutung, dass die union Instanz sein könnte als argument übergeben oder als Rückgabewert mit der angerufene oder Anrufer-nicht zu wissen, was drin ist.

Dann hat der Programmierer zu schreiben switch control-flow-statement zu sagen, Bruce Wayne abgesehen von einem Holzstab oder etwas vergleichbares. Es ist nicht allzu schlimm, wenn es gibt nur zwei Arten von Inhalten in der union, aber offensichtlich ist die union nicht skaliert nicht mehr.

Use case 3:

Als die Autoren der eine Empfehlung für die ISO-C++ - Standard steckte es zurück in 2008,

Vielen wichtigen problem-Domänen erfordern entweder eine große Anzahl von Objekten oder begrenzten Speicher
Ressourcen. In diesen Situationen, um Speicherplatz zu sparen ist sehr wichtig, und eine Gewerkschaft ist oft der perfekte Weg, das zu tun. In der Tat, ein üblicher Fall ist die situation dort, wo eine Gewerkschaft, die sich nie ändert seine aktive Mitglied während seiner Lebensdauer. Es kann konstruiert werden, kopiert werden, und zerstört, als ob es eine struct mit nur einem Element. Eine typische Anwendung HIERFÜR wäre zum erstellen einer heterogenen Sammlung von nicht verwandten Arten, die nicht dynamisch allokiert (vielleicht sind Sie im Ort, gebaut in einer Karte, oder Mitglieder eines Arrays).

Und jetzt ein Beispiel mit einem UML-Klassendiagramm:

Die situation im Klartext: ein Objekt der Klasse kann Objekte von jeder Klasse unter B1, ..., Bn, und höchstens einer von jedem Typ, mit n ist ein ziemlich große Zahl, sagen mindestens 10.

Wir nicht wollen, um zusätzliche Felder hinzuzufügen (Daten-Mitglieder) zu Einer etwa so:

private:
    B1 b1;
    .
    .
    .
    Bn bn;

weil n variieren können, (wir könnten hinzufügen möchten Bx-Klassen zu mischen), und da würde ein Chaos mit Konstruktoren und weil die Objekte in Anspruch nehmen würde, sehr viel Platz.

Könnten wir eine verrückte Behälter void* Zeiger auf Bx Objekte mit Gips, um Sie abzurufen, aber das ist fugly und so C-style... aber noch wichtiger ist, die würde lassen Sie uns mit dem Leben von vielen dynamisch zugewiesenen Objekte zu verwalten.

Statt, was getan werden kann, ist dies:

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

Dann, um den Inhalt einer union-Instanz aus data verwenden Sie a.get(TYPE_B2).b2 " und ähnliches, wo a ist eine Klasse A Instanz.

Dies ist umso mächtiger, da die Gewerkschaften sind uneingeschränkt in C++11. Sehen das Dokument verknüpft oben oder dieser Artikel für details.

InformationsquelleAutor der Antwort jrsala

Herb Sutter schrieb in GOTW vor etwa sechs Jahren, mit Schwerpunkt Hinzugefügt:

"Aber glaube nicht, dass es den Gewerkschaften nur ein überbleibsel aus früheren Zeiten. Gewerkschaften sind vielleicht am meisten nützlich für Sie sparen Speicherplatz, indem Daten zu überlappen, und das ist immer noch wünschenswert, in C++ und in der heutigen modernen Welt. Zum Beispiel, einige der fortschrittlichsten C++ standard-Bibliothek Implementierungen in der Welt jetzt gerade nutzen dieser Technik für die Umsetzung des "small string optimization" Optimierung alternative, die wiederverwendet, die Speicherung in einem string-Objekt selbst: für große Zeichenfolgen, die Leerzeichen innerhalb der Zeichenfolge-Objekt speichert die üblichen Zeiger auf den dynamisch zugewiesenen Puffer und Hauswirtschaft Informationen wie die Größe des Puffers; für kleine strings, die den gleichen Raum ist, anstatt wiederverwendet zu speichern, die string-Inhalte direkt und gänzlich zu vermeiden dynamic memory allocation. Für mehr über die small string optimization (und andere string-Optimierungen und pessimizations in beträchtliche Tiefe), siehe... ."

Und für ein weniger nützliches Beispiel, siehe die lange, aber ergebnislose Frage gcc, strict-aliasing und Gießen durch eine Gewerkschaft.

InformationsquelleAutor der Antwort Joseph Quinsey

Gewerkschaften sind nützlich beim Umgang mit byte-Ebene (low level) Daten.

Einer meiner letzten Verwendung war auf IP-Adresse Modellierung, die sieht wie folgt aus :

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

InformationsquelleAutor der Antwort YeenFei

Beispiel, wenn ich habe eine union:

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

        };
...
}

dies ermöglicht mir den Zugriff auf meine Daten als array oder die Elemente.

Ich habe eine union zu haben, die unterschiedlichen Begriffe auf den gleichen Wert. In der Bildverarbeitung, egal ob ich arbeiten war auf Spalten oder die Breite oder die Größe in X-Richtung, kann es verwirrend werden. Zu alleve dieses problem, ich benutze einen union, so weiß ich, welche Beschreibungen gehen zusammen.

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

InformationsquelleAutor der Antwort DannyK

Eine brillante Verwendung der union-memory-alignment, das fand ich in der PCL(Point Cloud Library) - source-code. Die einzigen Daten die Struktur in der API kannst zwei Architekturen: CPU mit SSE-Unterstützung sowie die CPU ohne SSE-support. ZB: die Datenstruktur für PointXYZ ist

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

Den 3 Schwimmern sind gepolstert und mit einem zusätzlichen Schwimmer für die SSE-Ausrichtung.
Also für

PointXYZ point;

Kann der Benutzer den access point.Daten[0] oder Punkt.x (abhängig von der SSE-Unterstützung) für den Zugriff auf sagen, die x-Koordinate.
Mehr ähnliche bessere Nutzung details sind auf folgendem link: PCL-Dokumentation PointT Typen

InformationsquelleAutor der Antwort Shubham Verma

Aus der Wikipedia-Artikel über die Gewerkschaften:

Den primären nutzen eines union
zu Platz sparen,, denn es bietet eine
Weise lassen sich viele verschiedene Arten werden
gespeichert in den gleichen Raum. Gewerkschaften
bieten Rohöl Polymorphismus. Allerdings
es gibt keine überprüfung der Typen, so dass es
ist der Programmierer um sicher zu sein
dass die richtigen Felder zugegriffen werden, in
verschiedenen Kontexten. Das entsprechende Feld ein
eine union-variable ist in der Regel
bestimmt durch den Zustand der anderen
Variablen, die möglicherweise in einem umschließenden
struct.

Einer gemeinsamen Programmiersprache C ++ idiom verwendet
Gewerkschaften durchzuführen, was C++ ruft ein
reinterpret_cast, durch die Zuordnung zu einer
Feld einer union und Lesen von
andere, so wie dies im code
hängt von der raw-Darstellung
die Werte.

InformationsquelleAutor der Antwort thkala

Einen letzten Schub auf die bereits hohe Bedeutung des unions wurde von den Strict-Aliasing-Regel eingeführt in der letzten version der C-standard.

Die Sie verwenden können Gewerkschaften tun, um Typ-Zweideutigkeiten ohne Verletzung der C-standard.

Dieses Programm hat unspezifisch Verhalten (weil ich davon ausgehe, dass float und unsigned int haben die gleiche Länge), aber nicht 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;
}

InformationsquelleAutor der Antwort

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

Den verwendet der union sind wenige und weit zwischen. Auf den meisten Computern, die Größe
ein pointer und ein int sind in der Regel die gleichen, weil beide
in der Regel passen in ein register in der CPU. Also, wenn Sie wollen, eine kurze
und schmutzige Besetzung von einem Zeiger auf eine int-oder die andere Weise erklären
union.

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

Andere Verwendung, die union ist in eine Befehls-oder message-Protokoll, wo
unterschiedliche Größe der Nachrichten gesendet und empfangen werden. Jeder Nachrichtentyp wird
halten Sie unterschiedliche Informationen, aber jede von Ihnen hat einen festen Teil (wahrscheinlich ein
struct) und einen Variablen Teil, bit. Dies ist, wie Sie es umsetzen..

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

struct msgstring80 { struct head fixed; char Nachricht[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, obwohl die Gewerkschaften die gleiche Größe haben, macht es Sinn,
nur senden Sie die aussagekräftige Daten und nicht Platz verschwendet. Ein msgack ist nur
16 bytes an Größe, während ein msgstring80 92 bytes. Also, wenn ein
messagetype-variable wird initialisiert, es hat seine Größe-Feld gesetzt
nach, welche Art es ist. Diese können dann verwendet werden, durch andere
Funktionen zu übertragen, die richtige Anzahl von bytes.

InformationsquelleAutor der Antwort ανώνυμος

In der Anfangszeit von C (z.B. als dokumentierte in 1974), alle Strukturen, die einen gemeinsamen Namensraum für Ihre Mitglieder. Jedes Mitglied name wurde im Zusammenhang mit einem Typ und einem offset; wenn "wd_woozle" wurde ein "int" bei offset 12, dann einen Zeiger p jeder Struktur-Typ, p->wd_woozle wäre äquivalent zu *(int*)(((char*)p)+12). Die Sprache erforderlich, dass alle Mitglieder von allen Strukturen, die Typen haben eindeutige Namen außerdass es ausdrücklich erlaubt die Wiederverwendung von Elementnamen in Fällen, in denen jede Struktur, wo Sie verwendet wurden, behandelten Sie wie einen gemeinsamen anfangs-Sequenz.

Die Tatsache, dass Struktur-Typen verwendet werden könnten promiscuously es möglich gemacht haben, die Strukturen so Verhalten, als wäre Sie enthielten überlappende Felder. Beispiel-Definitionen:

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

code deklarieren Sie eine Struktur vom Typ "float1", und verwenden Sie dann "Mitglieder" b0...b3, um den Zugriff auf die einzelnen bytes darin. Wenn die Sprache geändert wurde, so dass jede Struktur erhalten würde, einen separaten Namensraum für seine Mitglieder, code, stützte sich auf die Fähigkeit, Zugriff auf Dinge mehrere Möglichkeiten brechen würde. Die Werte der Trennung von namespaces für verschiedene Struktur-Typen ausreichend war, zu verlangen, dass dieser code geändert werden, um es aufnehmen, aber die Wert solcher Techniken war ausreichend für die Begründung der Erweiterung der Sprache weiter zu fördern.

Code, die geschrieben worden war, zu nutzen, die Fähigkeit zum Zugriff auf den Speicher innerhalb einer struct float1 als wäre es ein struct byte4 gemacht werden konnten, in der neuen Sprache durch das hinzufügen einer Erklärung: union f1b4 { struct float1 ff; struct byte4 bb; }; Deklaration von Objekten als Typ union f1b4; eher als struct float1und ersetzen Zugriffe auf f0b0b1 usw. mit ff.f0bb.b0bb.b1 usw. Zwar gibt es bessere Möglichkeiten, einen solchen code hätte unterstützt, die union Ansatz war zumindest etwas praktikabler, zumindest mit C89-ära Interpretationen der aliasing-Regeln.

InformationsquelleAutor der Antwort supercat