
                             ГЛАВА 5.

                      ТИПИРОВАННЫЕ КОНСТАНТЫ.

     Типированные константы  можно  сравнить  с инициализированными
переменными - переменными,  значения которых определяются на  входе
их  в  блок.  В  отличие  от  нетипированных  констант (см.  раздел
"Объявления констант"  в  главе  1),  в   объявлении   типированной
константы указывается как тип, так и значение константы.


объявление      +—————————————+  +—+  +———+  +—+  +————————————+
типированной ——Ў|идентификатор+—Ў|:+—Ў|тип+—Ў|=+—Ў|типированная+——Ў
константы       +—————————————+  +—+  +———+  +—+  | константа  |
                                                  +————————————+

типированная               +———————————————————+
константа       ——————+———Ў|константа          +———————Ў
                      |    +———————————————————+   °
                      |    +———————————————————+   |
                      +———Ў|константа адреса   +———+
                      |    +———————————————————+   |
                      |    +———————————————————+   |
                      +———Ў|константа массива  +———+
                      |    +———————————————————+   |
                      |    +——————————————————+    |
                      +———Ў|константа записи  +————+
                      |    +——————————————————+    |
                      |    +———————————————————+   |
                      +———Ў|константа объекта  +———+
                      |    +———————————————————+   |
                      |    +———————————————————+   |
                      +———Ў|константа множества+———+
                           +———————————————————+


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

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


                     Константы простого типа.

     Объявление типированной константы с простым типом означает ука-
зание значения константы:

     const
         Maximum   : Integer = 9999;
         Factor    : Real   = -0.1;
         Breakchar : Char   = $3;

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

     var
       Buffer : array[0..1023] of Byte;
     const
       BufferOfs : Word = Ofs(Buffer);
       BufferSeg : Word = Seg(Buffer);

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

     const
         Min : Integer = 0;
         Max : Integer = 99;
     type
         Vector = array [Min..Max] of Integer;

     Объявление Vector является недопустимым,  поскольку Min и  Max
