ich habe folgendes Listing:

union tWandler
{
    struct
    {
        unsigned char hi;
        unsigned char lo;
    } byte;
    unsigned short word;
} Wandler;

int main()
{
    Wandler.word = 7656;
    cout << (int)Wandler.byte.hi << endl;
    cout << (int)Wandler.byte.lo << endl;
}

Könntet ihr mir erläutern bzw. weiss jemand, was dieser Code genau tut? Und werden solche Unions heute noch viel verwendet?

Vielen Dank schonmal!

siehe folgendes Beispiel, das erklärt mehr oder weniger, warum das Ergebnis bei dir so aussieht, wie es aussieht:

unsigned short zahl = 7656;
	unsigned char res[2];

	memcpy(res, &zahl, sizeof(unsigned short));
	cout << zahl << endl;
	cout << (int)res[0] << endl;
	cout << (int)res[1] << endl;

EDIT:
vielleicht noch ergaenzend
Deine Zahl 7656 sieht Binaer so aus und wird dann auf char[2] "verteilt"

BYTE res[1]  BYTE res[0]
00011101     11101000        => 7656
=29          =232

Ich nehme mal an, wenn du nach unions fragst, dann hast du dich zumindest ein bisschen mit dem Thema beschäftigt und weißt, was sie machen. Das werde ich hier nämlich nicht erklären.

Dies ist die Idee des Programmierers: Zuerst speichert das Programm einen short Wert in der union als Wandler.word. Vorausgesetzt, sizeof(short)=2 und Big-Endian für shorts, steht im Speicher dann sowas:

--------------------------------------------------
| Erster Teil von Word  | Zweiter Teil von Word  |
--------------------------------------------------

|                Wandler.Word                    |
|-----------------  Wandler ---------------------|

Da es sich um eine union handelt, kann der gleiche Speicher aber auch so angesprochen werden:

--------------------------------------------------
|    Wandler.hi         |     Wandler.lo         |
--------------------------------------------------

|-----------------  Wandler ---------------------|

Und so kann man zwei chars aus dem short Wert erhalten.

Nun die Probleme:
1. Der Standard sagt explizit, dass das Verhalten von unions nur definiert ist, wenn man wieder das gleiche Element liest, dass man vorher gespeichert hat. Also eigentlich dürfte das Programm nach dem Speichern des shorts die union nur als short ansprechen, wenn das Verhalten definiert sein soll. Dass es trotzdem funktioniert liegt daran, dass praktisch alle Compiler unions so implementieren wie oben erklärt. Sie brauchen es aber nicht zwangsläufig so zu machen.
2. Es werden allerlei Annahmen gemacht, die nicht unbedingt erfüllt sind. Weder sizeof(short)=2 noch das Format in dem ein short im Speicher liegt sind definiert.

Die Verwendung von unions ist eher ungewöhnlich, sie sind eigentlich ein Relikt aus Speichersparzeiten. Denn eigentlich sind sie dazu gut, Variablen platzsparend zu speichern. Die Verwendung wie hier ist ziemlich unsauber, wie schon erläutert. Man könnte genausogut einen reinterpret_cast machen. Oder besser noch: Rechnen. Denn dann ist man auf der sicheren Seite.

Okay, vielen Dank euch für die ausführliche Erklärung!
So wie ich das sehe sollten also Unions eigentlich nicht mehr verwendet werden, aber es ist natürlich trotzdem praktisch zu wissen wie sie funktionieren - und jetzt ist alles klar!

Es kann schon Sinn machen, du solltest sie nicht aus Prinzip nicht verwenden. Nur ist es halt relativ selten, dass man sie zu ihrem eigentlichen Einsatzzweck braucht.

Den Missbrauch wie in deinem Beispiel, sollte man aber vermeiden.

Es kann schon Sinn machen, du solltest sie nicht aus Prinzip nicht verwenden. Nur ist es halt relativ selten, dass man sie zu ihrem eigentlichen Einsatzzweck braucht.

Den Missbrauch wie in deinem Beispiel, sollte man aber vermeiden.

Klar, aus Prinzip nicht verwenden ist immer schlecht. Aber kannst du mir ein konkretes Beispiel für den Einsatzzweck nennen? Ich sehe dahinter im Moment noch nicht wirklich einen Sinn (ausser zum Sparen von Speicherplatz).

Small String Optimization.

Sorry für die Frage, aber was ist das?

Okay, vielen Dank euch für die ausführliche Erklärung!
So wie ich das sehe sollten also Unions eigentlich nicht mehr verwendet werden

"Nicht verwenden" stimmt nicht. Du kannt nur nicht, bezogen auf obiges Beispiel, darauf schliessen was in "word" steht, wenn Du "byte" beschrieben hast und umgekehrt. In einer Union ist nur das zuletzt beschriebene Element gültig. Zum Zerlegen eines 2-Byte Wertes in einzelne Bytes sind Unions nicht geeignet. Dazu nimm lieber Shift-Operatoren.

class String{
   virtual ~String();//die ersten 4 Bytes
   union{
      struct{//normal mit new angelegt
        char* begin;
        char* end;
        char* maxEnd;
      }
      struct{//kleiner string
        char length;
        char data[11];
      }
      struct{//literal
        char* begin;
        char* end;
      }
   }

"Nicht verwenden" stimmt nicht. Du kannt nur nicht, bezogen auf obiges Beispiel, darauf schliessen was in "word" steht, wenn Du "byte" beschrieben hast und umgekehrt. In einer Union ist nur das zuletzt beschriebene Element gültig. Zum Zerlegen eines 2-Byte Wertes in einzelne Bytes sind Unions nicht geeignet. Dazu nimm lieber Shift-Operatoren.

Sehe ich das richtig, dass Shift-Operatoren bitweise kopieren können?

Z schrieb:

"Nicht verwenden" stimmt nicht. Du kannt nur nicht, bezogen auf obiges Beispiel, darauf schliessen was in "word" steht, wenn Du "byte" beschrieben hast und umgekehrt. In einer Union ist nur das zuletzt beschriebene Element gültig. Zum Zerlegen eines 2-Byte Wertes in einzelne Bytes sind Unions nicht geeignet. Dazu nimm lieber Shift-Operatoren.

Sehe ich das richtig, dass Shift-Operatoren bitweise kopieren können?

Nein, die rechnen bloß. Das sieht dann aber so aus, als hätten sie bitweise kopiert.

struct tMessage{
  tMessageTyp type;
  union{
    tLargeMessage large;
    tShortMessage short;
    tWhateverMessage whatever;
    int nureinint;
    tUndSoweiter undsoweiter;
  };
};