Глава 2

Описания и Константы

Совершенство достигается только к моменту краха.
- С.Н. Паркинсон

2.1 Описания

Прежде чем имя (идентификатор) может быть использовано в C++ программе, он должно быть описано. Это значит, что надо задать его тип, чтобы сообщить компилятору, к какого вида объектам относится имя. Вот несколько примеров, иллюстрирующих разнообразие описаний:

  char ch;
  int count = 1;
  char* name = "Bjarne";
  struct complex { float re, im; };
  complex cvar;
  extern complex sqrt(complex);
  extern int error_number;
  typedef complex point;
  float real(complex* p) { return p->re; };
  const double pi = 3.1415926535897932385;
  struct user;

Как можно видеть из этих примеров, описание может делать больше чем просто ассоциировать тип с именем. Большинство описаний являются также определениями; то есть они также определяют для имени сущность, к которой оно относится. Для ch, count и cvar этой сущностью является соответствующий объем памяти, который должен использоваться как переменная - эта память будет выделена. Для real это заданная функция. Для constant pi это значение 3.1415926535897932385. Для complex этой сущностью является новый тип. Для point это тип complex, поэтому point становится синонимом complex. Только описания

  extern complex sqrt(complex);
  extern int error_number;
  struct user;

не являются одновременно определениями. Это означает, что объект, к которому они относятся, должен быть определен где-то еще. Код (тело) функции sqrt должен задаваться неким другим описанием, память для переменной error_number типа int должна выделяться неким другим описанием, и какое-то другое описание типа user должно определять, что он из себя представляет. В C++ программе всегда должно быть только одно определение каждого имени, но описаний может быть много, и все описания должны согласовываться с типом объекта, к которому они относятся, поэтому в этом фрагменте есть две ошибки:

  int count;
  int count;               // ошибка: переопределение
  exnern int error_number;
  exnern int error_number; // ошибка: несоответствие типов

2.1.1 Область Видимости

Описание вводит имя в области видимости; то есть, имя может использоваться только в определенной части программы. Для имени, описанного в функции (такое имя часто называют локальным), эта область видимости простирается от точки описания до конца блока, в котором появилось описание; для имени не в функции и не в классе (называемого часто глобальным именем) область видимости простирается от точки описания до конца файла, в котором появилось описание. Описание имени в блоке может скрывать (прятать) описание во внутреннем блоке или глобальное имя. Это значит, что можно переопределять имя внутри блока для ссылки на другой объект. После выхода из блока имя вновь обретает свое прежнее значение. Например:

  int x;            // глобальное x
  f() {
      int x;        // локальное x прячет глобальное x
      x = 1;        // присвоить локальному x
      {
          int x;    // прячет первое локальное x
          x = 2;    // присвоить второму локальному x
      }
      x = 3;        // присвоить первому локальному x
  }
  int* p = &x;      // взять адрес глобального x

Скрытие имен неизбежно при написании больших программ. Однако читающий человек легко может не заметить, что имя скрыто, и некоторые ошибки, возникающие вследствие этого, очень трудно обнаружить, главным образом потому, что они редкие. Значит скрытие имен следует минимизировать. Использование для глобальных переменных имен вроде i или x напрашивается на неприятности.
С помощью применения операции разрешения области видимости :: можно использовать скрытое глобальное имя. Например:

  int x;
  f()
  {
      int x = 1;      // скрывает глобальное x
      ::x = 2;        // присваивает глобальному x
  }

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

  int x;
  f()
  {
      int x = x;    // извращение
  }

Это не является недопустимым, хотя и бессмысленно, и компилятор предупредит, что x "used before set" ("использовано до того, как задано"), если вы попробуете так сделать. Можно, напротив, не применяя операцию ::, использовать одно имя для ссылки на два различных объекта в блоке. Например:

  int x;
  f()             // извращение
  {
      int y = x;  // глобальное x
      int x = 22;
      y = x;      // локальное x
  }

