2.6.2. Объединения.

• Глава 2. Описания и константы
  • 2.6. Экономия памяти
    • 2.6.2. Объединения

Рассмотрим таблицу имен, в которой каждый элемент содержит имя и его значение. Значение может задаваться либо строкой, либо целым числом:

           struct entry {
              char* name;
              char  type;
              char* string_value;  // используется если type == 's'
              int   int_value;     // используется если type == 'i'
           };
           void print_entry(entry* p)
           {
             switch(p->type) {
             case 's':
                  cout << p->string_value;
                  break;
             case 'i':
                  cout << p->int_value;
                  break;
             default:
                  cerr << "type corrupted\n";
                  break;
             }
           }

Поскольку переменные string_value и int_value никогда не могут использоваться одновременно, очевидно, что часть памяти пропадает впустую. Это можно легко исправить, описав обе переменные как члены объединения, например, так:

           struct entry {
              char* name;
              char  type;
              union {
                 char* string_value; // используется если type == 's'
                 int   int_value;    // используется если type == 'i'
              };
           };

Теперь гарантируется, что при выделении памяти для entry члены string_value и int_value будут размещаться с одного адреса, и при этом не нужно менять все части программы, работающие с entry. Из этого следует, что все члены объединения вместе занимают такой же объем памяти, какой занимает наибольший член объединения.
Надежный способ работы с объединением заключается в том, чтобы выбирать значение с помощью того же самого члена, который его записывал. Однако, в больших программах трудно гарантировать, что объединение используется только таким способом, а в результате использования не того члена обЪединения могут возникать трудно обнаруживаемые ошибки. Но можно встроить объединение в такую структуру, которая обеспечит правильную связь между значением поля типа и текущим типом члена объединения ($$5.4.6).
Иногда объединения используют для "псевдопреобразований" типа (в основном на это идут программисты, привыкшие к языкам, в которых нет средств преобразования типов, и в результате приходится обманывать транслятор). Приведем пример такого "преобразования" int в int* на машине VAX, которое достигается простым совпадением разрядов:

           struct fudge {
                union {
                  int  i;
                  int* p;
                };
           };

           fudge a;
           a.i = 4095;
           int* p = a.p;    // некорректное использование

В действительности это вовсе не преобразование типа, т.к. на одних машинах int и int* занимают разный объем памяти, а на других целое не может размещаться по адресу, задаваемому нечетным числом. Такое использование объединений не является переносимым, тогда как существует переносимый способ задания явного преобразования типа ($$3.2.5).
Иногда объединения используют специально, чтобы избежать преобразования типов. Например, можно использовать fudge, чтобы узнать, как представляется указатель 0:

           fudge.p = 0;
           int i = fudge.i;    // i необязательно должно быть 0

Объединению можно дать имя, то есть можно сделать его полноправным типом. Например, fudge можно описать так:

           union fudge {
                 int  i;
                 int* p;
           };

и использовать (некорректно) точно так же, как и раньше. Вместе с тем, поименованные объединения можно использовать и вполне корректным и оправданным способом (см. $$5.4.6).