Basic Pascal Tutorial/Chapter 1/Constants/bg

│ български (bg) │ Deutsch (de) │ English (en) │ français (fr) │ italiano (it) │ 日本語 (ja) │ 한국어 (ko) │ русский (ru) │ 中文（中国大陆） (zh_CN) │

Константи

(author: Tao Yue, state: changed)

Константите се указват чрез идентификатори и получават стойност в началото на програмата. Стойността, съхранявана в константа, не може да бъде променена.

Константите биват три вида: обикновени, записи и масиви. Обикновената константа е идентификатор, на който се присвоява единична стойност. Константата-запис е идентификатор, съдържащ една или повече отделни стойности в структурирана форма. Константата-масив съдържа множество стойности от един тип. Те ще бъдат обяснени подробно в отделни раздели по-долу.

Константа, независимо дали скалар, поле за запис или индекс на масив, може да се използва вместо литерал от същия тип. Тя също така може да се използва навсякъде, където може да се използва и променлива, но с две изключения: не може да се използва отляво на оператор за присвояване и не може да се предава като VAR параметър при извикване на процедура, функция, метод или свойство (property).

Обикновени константи

Обикновените константи се дефинират в секцията Const (constant) на програмата:

const
  Identifier1 = value;
  Identifier2 = value;
  Identifier3 = value;

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

const
  Name = 'Tao Yue';
  FirstLetter = 'a';
  Year = 1997;
  pi = 3.1415926535897932;
  UsingNCSAMosaic = TRUE;

Отбележете, че в Pascal единичните символи са затворени в единични кавички или апострофи (')! Това е различно от по-новите езици, които често използват или позволяват двойни кавички или Heredoc нотация. Стандартният Pascal не използва двойни кавички за указване на символи или низове.

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

Типизираните константи налагат константата да бъде само от определен тип. Например,

const
  a : real = 12;

Ще дефинира константа с идентификатор a, която съдържа реална стойност 12.0 вместо целочислената стойност 12.

Константи-записи

Константите-записи се дефинират чрез създаване на тип запис с едно или повече полета и след това създаване на константа, която се позовава на този тип запис и попълва полетата със стойности.

Общият формат на константите-записи е:

const

identifier: record_type = ( field_values );

identifier …

където

• identifier е името на константата;
• record_type е името на типа-запис, който се използва за да опише тази константа;
• field_values е списък съдържащ име на поле от record_type, две точки (:), стойността за това поле, разделен от следващите поле:стойност с точка и запетая (;).

Нека опитаме прост пример, константа за комплексно число.

type
    complex= record
                R,I: real;
              end;
const
     Pi = 3.14159267;
     C1: Complex = ( R:3; I: 1783.5 );
     C2: complex = ( r: 9.6; I:1.62);
     C3: COMPLEX = ( r:17; i:115);
     C4: complex = ( r:1.9e56; i:72.43);
     C5: Complex=( R: 22.1 ; I: Pi );

Обърнете внимание, че полетата трябва да бъдат инициализирани в същия ред, в който са декларирани (или компилаторът ще сигнализира за грешка). Ако липсва стойност за поле, компилаторът ще предупреди за неинициализирана стойност.

За това как да опишете постоянен масив от записи, вижте раздела по-долу.

Константи-масив

Константите-масив работят почти по същия начин като обикновените константи, с изключение на това, че могат да бъдат посочени множество стойности. Всички стойности трябва да бъдат от един и същи тип, независимо дали е число (байт, дума, цяло число. Реално и т.н.) или символни (char, низ, ansistring и т.н.).

Едномерни масиви

За едномерните константи общият формат е:

const

identifier: array[low_value .. high_value] of type = ( values );

identifier …

където

• identifier е името на константата-масив;
• low_value е долната граница на масива;
• high_value е горната граница на масива;
• type е типът стойност, съхранявана в елементите на масива (char, integer, real, string, т.н.)
• values е списък със стойности, като всеки елемент в списъка е отделен от следващия със запетая.

Ето един пример с буквите от азбуката:

const
  Alphabet: array [1..26] of char =
       ('A','B','C','D','E','F','G','H','I',
        'J','K','L','M','N','O','P','Q','R',
        'S','T','U','V','W','X','Y','Z'   ) ;

Има две правила, които трябва да се запомнят. Както беше споменато по-рано, всички дадени стойности трябва да бъдат от един и същи тип и трябва да посочите толкова стойности, колкото елементи има в масива. Приведеният пример е добър, но ще има и други части на програмата, които препращат към този масив, като например for цикли. и т.н. Вместо да използваме числото 26 за размера на масива, нека вместо него използваме друга константа:

Const
   LetterCount = 26;
   Alphabet: array [1..LetterCount] of char =
       ('A','B','C','D','E','F','G','H','I',
        'J','K','L','M','N','O','P','Q','R',
        'S','T','U','V','W','X','Y','Z'   ) ;

По този начин, ако се наложи на друго място да се използва размера на масива, просто може да се използва LetterCount.

Ето по-интересен пример, в който се използват няколко типа данни. Този пример, който вероятно е от календарна програма, има всякакви типове: char, string и integer.

Const
  MonthStart = 0 ; // could be 1 and
  MonthEnd   = 11; // 12 if desired
  DayStart   = 0 ; // same,could be 1 and
  DayEnd     = 6;  // 7
  DayNameCh: array [DayStart .. DayEnd] of char =(
        'S','M','T','W','H','F','A');
  DayNameShort: array [DayStart .. DayEnd] of string=
    ( 'Sun','Mon','Tue','Wed','Thu',
      'Fri','Sat' ) ;
  DayNameLong: array DayStart .. DayEnd] of 
    string = ( 'Sunday', 'Monday','Tuesday','Wednesday',
               'Thursday', 'Friday', 'Saturday' );
     MonthNameLong: array[MonthStart ..MonthEnd] of string = (
  'January','February','March','April',
  'May','June','July','August',
  'September','October','November'.
  'December'  
             );
   MonthDays: ARRAY [ MonthStart .. MonthEnd ] of
    integer = ( 31, 28, 31, 30, 31, 30,
                31, 31, 30. 31, 30, 31 );

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

