8. Описания

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

описание:

      спецификаторы_описания opt список_описателей opt ;
      описание_имени
      asm_описание

8.1 Спецификаторы класса памяти

Спецификаторы "класса памяти" (sc-спецификатор) это:

  sc-спецификатор:
      auto
      static
      extern
      register

8.2 Спецификаторы Типа

Спецификаторами типов (спецификатор_типа) являются:

  спецификатор_типа:
      простое_имя_типа
      class_спецификатор
      enum-спецификатор
      сложный_спецификатор_типа
      const

  простое_имя_типа:
      char
      short
      int
      long
      unsigned
      float
      double
      const
      void

8.3 Описатели

Список_описателей, появляющийся в описании, есть разделенная запятыми последовательность описателей, каждый из которых может иметь инициализатор.

  список_описателей:
      иниц_описатель
      иниц_описатель  ,  список_описателей
      иниц_описатель:
      описатель  инициализатор opt

8.4 Смысл описателей

8.4.1 Примеры

В качестве примера, описание

  int i;
  int *ip;
  int f ();
  int *fip ();
  int (*pfi) ();

  const a = 10, *pc = &a, *const cpc = pc;
  int b, *const cp = &b;

  a = 1;
  a++;
  *pc = 2;
  cp = &a;
  cpc++;

  b = a;
  *cp = a;
  pc++;
  pc = cpc;

  fseek (FILE*,long,int);

8.5 Описания классов

8.5.1 Статические члены

  void tnode.set (char* w,tnode* l,tnode* r)
    {
      count = strlen (w);
      if (sizeof (tword) <= count) error ("tnode string too long");
      strcpy (tword,w);
      left = l;
      right = r;
    }

8.5.3 Производные классы

В конструкции

     агрег идентификатор:public opt typedef-имя

8.5.4 Виртуальные функции

8.5.5 Конструкторы

Член функция с именем, совпадающим с именем ее класса, называется конструктором. Конструктор не имеет типа возвращаемого значения; он используется для конструирования значений с типом его класса. С помощью конструктора можно создавать новые объекты его типа, используя синтаксис

     typedef-имя ( список_параметров opt )

  complex zz = complex (1,2.3);

  cprint (complex (7.8,1.2));

8.5.6 Преобразования

8.5.7 Деструкторы

Функция член класса cl с именем ~cl называется деструктором. Деструктор не возвращает никакого значения и не получает никаких параметров; он используется для уничтожения значений типа cl непосредственно перед уничтожением содержащего их объекта. Деструктор не может быть overload, virtual или friend.

8.5.9 Друзья (friends)

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

  class private
    {
      int a;
      friend void friend_set (private*,int);
  public:
      void member_set (int);
    };

  void friend_set (private* p,int i) { p->a=i; }

  void private.member_set (int i) { a = i; }

  private obj;

  friend_set (&obj,10);

  obj.member_set (10);

  class cl2
    {
      friend cl1;
      . . .
    };

8.5.10 Функция операция

Большинство операций могут быть перегружены с тем, чтобы они могли получать в качестве операндов объекты класса.

      имя_функции_операции:   operator  op
    op:            +   -   *   /   %   ^   &   |   ~
                   !   =   <   >   +=  -=  *=  /=  %=
                   ^=  &=  |=  <<  >>  <<= >>= ==  !=
                   <=  >=  &&  ||  ++  --  ()  []

8.5.11 Структуры

Структура есть класс, все члены которого общие. Это значит, что

  struct s { ... };

  class s { public: ... };

8.5.12 Объединения

Описатель члена вида

     идентификатор opt:  константное_выражение

8.5.14 Вложенные классы

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

  int x;

  class enclose   /* охватывающий */
    {
      int x;
      class inner
        {
          int y;
          f () { x=1 }
          ...
        };
      g (inner*);
      ...
    };

  int inner;  /* вложенный */

  enclose.g (inner* p) { ... }

8.6 Инициализация

Описание может задавать начальное значение описываемого идентификатора. Инициализатору предшествует =, и он состоит из выражения или списка значений, заключенного в фигурные скобки.

     инициализатор:
          =                                              expression
          =          {           список_инициализаторов           }
          =       {        список_инициализаторов        ,        }
          (                   список_выражений                    )

     список_инициализаторов                                       :
          выражение
          список_инициализаторов      ,      список_инициализаторов
          { список_инициализаторов }

8.6.1 Список инициализаторов

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

  int x[] = { 1, 3, 5 };

  float y[4][3] =
      {
        { 1, 3, 5 },
        { 2, 4, 6 },
        { 3, 5, 7 }
      };

  float y[4][3] =
    {
      1, 3, 5, 2, 4, 6, 3, 5, 7
    };

  float y[4][3] = { { 1 }, { 2 }, { 3 }, { 4 } };

8.6.2 Классовые объекты

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

  struct complex
    {
      float re;
      float im;
      complex (float r,float i) { re=r; im=i; }
      complex (float r) { re=r; im=0; }
    };

  complex zz (1,2.3);
  complex* zp = new complex (1,2.3);

  complex zz1 = complex (1,2.3);
  complex zz2 = complex (123);
  complex zz3 = 123;
  complex zz4 = zz3;

8.6.3 Ссылки

Когда переменная описана как T&, что есть "ссылка на тип T", она может быть инициализирована или указателем на тип T, или объектом типа T. В последнем случае будет неявно применена операция взятия адреса &. Например:

  int i;
  int& r1 = i;
  int& r2 = &i;

8.6.4 Массивы символов

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

  char msg[] = "Syntax error on line %d\n";

8.7 Имена типов

Иногда (для неявного задания преобразования типов и в качестве параметра sizeof или new) нужно использовать имя типа данных. Это выполняется при помощи "имени типа" которое по сути является описанием для объекта этого типа, в котором опущено имя объекта.

     имя_типа:
          спецификатор_типа абстрактный_описатель
     абстрактный_описатель                                        :
          пустой
          *                                   абстрактный_описатель
          абстрактный_описатель    (  списоко_писателей_параметров)
          абстрактный_описатель    [  константное_выражение  opt  ]
          ( абстрактный_описатель )

  int
  int *
  int *[3]
  int *()
  int (*)()

     простое_имя_типа:
          typedef-имя
          char
          short
          int
          long
          unsigned
          float
          double

  (double) a

  double (a)

8.8 Определение типа typedef

Описания, содержащие спецификатор_описания typedef, определяют идентификаторы, которые позднее могут использоваться так, как если бы они были ключевыми словами типа, именующее основные или производные типы.

     typedef-имя:
          идентификатор

8.9 Перегруженные имена функций

8.10 Описание перечисления

Перечисления являются int с именованными константами.

     enum_спецификатор:
          enum    идентификатор     opt     {     enum_список     }

     enum_список:
          перечислитель
          enum_список,                                перечислитель

     перечислитель:
          идентификатор
          идентификатор = константное_выражение

  enum color { chartreuse, burgundy, claret=20, winedark };
    ...
    color *cp, col;
    ...
    col = claret;
    cp = &col;
    ...
    if (*cp == burgundy) ...

8.11 Описание Asm

Описание Asm имеет вид

    asm (строка);