Переменная y инициализируется значением глобального x, 11, а затем ему присваивается значение локальной переменной x, 22.
Имена параметров функции считаются описанными в самом внешнем блоке функции, поэтому

  f(int x)
  {
      int x;        // ошибка
  }

2.1.2 Объекты и Адреса (Lvalue)

2.1.3 Время Жизни

2.2 Имена

2.3 Типы

Каждое имя (идентификатор) в C++ программе имеет ассоциированный с ним тип. Этот тип определяет, какие операции можно применять к имени (то есть к объекту, на который оно ссылается), и как эти операции интерпретируются. Например:

  int error number;
  float real(complex* p);

  Поскольку error_number  описано как  int, его  можно присваивать,
использовать в  арифметических выражениях  и т.д. Тогда как функция
real может вызываться с адресом complex в качестве параметра. Можно
взять адрес  любого из  них. Некоторые  имена, вроде int и complex,
являются именами типов. Обычно имя типа используется в описании для
спецификации другого имени. Единственные отличные от этого действия
над именем  типа -  это sizeof  (для определения количества памяти,
которая требуется  для хранения объекта типа) и new (для размещения
объекта типа в свободной памяти). Например:

  main()
  {
      int* p = new int;
      cout << "sizeof(int)=" << sizeof(int) " \n"; } 

  float f;
  char* p;
  //...
  long ll = long(p);     // преобразует p в long
  int i = int(f);        // преобразует f в int

2.3.1 Основные Типы

В C++ есть набор основных типов, которые соответствуют наиболее общим основным единицам памяти компьютера и наиболее общим основным способам их использования:

  char
  short int
  int
  long int

для представления целых различных размеров,

  float
  double

для представления чисел с плавающей точкой,

  unsigned char
  unsigned short int
  unsigned int
  unsigned long int

для представления  беззнаковых целых,  логических значений, битовых
массивов и  т.п. Для большей компактности записи можно опускать int
в комбинациях  из нескольких  слов, что не меняет смысла; так, long
означает long int, и unsigned означает unsigned int. В общем, когда
в описании опущен тип, он предполагается int. Например:

  const a = 1;
  static x;

все определяют объект типа int.

  Целый тип  char наиболее удобен для хранения и обработки символов
на данном  компьютере; обычно  это 8-битовый байт. Размеры объектов
C++ выражаются  в единицах  размера char,  поэтому  по  определению
sizeof(char)==1. В  зависимости  от  аппаратного  обеспечения  char
является  знаковым   или  беззнаковым  целым.  Тип  unsigned  char,
конечно, всегда  беззнаковый, и  при его  использовании  получаются
более переносимые  программы, но из-за применения его вместо просто
char могут возникать значительные потери в эффективности.

  Причина того, что предоставляется более чем один целый тип, более
чем один беззнаковый тип и более чем один тип с плавающей точкой, в
том,   чтобы    дать   возможность   программисту   воспользоваться
характерными  особенностями   аппаратного  обеспечения.  На  многих
машинах между  различными разновидностями основных типов существуют
значительные различия  в потребностях  памяти, временах  доступа  к
памяти и  временах вычислений.  Зная машину обычно легко, например,
выбрать  подходящий   тип  для   конкретной  переменной.   Написать
действительно переносимую  программу нижнего  уровня  сложнее.  Вот
все, что гарантируется относительно размеров основных типов:

     1==sizeof(char)<=sizeof(short)<= sizeof(int)<="sizeof(long)" sizeof(float)<="sizeof(double)" 

2.3.2 Неявное Преобразование Типа

2.3.3 Производные Типы

Другие типы модно выводить из основных типов (и типов, определенных пользователем) посредством операций описания:

и механизма определения структур. Например:

  int* a;
  float v[10];
  char* p[20];    // вектор из 20 указателей на символ
  void f(int);
  struct str { short length; char* p; };

2.3.4 Тип void

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

 void f()     // f не возвращает значение
 void* pv;    // указатель на объект неизвестного типа

  Переменной типа  void* можно присваивать указатель любого типа. На
