Описания

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

описание:

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

  спецификатор_описания:
      sc_спецификатор
      спецификатор_типа
      фнк_спецификатор
      friend
      typedef
  спецификаторы_описания:
      спецификатор_описания спецификатор_описания opt

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

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

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

  фнк-спецификатор:
      overload
      inline
      virtual

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

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

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

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

  сложный_спецификатор_типа:
      ключ typedef-имя
      ключ идентификатор
  ключ:
      class
      struct
      union
      enum

  class x { ... };
  void f(int x)
  {
      class x a;
      // ...
  }

8.3 Описатели

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

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

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

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

Каждый описатель считается утверждением того, что если в выражении возникает конструкция, имеющая ту же форму, что и описатель, то она дает объект указанного типа и класса памяти. Каждый описатель содержит ровно одно оп_имя; оно определяет описываемый идентификатор. За исключением описаний некоторых специальных функций (см. #8.5.2) , оп_имя будет простым идентификатором.
Если в качестве описателя возникает ничем не снабженный идентификатор, то он имеет тип, указанный спецификатором, возглавляющим описание.
Описатель в скобках эквивалентен описателю без скобок, но связку сложных описателей скобки могут изменять.
Теперь представим себе описание

  T D1

  *D

  * const D

  &D

  & const D

  D (список_описаний_параметров)

  список_описаний_параметров:
      список_описаний_парам opt ... opt
  список_описаний_парам:
      список_описаний_парам  ,  описание_параметра
      описание_параметра
  описание_параметра:
      спецификаторы_описания  описатель
      спецификаторы_описания  описатель  = выражение
      спецификаторы_описания  абстракт_описатель
      спецификаторы_описания  абстракт_описатель  =  выражение

  D[ константное_выражение]

  D[]

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);

  point (int = 0,int = 0);

  point (1,2);
  point (1)             /* имеет смысл point (1,0); */
  point ()              /* имеет смысл point (0,0); */

  printf (char* ... );

  printf ("hello, world");
  printf ("a=%d b=%d",a,b);
  printf ("string=%s",st);

  float fa[17], *afp[17];

  static int x3d[3][5][7];

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