Едномерен масив от записи

Константата-масив може да се състои от записи. За да ги опишем, използваме скобите ( ) около всеки запис. Използвайки типа complex, дефиниран в раздела за константите-записи, можем да създадем постоянен масив от complex записи, както следва:

type
    complex= record
                R,I: real;
              end;
const
     Pi = 3.14159267;
     C2: complex = ( r: 96; I:1.62);
     C_Low = 1;  
     C_High = 5;
     C: array [ c_low .. c_high] of complex = (
     ( R:3; I:1783.5 ),
     ( r: 96;  I:1.62),
     ( r:17; i:115),
     ( r:1.9e56; i:72.43),
     ( R: 102.1;I: Pi )
     );

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

Сега за един по-сложен пример, в който използваме изброен тип и множество:

type
    MONTH = ( January, February, March,
              April, May, June,
              July, August, September,
              October, November, December);
    MonthSet = Set of Month;
    EachMonth=Record
         Name, Short: String;
         Count: Integer;
    end;

Const
     Months: array [ January .. December ] of EachMonth = (
       (Name: 'January';  Short: 'Jan'; Count: 31 ),
       (Name: 'February'; Short: 'Feb'; Count: 28 ),
       (Name: 'March';    Short: 'Mar'; Count: 31 ),
       (Name: 'April';    Short: 'Apr'; Count: 30 ),
       (Name: 'May';      Short: 'May'; Count: 31 ),
       (Name: 'June';     Short: 'Jun'; Count: 30 ),
       (Name: 'July';     Short: 'Jul'; Count: 31 ),
       (Name: 'August';   Short: 'Aug'; Count: 31 ),
       (Name: 'September';Short: 'Sep'; Count: 30 ),
       (Name: 'October';  Short: 'Oct'; Count: 31 ),
       (Name: 'November'; Short: 'Nov'; Count: 30 ),
       (Name: 'December'; Short: 'Dec'; Count: 31 )
        );

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

Двумерни константи-масиви

По подобие на примера за масив от записи, двумерните масиви се описват чрез ограждане на всяко от второто измерение в скоби. За да е по-разбираемо, числата в масива са идентифицирани по номер, напр. 13 е първият ред, трета колона, докато 21 е вторият ред, първата колона. Ето примера:

const
   DemoArray: array [1..2,1..3] of integer =
     (
      (11,12,13),
      (21,22,23)
      );

Тримерни константи-масиви

Тримерните константи-масиви се срещат рядко и може никога да не използвате такъв, но трябва да знаете как да конструирате тримерен константен масив ако се наложи. Отново всяко ниво на масива се огражда в скоби. Тук е показан тримерен константен масив и числата представляват позицията в масива:

const
   Demo3: array [1..2, 1..3, 1..4] of integer=
     (
      (
       (111,112,113,114),
       (121,122,123,124),
       (131,132,133,134)
       ),
      (
       (211,212,213,214),
       (221,222,223,224),
       (231,232,233,234)
      )
     );