являются типированными константами.


                    Константы строкового типа.

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

     const
         Heading  : string [7] = `Section';
         Newline  : string [2] = #13#10;
         TrueStr  : string [5] = `Yes';
         FalseStr : string [5] = `No';


                   Константы структурного типа.

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


                     Константы с типом массив.

     Объявление константы   с   типом   массив   содержит  значения
компонент, заключенные в скобки и разделенные запятыми.

                      +—+     +————————————+     +—+
константа-массив  ———Ў|(+————Ў|типированная+——+—Ў|)+———Ў
                      +—+  °  | константа  |  |  +—+
                           |  +————————————+  |
                           |      +—+         |
                           +——————+,|ў————————+
                                  +—+

     Приведем пример константы с типом массив:

     type
        Status = (Active, Passive, Waiting);
        StatusMap = array [Status] of string[7];

     const
        StatStr:StatusMaр = ('Active', 'Passive', 'Waiting');

     В этом примере определяется константа-массив StatStr, которая
может  быть использована для преобразования значений типа Status в
соответствующие им строковые представления.  Компонентами  StatStr
являются

     StatStr[Active] = 'Active'
     StatStr[Passive] = 'Passive'
     StatStr[Waiting] = 'Waiting'

     Тип компоненты  константы-массива может  быть   любым,   кроме
файлового  типа.  Упакованные константы строкового типа (символьные
массивы) могут быть определены  и  как  одиночные  символы,  и  как
строки. Определение

     const
        Digits : array[0..9] of Сhar =
           ('0','1','2','3','4','5','6','7','8','9');

     можно представить в более удобном виде:

     const
         Digits : array [0..9] of Char = '0123456789';

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

     type
        Cube = array[0..1, 0..1, 0..1] of Integer;
     const
        Maze: Cube=(((0,1),(2,3)),((4,5),(6,7)));

     задает следующие начальные значения массиву Maze:

     Maze[0, 0, 0] = 0
     Maze[0, 0, 1] = 1
     Maze[0, 1, 0] = 2
     Maze[0, 1, 1] = 3
     Maze[1, 0, 0] = 4
     Maze[1, 0, 1] = 5
     Maze[1, 1, 0] = 6
     Maze[1, 1, 1] = 7


                     Константы с типом запись.

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


               +—+    +—————————————+  +—+  +————————————+    +—+
константа-  ——Ў|(+———Ў|идентификатор+—Ў|:+—Ў|типированная+—+—Ў|)+—Ў
запись         +—+ °  |     поля    |  +—+  |  константа | |  +—+
                   |  +—————————————+       +————————————+ |
                   |                   +—+                 |
                   +———————————————————+;|ў————————————————+
                                       +—+

     Приведем несколько примеров констант-записей:

     type
        Point = record
           X, Y : Real;
        end;

   Vector = array [0..1] of Point;
   Month = (Jan,Feb,Mar,Apr,May,Jun,Jly,Aug,Sep,Oct,Nov,Dec);
      Date = record
         D : 1..31;
         M : Month;
         Y : 1900..1999;
      end;
  const
     Origin : Point = (X : 0.0; Y : 0.0);
     Line   : Vector= ((X : -3.1; Y : 1.5), (X : 5.8; Y : 3.0));
     SomDay : Date  = (D : 2; M : Dec; Y : 1960);

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


                      Константы типа объект.

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

     const
       ZeroPoint : Point = (X : 0; Y : 0);
       ScreenRect : Rect = (A : (X : 0;  Y : 0);
                            B : (X : 80; Y : 25));
       CountField : NumField = (X : 5; Y : 20; Len : 4; Name : nil;
                                Value : 0; Min : -999; Max : 999);

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


                     Константы типа множества.

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


                        +—+                                 +—+
константа-множество  ——Ў|[+——+—————————————————————————————Ў|]+——Ў
                        +—+  |    +—————————————————+   °   +—+
                             +———Ў|константа-элемент+—+—+
                               °  +—————————————————+ |
                               |        +———+         |
                               +————————+ , |ў————————+
                                        +———+

 константа-элемент
                       +—————————+
                  ————Ў|константа+——+—————————————————————————Ў
                       +—————————+  |  +——+   +—————————+  °
                                    +—Ў|..+——Ў|константа+——+
                                       +——+   +—————————+

     Приведем несколько примеров констант множеств:

     type
        Digits  = set of 0..9;
        Letters  = set of 'A'..'Z';
     const
        EvenDigits : Digits = [0, 2, 4, 6, 8];
        Vowels     : Letters= ['A', 'E', 'I', 'O', 'U', 'Y'];
        HexDigits  : set of '0'..'z' = ['0'..'9', 'A'..'F',
                                        'a'..'f'];


                   Константы с типом указатель.

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

     type
        Direction = (Left, Right, Up, Down);
        StringPrt = ^String;
        NodePtr = ^Node;
        Node = record
           Next : NodePtr;
           Symbol : StringPrt;
           Value : Direction;
        end;
     const
        S1: string[4] = 'DOWN';
        S2: string[2] = 'UP';
        S3: string[5] = 'RIGHT';
        S4: string[4] = 'LEFT';
        N1: Node = (Next: nil; Symbol:#S1; Value: Down);
        N2: Node = (Next: @N1; Symbol:#S2; Value: Up);
        N3: Node = (Next: @N2; Symbol:#S3; Value: Right);
        N4: Node = (Next: @N3; Symbol:#S4; Value: Left);
        DirectionTable: NodePtr = @N4;



                   Константы процедурного типа.

     Константа процедурного  типа  должна  указывать  идентификатор
процедуры или  функции,  совместимый  по   присваиванию   с   типом
константы. Пример:

     type
        ErrorProc = procedure(ErrorCode: Integer);
     procedure DefaultError(ErrorCode: Integer); far;
     begin
        Writeln('Error ', ErrorCode, '.');
     end;
     const
        ErrorHandler: ErrorProc = DefaultError;
