Бьерн Страуструп - Язык программирования С++. Главы 2-4 - Структуры

2.3.8  Структуры

Массив представляет собой совокупность элементов одного типа, а структура является совокупностью элементов произвольных (практически) типов. Например:

    struct address {
        char* name;         // имя "Jim Dandy"
        long  number;       // номер дома 61
        char* street;       // улица "South Street"
        char* town;         // город "New Providence"
        char* state[2];     // штат 'N' 'J'
        int   zip;          // индекс 7974
    };

Здесь определяется новый тип, называемый address, который задает почтовый адрес. Определение не является достаточно общим, чтобы учесть все случаи адресов, но оно вполне пригодно для примера. Обратите внимание на точку с запятой в конце определения: это один из немногих в С++ случаев, когда после фигурной скобки требуется точка с запятой, поэтому про нее часто забывают.

Переменные типа address можно описывать точно так же, как и любые другие переменные,  а с помощью операции . (точка) можно обращаться к отдельным членам структуры. Например:

    address jd;
    jd.name = "Jim Dandy";
    jd.number = 61;

Инициализировать переменные типа struct можно так же, как массивы. Например:

     address jd = {
        "Jim Dandy",
         61, "South Street",
         "New Providence", {'N','J'}, 7974
     };

Но лучше для этих целей использовать конструктор ($$5.2.4). Отметим, что jd.state нельзя инициализировать строкой "NJ". Ведь строки оканчиваются нулевым символом '\0', значит в строке "NJ" три символа, а это на один больше, чем помещается в jd.state. К структурным объектам часто обращаются c помощью указателей, используя операцию ->. Например:

     void print_addr(address* p)
    {
      cout << p->name << '\n'
           << p->number << ' ' << p->street << '\n'
           << p->town << '\n'
           << p->state[0] << p->state[1]
           << ' ' << p->zip << '\n';
    }

Объекты структурного типа могут быть присвоены, переданы как фактические параметры функций и возвращены функциями в качестве результата. Например:

    address current;

   address set_current(address next)
   {
     address prev = current;
     current = next;
     return prev;
   }

Другие допустимые операции, например, такие, как сравнение (== и !=), неопределены. Однако пользователь может сам определить эти операции
(см. главу 7).

Размер объекта структурного типа не обязательно равен сумме размеров всех его членов. Это происходит по той причине, что на многих машинах требуется размещать объекты определенных типов, только выравнивая их по некоторой зависящей от системы адресации границе (или просто потому, что работа при таком выравнивании будет более эффективной ). Типичный пример - это выравнивание целого по словной границе. В результате выравнивания могут появиться "дырки" в структуре. Так, на уже упоминавшейся машине автора sizeof(address)
равно 24, а не 22, как можно было ожидать.

Следует также упомянуть, что тип можно использовать сразу после его появления в описании, еще до того, как будет завершено все описание. Например:

     struct link{
           link* previous;
           link* successor;
      };

Однако новые объекты типа структуры нельзя описать до тех пор, пока не появится ее полное описание. Поэтому описание

      struct no_good {
         no_good member;
      };

является ошибочным (транслятор не в состоянии установить размер no_good). Чтобы позволить двум (или более) структурным типам ссылаться друг на друга, можно просто описать имя одного из них как имя некоторого структурного типа. Например:

      struct list;        // будет определено позднее

      struct link {
           link* pre;
           link* suc;
           list* member_of;
      };

      struct list {
           link* head;
      };

Если бы не было первого описания list, описание члена link привело бы к синтаксической ошибке. Можно также использовать имя структурного типа еще до того, как тип будет определен, если только это использование не предполагает знания размера структуры. Например:

        class S;        // 'S' - имя некоторого типа

        extern S a;

        S f();

        void g(S);

Но приведенные описания можно использовать лишь после того, как тип S
будет определен:

        void h()
        {
          S a;        // ошибка: S - неописано
          f();        // ошибка: S - неописано
          g(a);       // ошибка: S - неописано
        }