Класс специфицирует тип. Его имя становится typedef-имя (см. #8.8), которое может быть использовано даже внутри самого спецификатора класса. Объекты класса состоят из последовательности членов.

     спецификатор_класса:
          заголовок_класса     {      список_членов      opt      }
          заголовок_класса         {  список_членов  opt  public  :
     список_членов                      opt                       }
     заголовок_класса:
          агрег                  идентификатор                  opt
          агрег идентификатор opt : public opt typedef-имя
     агрег:
          class
          struct
          union

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

  struct tnode
      {
        char tword[20];
        int count;
        tnode *left;
        tnode *right;
      };

  tnode s, *sp

  sp->count

  s.left

   s.right->tword[0]

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

Член-данные класса может быть static; члены-функции не могут. Члены не могут быть auto, register или extern. Есть единственная копия статического члена, совместно используемая всеми членами класса в программе. На статический член mem класса cl можно ссылаться cl:mem, то есть без ссылки на объект. Он существует, даже если не было создано ни одного объекта класса cl.

8.5.2 Функции члены

Функция, описанная как член, (без спецификатора friend (#8.5.9)) называется функцией членом и вызывается с помощью синтаксиса члена класса (#7.1). Например:

  struct tnode
    {
      char tword[20];
      int count;
      tnode *left;
      tnode *right;
      void set (char* w,tnode* l,tnode* r);
    };
  tnode n1, n2;
  n1.set ("asdf",&n2,0);
  n2.set ("ghjk",0,0);

     typedef-имя . простое_оп_имя

  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;
    }

  int b;
  struct x
    {
      int f () { return b; }
      int f () { return b; }
      int b;
    };

  int b;
  struct x
    {
      int f ();
      int b;
    };
  inline x.f () { return b; }

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

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

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

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

  struct base
    {
      int a;
      int b;
    };
  struct derived : public base
    {
      int b;
      int c;
    };
  derived d;
  d.a = 1;
  d.base::b = 2;
  d.b = 3;
  d.c = 4;

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

Если базовый класс base содержит (виртуальную) virtual (#8.1) функцию vf, а производный класс derived также содержит функцию vf, то вызов vf для объекта класса derived вызывает derived::vf. Например:

  struct base
    {
      virtual void vf ();
      void f ();
    };
   struct derived : public base
    {
      void vf ();
      void f ();
    };
  derived d;
  base* bp = &d;
  bp->vf ();
  bp->f ();

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

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

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

  complex zz = complex (1,2.3);
  cprint (complex (7.8,1.2));

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

Конструктор, получающий один параметр, определяет преобразование из типа своего параметра в тип своего класса. Такие преобразования неявно применяются дополнительно к обычным арифметическим преобразованиям. Поэтому присваивание объекту из класса X допустимо, если или присваиваемое значение является X, или если X имеет конструктор, который получает присваиваемое значение как свой единственный параметр. Аналогично конструкторы используются для преобразования параметров функции (#7.1) и инициализаторов (#8.6). Например:

  class X { ... X (int); };
  f (X arg)
    {
      X a = 1;          /* a = X (1) */
      a = 2;            /* a = X (2) */
      f (3);            /* f (X (3)) */
    }

  class X { ... X (int); };
  class X { ... Y (X); };
  Y a = 1;              /* недопустимо: Y (X (1)) не пробуется */

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

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

Деструктор для базового класса выполняется после деструктора производного от него класса. Как деструкторы используются для управления свободной памятью, см. объяснение в #17.

8.5.8 Видимость имен членов

Члены класса, описанные с ключевым словом class, являются закрытыми, это значит, что их имена могут использоваться только функциями членами (#8.5.2) и друзьями (см. #8.5.10), пока они не появятся после метки public: . В этом случае они являются общими. Общий член может использоваться любой функцией. Структура является классом, все члены которого общие; см. #8.5.11.
Если перед именем базового класса в описании производного класса стоит ключевое слово public, то общие члены базового класса являются общими для производного класса; если нет, то они являются закрытыми. Общий член mem закрытого базового класса base может быть описан как общий для производного класса с помощью описания вида

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

  class base
    {
      int a;
  public:
      int b,c;
      int bf ();
    };
  class derived : base
    {
      int d;
  public:
      base.c;
      int e;
      int df ();
    };
  int ef (derived&);

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 Объединения

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

8.5.13 Поля бит

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

     идентификатор 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;

  r1 = r2;

  double& rr = 1;

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-имя:
          идентификатор

  typedef int MILES, *KLICKSP;
  struct complex { double re, im; };

  MILES distance;
  extern KLICKSP metricp;
  complex z, *zp;

  struct X { int a; };
  struct Y { int a; };
  X a1;
  Y a2;
  int a3;

     описание_имени:
          агрег                   идентификатор                   ;
          enum  идентификатор ;

  class vector;
  class matrix
    {
      ...
      friend matrix operator* (matrix&,vector&);
    };
  class vector
    {
      ...
      friend matrix operator* (matrix&,vector&);
    };

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

В тех случаях, когда для одного имени определено несколько (различных) описаний функций, это имя называется перегруженным. При использовании этого имени правильная функция выбирается с помощью сравнения типов фактических параметров с типами параметров в описаниях функций. К перегруженным именам неприменима операция получения адреса &.
Из обычных арифметических преобразований, определенных в #6.6, для вызова перегруженной функции выполняются только char->short->int, int->double, int->long и float->double. Для того, чтобы перегрузить имя функции не-члена описание overload должно предшествовать любому описанию функции; см. #8.2.
Например:

  overload abs;
  int abs (int);
  double abs (double);

  class X { ... X (int); };
  class Y { ... Y (int); };
  class Z { ... Z (char*); };
  overload int f (X), f (Y);
  overload int g (X), g (Y);
  f (1);        /* неверно: неоднозначность f(X(1)) или f(Y(1)) */
  g (1);        /* g(X(1))                              */
  g ("asdf");   /* g(Z("asdf"))                         */

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 (строка);

*¹ В английском "garbage", означающее затертое место [памяти], т.е. если переменная целая, то 0, если char, то '\0', если указатель на Т, то (Т*) NULL.

[Назад] [Содержание] [Вперед]

к оглавлению   к C-Builder

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

НОВОСТИ ФОРУМА Рыцари теории эфира

10.11.2021 - 12:37: ПЕРСОНАЛИИ - Personalias -> WHO IS WHO - КТО ЕСТЬ КТО - Карим_Хайдаров. 10.11.2021 - 12:36: СОВЕСТЬ - Conscience -> РАСЧЕЛОВЕЧИВАНИЕ ЧЕЛОВЕКА. КОМУ ЭТО НАДО? - Карим_Хайдаров. 10.11.2021 - 12:36: ВОСПИТАНИЕ, ПРОСВЕЩЕНИЕ, ОБРАЗОВАНИЕ - Upbringing, Inlightening, Education -> Просвещение от д.м.н. Александра Алексеевича Редько - Карим_Хайдаров. 10.11.2021 - 12:35: ЭКОЛОГИЯ - Ecology -> Биологическая безопасность населения - Карим_Хайдаров. 10.11.2021 - 12:34: ВОЙНА, ПОЛИТИКА И НАУКА - War, Politics and Science -> Проблема государственного терроризма - Карим_Хайдаров. 10.11.2021 - 12:34: ВОЙНА, ПОЛИТИКА И НАУКА - War, Politics and Science -> ПРАВОСУДИЯ.НЕТ - Карим_Хайдаров. 10.11.2021 - 12:34: ВОСПИТАНИЕ, ПРОСВЕЩЕНИЕ, ОБРАЗОВАНИЕ - Upbringing, Inlightening, Education -> Просвещение от Вадима Глогера, США - Карим_Хайдаров. 10.11.2021 - 09:18: НОВЫЕ ТЕХНОЛОГИИ - New Technologies -> Волновая генетика Петра Гаряева, 5G-контроль и управление - Карим_Хайдаров. 10.11.2021 - 09:18: ЭКОЛОГИЯ - Ecology -> ЭКОЛОГИЯ ДЛЯ ВСЕХ - Карим_Хайдаров. 10.11.2021 - 09:16: ЭКОЛОГИЯ - Ecology -> ПРОБЛЕМЫ МЕДИЦИНЫ - Карим_Хайдаров. 10.11.2021 - 09:15: ВОСПИТАНИЕ, ПРОСВЕЩЕНИЕ, ОБРАЗОВАНИЕ - Upbringing, Inlightening, Education -> Просвещение от Екатерины Коваленко - Карим_Хайдаров. 10.11.2021 - 09:13: ВОСПИТАНИЕ, ПРОСВЕЩЕНИЕ, ОБРАЗОВАНИЕ - Upbringing, Inlightening, Education -> Просвещение от Вильгельма Варкентина - Карим_Хайдаров.