первый взгляд  это может показаться не особенно полезным, поскольку
void* нельзя  разыменовать, но  именно это ограничение и делает тип
void*  полезным.  Главным  образом,  он  применяется  для  передачи
указателей функциям,  которые не  позволяют сделать предположение о
типе объекта,  и для возврата из функций нетипизированных объектов.
Чтобы  использовать   такой  объект,   необходимо  применить  явное
преобразование типа.  Подобные функции  обычно находятся  на  самом
нижнем уровне  системы, там,  где осуществляется работа с основными
аппаратными ресурсами. Например:

  void* allocate(int size);    // выделить
  void deallocate(void*);      // освободить
  f() {
      int* pi = (int*)allocate(10*sizeof(int));
      char* pc = (char*)allocate(10);
  //...
  deallocate(pi);
  deallocate(pc);
  }

2.3.5 Указатели

Для большинства типов T T* является типом указатель на T. То есть, в переменной типа T* может храниться адрес объекта типа T. Для указателей на вектора и указателей на функции вам, к сожалению, придется пользоваться более сложной записью:

  int* pi;
  char** cpp;             // указатель на указатель на char
  int (*vp)[10];          // указатель на вектор из 10 int'ов
  int (*fp)(char, char*); // указатель на функцию
                          // получающую параметры (char, char*)
                          // и возвращающую int

 Основная операция над указателем - разыменование, то есть ссылка на
объект,  на   который  указывает   указатель.  Эта  операция  также
называется  косвенным  обращением.  Операция  разыменования  -  это
унарное * (префиксное). Например:

 char c1 = 'a';
 char* p = &c1;    // в p хранится адрес c1
 char c2 = *p;    // c2 = 'a'

Переменная, на  которую указывает  p,- это  c1, а значение, которое
хранится в  c1, это  'a', поэтому присваиваемое c2 значение *p есть
'a'.

  Над  указателями   можно  осуществлять  некоторые  арифметические
действия. Вот,  например, функция,  подсчитывающая число символов в
строке (не считая завершающего 0):

  int strlen(char* p)
  {
      int i = 0;
      while (*p++) i++;
      return i;
  }

Другой способ  найти длину состоит в том, чтобы сначала найти конец
строки, а затем вычесть адрес начала строки из адреса ее конца:

  int strlen(char* p)
  {
      char* q = p;
      while (*q++) ;
      return q-p-1;
  }

2.3.6 Вектора

Для типа T T[size] является типом "вектор из size элементов типа T". Элементы индексируются (нумеруются) от 0 до size-1. Например:

  float v[3];   // вектор из трех float: v[0], v[1], v[2]
  int a[2][5];  // два вектора из пяти int
  char* vpc;    // вектор из 32 указателей на символ

