Типизированные константы

В блоке CONST можно описывать не только константы, но и переменные величины. Эти переменные величины из-за того, что они описаны в таком странном месте, приобретают неудачное название типизированные константы, но переменными быть не перестают, а самое для нас главное - здесь им можно удобно придавать начальные значения. Вот пример:

CONST n :Integer =800;

e :Real =2.7;

Вот как запишется программа для вычисления средней недельной температуры из 12.4, если массив t описать как типизированную константу:

CONST k =7; { k - обычная, нетипизированная константа}

t :array [1..k] of Integer = (-14, -12, -8, -2, 0, 1, -3);

{ t - типизированная константа}

VAR s,i :Integer;

BEGIN

s:=0;

for i:=1 to k do s:=s+t[i];

WriteLn(s/k)

END.

Здесь в круглых скобках задается список начальных значений переменной t, а именно: t[1] равно -14, t[2] равно -12 и т.д. В разделе операторов эти значения можно менять.

Двумерным массивам начальные значения придаются аналогично. Так в программе из 12.3 вместо двенадцати присвоений можно было записать так:

Const k =3; n=4;

t :array [1..k,1..n] of Integer = (( -8,-14,-19,-18),

( 25, 28, 26, 20),

( 11, 18, 20, 25));

.......

Обратите внимание на расстановку скобок.

Придумываем типы данных

Паскаль предоставляет возможность не только пользоваться стандартными типами данных, но также именовать их по-другому и даже создавать свои типы.

Запись TYPE bukva = Char

означает: ТИП bukva "равен" (эквивалентен) типу Char,

то есть мы просто придумали типу Char еще одно название "bukva". Теперь все равно, как записать:

VAR a,b:Char

или VAR a,b:bukva .

Еще примеры: type Vector = array[1..10] of Integer;

matritsa = array[1..8] of Vector;

var a,b :Vector;

c :matritsa;

d :array[1.. 8] of Vector;

Здесь мы создали два новых типа с именами Vector и matritsa. Очевидно, переменные c и d описаны одинаково. Обратите внимание, что вместо type matritsa = array[1.. 8] of Vector

можно записать type matritsa = array[1.. 8] of array[1..10] of Integer

или type matritsa = array[1..8,1..10] of Integer .

Зачем нужны новые типы? Вот две из нескольких причин. Одна – наглядность и удобство. Другая - чисто грамматическая - Паскаль разрешает в определенных конструкциях записывать лишь имена типов, а не их определения. Например, когда мы изучим процедуры с параметрами, мы узнаем, что

писать procedure p(a: array[1..10] of Integer) неправильно,

а писать procedure p(a: Vector) правильно.

Логический тип Boolean

В операторах if, while, repeat мы привыкли писать выражения вида a>b, i<=0, c=’крот’, 3>2, (a>b)AND(a>c) и т.п. Про каждое из этих выражений можно сказать, истинно оно в данный момент или ложно. Например, выражение 3>2 истинно всегда, а выражение i<=0 ложно в тот момент, когда i равно, скажем, 2. Такие выражения называются логическими выражениями.

Говорят, что логическое выражение 3>2 имеет значение “истина” (по-английскиtrue- “тру”), а логическое выражение i<=0 имеет значение “ложь” (по-английски false- “фолс”).

Внутренняя идеология построения языка Паскаль требует определить новый тип переменных - логический тип Boolean. Запись VAR a:Booleanозначает, что переменная aможет принимать всего два значения - true и false. Так, мы можем записать a:=false.

Слова true и false являются логическими константамии их можно употреблять в логических выражениях или вместо них. Например, if a=true then... Конструкцию if (a>b)=false then... можно перевести “если неправда, что a больше b, то...”.

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

while true do .......

repeat ........... until false

Решим конкретный пример на этот тип.

Задача: В группе - 6 студентов. Сколько из них сдали зачет по физике?

Сначала напишем программу без использования типа Boolean. В ней единицей я обозначил зачет, нулем - незачет. Массив Zachet из 6 элементов хранит информацию о зачете.

CONST Zachet :array[1..6] of Integer = (1,1,0,1,1,1);
VAR c,i :Integer;
BEGIN
c:=0; {c - счетчик зачетов}
for i:=1 to 6 do if zachet[i] = 1 then c:=c+1;
WriteLn(c)
END.

Теперь напишем программу с использованием типа Boolean. В ней через true я обозначил зачет, через false - незачет.

CONST Zachet :array[1..6] of Boolean = (true,true, false, true, true, true);
VAR c,i :Integer;
BEGIN
c:=0;
for i:=1 to 6 do if zachet[i] = true then c:=c+1;
WriteLn(c)
END.

Отличие второй программы от первой в том, что выражение zachet[i] = true (зачет равен истина) выглядит естественнее и понятнее, чем zachet[i] = 1 (зачет равен единице, то есть колу?). В общем, чуть-чуть нагляднее.

Кстати, вполне правильно было бы написать и if zachet[i] then .... Ведь условием после слова if может стоять любое логическое выражение, имеющее значением true или false.

Перечислимые типы

В 5.7 я говорил о порядковых типах- это те типы, все значения которых можно выстроить по порядку и перечислить от начала до конца. Мы пока знаем, что в Паскале порядковыми типами являются целочисленные типы, символьный тип и логический тип. Кроме того, программист может придумывать собственные порядковые типы. Рассмотрим, например, такую конструкцию:

VAR Month : (january, february, march, april, may, june, july, august, september, october, november, december)

Она означает, что переменная Month может принимать только одно из перечисленных в скобках значений. Например, можно записать Month:= may. Переменная Month является переменной перечислимого типа, который является одним из видов порядковых типов.

Эти значения ни в коем случае не являются строками. Так, нельзя записать Month:= ‘may’. Кроме того, их нельзя вывести на печать, вообще они не могут быть введены в компьютер или выведены из него, например, при помощи операторов Read и Write. Однако, их удобно применять при программировании. Это удобство выяснится из следующего примера.

Задача: Известно, сколько дней в каждом месяце года. Сколько дней летом?

Сначала запишем программу традиционным способом.

Программа:

CONST dni :array[1..12] of Byte = (31,28,31,30,31,30,31,31,30,31,30,31);
VAR s,i :Integer;
begin
s:=0; {Сумматор летних дней}
for i:=6 to 8 do s:=s+dni[i]; {Летние месяцы - 6,7,8}
WriteLn(s)
end.

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

TYPE mes = (january, february, march, april, may, june, july, august, september,
october, november, december);
CONST dni :array[january..december] of Byte =
(31,28,31,30,31,30,31,31,30,31,30,31);
VAR s :Integer;
i :mes;
begin
s:=0;
for i:=june to august do s:=s+dni[i];
WriteLn(s)
end.

Пояснения: Основное достижение нашей программы в том, что в операторе for можно написать june to august вместо 6 to 8, а в определении массива dni можно написать array[january..december] вместо array[1..12]. Для этого пришлось определить специальный перечислимый тип mes, перечислив в скобках произвольные имена месяцев, а переменную цикла i задать типом mes, а не Integer.

Синтаксис перечислимого типа:

(имя , имя , имя , . . . . , имя)

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

if i = february then dni[i]:= 29