Цикл для  печати целых значений букв нижнего регистра можно было бы
написать так:

  extern int strlen(char*);
  char alpha[] = "abcdefghijklmnoprstuvwxyz";
  main()
  {
      int sz = strlen(alpha);
      for (int i=0; i. 

2.3.7 Указатели и Вектора

Указатели и вектора в C++ связаны очень тесно. Имя вектора можно использовать как указатель на его первый элемент, поэтому пример с алфавитом можно было написать так:

  char alpha[] = "abcdefghijklmnopqrstuvwxyz";
  char* p = alpha;
  char ch;
  while (ch = *p++)
      cout << chr(ch) << "=" << ch
           << " << oct(ch) << "\n"; 

  char* p = &alpha[0];

  Эта эквивалентность  широко используется  в  вызовах  функций,  в
которых векторный  параметр  всегда  передается  как  указатель  на
первый элемент вектора; так, в примере

  extern int strlen(char*);
  char v[] = "Annemarie";
  char* p = v;
  strlen(p);
  strlen(v);

2.3.8 Структуры

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

  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 не является достаточным для
работы  с   полным  почтовым   адресом,     но  в  качестве  примера
достаточен). Обратите внимание на точку с запятой в конце; это одно
из очень  немногих мест  в C++,  где  необходимо  ставить  точку  с
запятой после  фигурной скобки,  поэтому люди  склонны забывать  об
этом.

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

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

  Запись, которая  использовалась для инициализации векторов, можно
применять и к переменным структурных типов. Например:

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

2.3.9 Эквивалентность типов

Два структурных типа являются различными даже когда они имеют одни и те же члены. Например:

  struct s1 { int a; };
  struct s2 { int a; };

есть два разных типа, поэтому

  s1 x;
  s2 y = x;    // ошибка: несоответствие типов

Структурные типы отличны также от основных типов, поэтому

  s1 x;
  int i = x;    // ошибка: несоответствие типов

  Однако, существует  механизм для  описания нового  имени для типа
без введения нового типа. Описание с префиксом typedef описывает не
новую переменную данного типа, а новое имя этого типа. Например:

  typedef char* Pchar;
  Pchar p1, p2;
  char* p3 = p1;

2.3.10 Ссылки

2.3.11 Регистры

Во многих машинных архитектурах можно обращаться к (небольшим) объектам заметно быстрее, когда они помещены в регистр. В идеальном случае компилятор будет сам определять оптимальную стратегию использования всех регистров, доступных на машине, для которой компилируется программа. Однако это нетривиальная задача, поэтому иногда программисту стоит дать подсказку компилятору. Это делается с помощью описания объекта как register. Например:

  register int i;
  register point cursor;
  register char* p;

2.4 Константы

2.4.1 Целые Константы

Целые константы предстают в четырех обличьях: десятичные, восьмеричные, шестнадцатиричные и символьные константы. Десятичные используются чаще всего и выглядят так, как можно было бы ожидать:

  0    1234    976    12345678901234567890

Десятичная константа  имеет тип int, при условии, что она влезает в
int,  в   противном  случае   ее  тип   long.   Компилятор   должен
предупреждать   о    константах,   которые   слишком   длинны   для
представления в машине.

  Константа, которая  начинается нулем  за  которым  идет  x  (0x),
является шестнадцатиричным  числом (с  основанием 16), а константа,
которая     начинается  нулем   за  которым  идет  цифра,  является
восьмеричным числом  (с основанием  8).  Вот  примеры  восьмеричных
констант:

  0        02        077        0123

их десятичные  эквиваленты -  это 0, 2, 63, 83. В шестнадцатиричной
записи эти константы выглядят так:

  0x0      0x2       0x3f       0x53

2.4.2 Константы с Плавающей Точкой

Константы с плавающей точкой имеют тип double. Как и в предыдущем случае, компилятор должен предупреждать о константах с плавающей точкой, которые слишком велики, чтобы их можно было представить. Вот некоторые константы с плавающей точкой:

  1.23    .23      0.23     1.    1.0     1.2e10    1.23e-15

Заметьте, что  в середине  константы с  плавающей точкой  не  может
встречаться пробел.  Например, 65.43  e-21 является не константой с
плавающей точкой,  а  четырьмя  отдельными  лексическими  символами
(лексемами):

  65.43    e    -    21

2.4.3 Символьные Константы

Хотя в C++ и нет отдельного символьного типа данных, точнее, символ может храниться в целом типе, в нем для символов имеется специальная и удобная запись. Символьная константа - это символ, заключенный в одинарные кавычки; например, 'a' или '0'. Такие символьные константы в действительности являются символическими константами для целого значения символов в наборе символов той машины, на которой будет выполняться программа (который не обязательно совпадает с набором символов, применяемом на том компьютере, где программа компилируется). Поэтому, если вы выполняетесь на машине, использующей набор символов ASCII, то значением '0' будет 48, но если ваша машина использует EBCDIC, то оно будет 240. Употребление символьных констант вместо десятичной записи делает программу более переносимой. Несколько символов также имеют стандартные имена, в которых обратная косая \ используется как escape-символ:

  Вопреки их  внешнему виду  каждое является  одним символом. Можно
также представлять  символ одно-, дву- или трехзначным восьмеричным
числом (символ  \, за  которым идут восьмеричные цифры), или одно-,
дву- или  трехзначным шестнадцатиричным числом (\x, за которым идут
шестнадцатиричные цифры). Например:

  '\6'      '\x6'        6        ASCII ack
  '\60'     '\x30'       48       ASCII '0'
  '\137'    '\x05f'      95       ASCII '_'

2.4.4 Строки

Строковая константа - это последовательность символов, заключенная в двойные кавычки:

  "это строка"

Каждая строковая  константа содержит  на один  символ  больше,  чем
кажется; все они заканчиваются пустым символом '\0' со значением 0.
Например:

  sizeof("asdf")==5;

  Строка имеет  тип "вектор  из соответствующего  числа  символов",
поэтому "asdf"  имеет тип char[5]. Пустая строка записывается "" (и
имеет  тип   char[1]).  Заметьте,   что   для   каждой   строки   s
strlen(s)==sizeof(s)-1, поскольку strlen() не учитывает завершающий
0.

  Соглашение о  представлении  неграфических  символов  с  обратной
косой  можно   использовать  также   и  внутри   строки.  Это  дает
возможность представлять  в строке  двойные кавычки и escape-символ
\. Самым  обычным символом  этого рода является, безусловно, символ
новой строки '\n'. Например:

  cout << "гудок в конце сообщения\007\n" 

  "это не строка,
  а синтаксическая ошибка"

Однако в  строке может  стоять обратная  косая, сразу после которой
идет новая строка; и то, и другое будет проигнорировано. Например:

  cout << "здесь все \ ok" 

  здесь все ok

Новая строка,  перед  которой  идет  escape  (обратная  косая),  не
приводит  к   появлению  в   строке  новой   строки,   это   просто
договоренность о записи.

  В строке  можно иметь  пустой символ,  но большинство программ не
будет предполагать,  что есть символы после  него. Например, строка
"asdf\000hjkl" будет  рассматриваться стандартными функциями, вроде
strcpy() и strlen(), как "asdf".

  Вставляя численную  константу в строку с помощью восьмеричной или
шестнадцатиричной записи благоразумно всегда использовать число из
трех цифр.  Читать запись  достаточно трудно  и  без  необходимости
беспокоиться о  том, является  ли символ после константы цифрой или
нет. Разберите эти примеры:

  char v1[] = "a\x0fah\0129";    // 'a' '\xfa' 'h' '\12' '9'
  char v2[] = "a\xfah\129";      // 'a' '\xfa' 'h' '\12' '9'
  char v3[] = "a\xfad\127";      // 'a' '\xfad' '\127'

2.4.5 Ноль

2.4.6 Const

Ключевое слово const может добавляться к описанию объекта, чтобы сделать этот объект константой, а не переменной. Например:

  const int model = 145;
  const int v[] = { 1, 2, 3, 4 };

  Поскольку константе  ничего нельзя  присвоить,  она  должна  быть
инициализирована. Описание  чего-нибудь как  const гарантирует, что
его значение не изменится в области видимости:

  model = 145;        // ошибка
  model++;            // ошибка

  Заметьте, что  const изменяет  тип, то  есть ограничивает  способ
использования  объекта,   вместо  того,   чтобы   задавать   способ
размещения константы.  Поэтому например  вполне разумно, а иногда и
полезно, описывать функцию как возвращающую const:

  const char* peek(int i)
  {
      return private[i];
  }

Функцию вроде  этой можно  было бы  использовать  для  того,  чтобы
давать кому-нибудь читать строку, которая не может быть затерта или
переписана (этим кем-то).

  С   другой   стороны,   компилятор   может   несколькими   путями
воспользоваться тем,  что объект  является константой  (конечно,  в
зависимости от того, насколько он сообразителен). Самое очевидное -
это то,  что для  константы не требуется выделять память, поскольку
компилятор знает  ее значение.  Кроме того, инициализатор константы
часто (но  не всегда)  является константным  выражением, то есть он
может быть  вычислен  на  стадии  компиляции.  Однако  для  вектора
констант обычно  приходится выделять память, поскольку компилятор в
общем случае  не может вычислить, на какие элементы вектора сделаны
ссылки в  выражениях. Однако  на многих  машинах даже в этом случае
может достигаться повышение эффективности путем размещения векторов
констант в память, доступную только для чтения.

  Использование указателя  вовлекает два  объекта: сам  указатель и
указываемый объект.  Снабжение описания указателя "префиксом" const
делает объект, но не сам указатель, константой. Например:

  const char* pc = "asdf";    // указатель на константу
  pc[3] = 'a';                // ошибка
  pc = "ghjk";                // ok

Чтобы  описать   сам  указатель,   а  не  указываемый  объект,  как
константный, используется операция const*. Например:

  char *const cp = "asdf";    // константный указатель
  cp[3] = 'a';                // ok
  cp = "ghjk";                // ошибка

Чтобы сделать  константами оба объекта, их оба нужно описать const.
Например:

  const char *const cpc = "asdf";    // const указатель на const
  cpc[3] = 'a';                      // ошибка
  cpc = "ghjk";                      // ошибка

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

  char* strcpy(char* p, const char* q); // не может изменить q

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

  int a = 1;
  const c = 2;
  const* p1 = &c;    // ok
  const* p2 = &a;    // ok
  int* p3 = &c;      // ошибка
  *p3 = 7;           // меняет значение c

2.4.7 Перечисления

Есть другой метод определения целых констант, который иногда более удобен, чем применение const. Например:

  enum { ASM, AUTO, BREAK };

определяет  три   целых  константы,  называемы  перечислителями,  и
присваивает  им  значения.  Поскольку  значения  перечислителей  по
умолчанию присваиваются  начиная с  0 в  порядке  возрастания,  это
эквивалентно записи:

  const ASM = 0;
  const AUTO = 1;
  const BREAK = 2;

Перечисление может быть именованным. Например:

  enum keyword { ASM, AUTO, BREAK };

  Имя перечисления  становится синонимом  int, а  не  новым  типом.
Описание переменной  keyword, а  не  просто  int,  может  дать  как
программисту, так  и компилятору подсказку о том, что использование
преднамеренное. Например:

  keyword key;
  switch (key) {
  case ASM:
      // что-то делает
      break;
  case BREAK:
      // что-то делает
      break;
  }

побуждает компилятор  выдать предупреждение,  поскольку только  два
значения keyword из трех используются.

  Можно также задавать значения перечислителей явно. Например:

  enum int16 {
      sign=0100000,               // знак
      most_significant=040000,    // самый значимый
      least_significant=1         // наименее значимый
  };

2.5 Экономия Пространства

2.5.1 Поля

Использование char для представления двоичной переменной, например, переключателя включено/выключено, может показаться экстравагантным, но char является наименьшим объектом, который в C++ может выделяться независимо. Можно, однако, сгруппировать несколько таких крошечных переменных вместе в виде полей struct. Член определяется как поле путем указания после его имени числа битов, которые он занимает. Допустимы неименованные поля; они не влияют на смысл именованных полей, но неким машинно-зависимым образом могут улучшить размещение:

  struct sreg {
      unsigned enable : 1;
      unsigned page : 3;
      unsigned : 1;        // неиспользуемое
      unsigned mode : 2;
      unsigned : 4:        // неиспользуемое
      unsigned access : 1;
      unsigned length : 1;
      unsigned non_resident : 1;
  }

Получилось  размещение   регистра  0   состояния  DEC   PDP11/45  (в
предположении, что  поля в  слове размещаются  слева направо). Этот
пример  также   иллюстрирует  другое   основное  применение  полей:
именовать части  внешне предписанного  размещения. Поле должно быть
целого типа  и используется  как другие целые, за исключением того,
что невозможно  взять адрес поля. В ядре операционной системы или в
отладчике тип sreg можно было бы использовать так:

  sreg* sr0 = (sreg*)0777572;
  //...
  if (sr->access) {        // нарушение доступа
      // чистит массив
      sr->access = 0;
  }

2.5.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\n"; break; } } 

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

2.6 Упражнения