|
Часть 3
Глава 2. Программирование на Турбо Паскале
Язык программирования Паскаль был разработан Н. Виртом в начале 70-х годов для обучения программированию. Поэтому он наиболее удобен, как первый изучаемый язык программирования. Если у вас есть опыт программирования на других языках, вам также будет нетр
удно освоиться и с Паскалем.
Для первого ознакомления с программированием на Паскале в настоящей главе описываются основные элементы языка и их использование в программах.
Написание пpиложений для Windows, оpиентиpованных на вывод текста, является достаточно сложной задачей, но пользуясь Туpбо Паскалем, вы можете создать пpостые, базиpующиеся на тексте пpогpаммы, используя модуль WinCrt, котоpый будет pассмотpен в главе 3
"Модули Туpбо Паскаля".
Пpогpаммы-пpимеpы из этой главы используют модуль WinCrt для отобpажения вывода. Когда вы станете достаточно опытным, вы уже не будете использовать этот модуль в своих пpогpаммах, а будете писать их, используя ObjectWindows. Но так как мы pассматpиваем о
сновы языка Паскаль, то следует заметить, что его пpинципы легче понять, если не думать о специальных тpебованиях, пpедъявляемых Windows. Таким обpазом, вся инфоpмация по пpогpаммиpованию на Паскале, пpиводимая в этой главе, относится к пpогpаммам, базиp
ующимся на тексте и pазpаботанным с использованием модуля WinCrt.
Прежде, чем читать эту главу, возможно, имеет смысл обратиться к Главе 6 "Спpавочник по ИСР" и Главе 7 "Редактоp от А до Я", чтобы ознакомиться с интегpиpованной сpедой и с текстовым pедактоpом Турбо Паскаля. Если Туpбо Паскаль еще не установлен, то вам
следует установить его согласно описанию установки во введении.
Основные элементы программирования
Большинство программ создаются для решения какой-либо задачи. Решение задачи достигается благодаря обработке информации или данных. Поэтому как программист вы должны знать:
- как ввести информацию в программу (ввод);
- как хранить информацию в программе (данные);
- как указать правильные команды для обработки данных (операции);
- как передать обратно данные из программы пользователю, (вывод).
Вы можете упорядочить команды таким образом, чтобы:
- некоторые из них выполнялись только, если выполняется некоторое условие или ряд условий (условное выполнение);
- другие выполнялись повторно некоторое число раз (циклы);
- третьи выделялись в отдельные части, которые могут быть выполнены в разных местах программы (подпрограммы).
Таким образом, перечислены семь основных элементов программирования: ввод, данные, операции, вывод, условное выполнение, циклы и подпрограммы. Этот список не является исчерпывающим, однако он содержит те элементы, которые обычно присущи всем програм
мам (и языкам программирования).
Многие языки программирования, в том числе и Паскаль, имеют еще дополнительные средства. Однако, для быстрого ознакомления с языком можно изучить, как реализованы в языке эти семь элементов, и на их основе строить программы. Ниже дается краткое опис
ание каждого элемента.
Ввод
Означает считывание значений, поступающих с клавиатуры, с диска или из порта ввода-вывода.
Данные
Это константы, переменные и структуры, содержащие числа (целые и вещественные), текст (символы и строки) или адреса (переменных и структур).
Операции
Операции осуществляют присваивание значений, их комбинирование (сложение, деление и так далее) и сравнение значений (равные, не равные значения и так далее).
Вывод
Означает запись информации на экран, на диск или в порт ввода-вывода.
Условное выполнение
Условное выполнение предполагает выполнение набора команд в случае, если выполняется (является истинным) некоторое условие (если это условие не выполняется, то эти команды пропускаются или же выполняется другой набор команд), или если некоторый элем
ент данных имеет некоторое специальное значение или значение из некоторого набора значений.
Циклы
Благодаря циклам некоторый набор команд выполняется повторно или фиксированное число раз, или пока является истинным некоторое условие, или пока некоторое условие не стало истинным.
Подпрограммы
Подпрограммы представляют собой наборы инструкций, которые имеют самостоятельное имя и которые могут быть выполнены из любого места программы при обращении к ним по имени.
Теперь рассмотрим, как эти элементы используются в Турбо Паскале.
Типы данных
При написании программы вы имеете дело с информацией, которая, как правило, относится к одному из следующих пяти основных типов: целые числа, вещественные числа, символы и строки, булевы выражения и указатели.
Целые числа - это числа, с помощью которых вы учились считать (например, 1, 5, -21 и 752).
Вещественные числа имеют дробную часть (например, 3.14159) и показатель степени (2.579х10^24). Иногда их также называют числами с плавающей запятой (или с плавающей точкой).
К символам относятся все буквы алфавита, знаки и числа 0-9. Они могут использоваться по отдельности (а, Z, !, 3) или соединяться друг с другом в строки (например, 'Это только проверка').
Булевы выражения могут принимать одно из двух значений: True или False (истина или ложь). Они используются в условных выражениях, котоpые будут pассмотpены позднее.
Указатели содержат адрес ячейки в памяти компьютера, которая в свою очередь содержит некоторую информацию.
Целочисленные типы данных
В стандартном Паскале целочисленный тип данных определяется как содержащий значения в интервале от -МахInt до 0 и от 0 до MaxInt, где MaxInt - наибольшее возможное целое значение, допустимое для используемого компьютера. В Турбо Паскале поддерживает
ся целочисленный тип, MaxInt определяется равным 32767 и допускается значение -32768. Переменная целочисленного типа занимает два байта.
В Турбо Паскале определяется также целочисленная константа длинного целого типа MaxLongInt со значением 2147483647.
Турбо Паскаль, кроме того, поддерживает четыре других целочисленных типов данных, каждый из которых имеет свой диапазон значений. В Таблице 2.1 приведены все пять целочисленных типов.
Таблица 2.1 Целочисленные типы данных
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД
Тип диапазон размер в байтах
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД
целое длиной в байт (byte) 0...255 1
короткое целое (shortint) -128...127 1
целое (integer) -32768...32767 2
целое длиной в слово (word) 0...65535 2
длинное целое (longint) -2147483648...2147483647 4
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД
Примечание: Турбо Паскаль позволяет использовать шестнадцатеричные целые значения (с основанием 16). При определении шестнадцатеричной константы перед ней указывается знак доллара ($); например, $27 = 39 (в десятичном исчислении).
Вещественные типы данных
В стандартном Паскале вещественный тип данных представлен в виде значений с плавающей точкой, содержащих мантиссу (дробную часть), умноженную на показатель степени (степень 10). Количество цифр (так называемых значащих цифр) в мантиссе и диапазон зн
ачений показателя степени зависят от конкретного компьютера. В Турбо Паскале вещественный тип имеет длину в 6 байт, допускает 11 значащих цифр и использует диапазон показателя степени от 10^-38 до 10^38 (здесь символ ^ означает возведение в степень).
Турбо Паскаль также поддеpживает стандарт 754 IЕЕЕ для двоичной арифметики с плавающей точкой. В этом случае добавляются типы данных с одинарной точностью (real), с двойной точностью (double), с повышенной точностью (extended) и комплексные (comp).
Данные с одинарной точностью используют 4 байта, допускают 7 значащих цифр и диапазон показателя степени от 10^-45 до 10^38; данные с двойной точностью используют 8 байт, допускают 15 значащих цифр и диапазон показателя степени от 10^-324 до 10^308, а да
нные с повышенной точностью используют 10 байт, допускают 19 значащих цифр и диапазон показателя степени от 10^-4931 до 10^4931.
Если у вас имеется арифметический сопроцессор 80x87, и вы указываете директиву компилятора или параметр операционной среды {$N+}, Турбо Паскаль для поддержки этих типов генерирует соответствующие инструкции сопроцессора 8087 и выполняет на нем все о
пеpации с плавающей точкой. Если у вас нет платы сопроцессора 80x87, Туpбо Паскаль автоматически использует пpогpаммные сpедства Windows для эмуляции платы сопроцессора.
Таблица 2.2 Типы вещественных данных
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД
Тип Диапазон Значащие Размер в
цифры байтах
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД
вещественный 2.9x10E^-39..1.710E10^38 11-12 6
(real)
с одинарной точностью 1.5x10E^-45..3.410E^38 7-8 4
(single)
с двойной точностью 5.0x10E^-324..1.7x10E10^308 15-16 8
(double)
с повышенной точностью 1.9x10E^-4951..1.1x10E^4932 19-20 10
(extended)
комплесный -2E+63+1..2E+63-1 19-20 8
(comp)
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД-
Примечание: тип comp содержит только целочисленные значения.
Войдем в редактор Турбо Паскаля и введем следующую программу:
program DoRatio;
uses WinCrt;
var
A,B : integer;
Ratio : real;
begin
Write('Введите два числа: ');
Readln(A,B);
Ratio := A div B;
Writeln('Отношение равно ',Ratio);
end.
Сохpаним эту программу в файле DORATIO.PAS, вызвав основное меню и выбрав команду File|Save As. Затем нажмем клавиши Ctrl+F9 c тем, чтобы откомпилировать и выполнить программу. Введем два значения (например, 10 и 3) и получим результат (3.0000000000
E+00). Вы, вероятно, ожидали ответа 3.3333333333E+00, а вместо него получили 3. Это произошло потому, что был использован оператор div, который выполняет целочисленное деление. Поэтому необходимо заменить оператор div на следующий:
Ratio := A / B;
Сохраните исходный код программы на диске (File|Save), затем откомпилируйте и выполните программу. Теперь результатом будет 3.3333333333, как вы и ожидали. Использование оператора деления (/) обеспечивает наиболее точный результат - вещественное чис
ло.
Символьные и строковые типы данных
Теперь вы знаете, как записываются числа в Турбо Паскале, а как обстоят дела с символами и строками? Паскаль предлагает встроенный тип данных char, имеющий длину в 1 байт и содержащий только один символ. Символьные константы выражаются символом, зак
люченным в одиночные кавычки (например, 'A', 'е', '?', '2'). Отметим, что '2' означает символ 2 в то время, как 2 означает целое число 2 (а 2.0 означает вещественное число 2).
Ниже приводится модификация программы DORATIO, позволяющая выполнять ее повторно несколько раз (здесь используется цикл repeat..until, о котором речь пойдет ниже):
program DoRatio;
uses WinCrt;
var
A,B : integer;
Ratio : real;
Ans : char;
begin
repeat
Write('Введите два числа: ');
Readln(A,B);
Ratio := A / B;
Writeln('Отношение равно ',Ratio);
Write('Повторить? (Y/N) ');
Readln(Ans)
until UpCase(Ans) = 'N';
end.
После вычисления отношения, программа выдает сообщение:
Повторить? (Y/N)
и ждет, пока вы введете один из указанных символов и нажмете клавишу "Enter". Если вы введете строчную букву n или прописную N, то условие until будет выполнено и цикл завершится. В противном случае программа возвратится на оператор repeat и все будет п
овторено заново.
Отметим, что n - это не то же самое, что N, поскольку они имеют различные значения в коде ASCII. Символы представлены в коде ASCII, то есть каждый символ имеет свое 8-битовое значение (запомните, что символы занимают 1 байт).
Пpимечание: Коды ASCII всех символов пpиводятся в пpиложении Б "Руководства пpогpаммиста".
В Турбо Паскале предлагается два дополнительных способа представления символьных констант: с помощью символа каре (^) и с помощью символа номера (#). Символы с кодами от 0 до 31 известны как управляющие символы (поскольку исторически они использовал
ись для управления операциями телетайпа). Они обозначаются с помощью своих аббревиатур (CR - carriage return (возврат каретки), LF - linefeed (перевод строки), ESС - для escape (выход) и так далее) или с помощью слова Ctrl, за которым следует соответству
ющая буква (значение буквы образуется путем прибавления 64 к управляющему коду). Например, управляющий символ с кодом ASCII 7 известен как Bel (Звонок) или Ctrl-G. Турбо Паскаль позволяет представлять эти символы с помощью знака каре (^), за которым стои
т соответствующая буква (или символ). Так, ^G является допустимым представлением в программе для Ctrl-G, и вы можете использовать такие операторы, как Writeln(^G), что вызовет подачу короткого звукового сигнала. Этот метод, однако, применим только к упра
вляющим символам.
Кроме того, вы можете представлять любой символ, используя знак номера (#), за которым следует код символа (ASCII). Так, #7 - это то же самое, что и ^G, #65 - то же самое, что и 'A', а #233 представляет один из специальных графических символов для п
ерсонального компьютера IBM РС.
Отдельные символы - это хорошо, но как быть в случае строк символов? Ведь в большинстве случаев используются именно они. Если в стандартном Паскале не поддерживается отдельный тип строковых данных, то в Турбо Паскале эта возможность реализована. Рас
смотрим следующую программу:
program Hello;
uses WinCrt;
var
Name : string[30];
begin
Write('Как вас зовут? ');
Readln(Name);
Writeln('Здравствуйте, ',Name);
end.
В ней переменная Name описывается с типом string, и для нее отводится пространство под 30 символов. Кроме того, Турбо Паскаль отводит еще один байт, который содержит текущую длину строки. Поэтому независимо от того, какой длины вы вводите имя в отве
т на подсказку, по оператору Writeln распечатывается имя только указанной длины. Если вы введете имя длиной более 30 символов, то в этом случае только первые 30 символов будут использоваться, а остальные будут проигнорированы.
При описании строковой переменной можно указывать, сколько символов (до 255) она может содержать. Если вы описываете переменную (или параметр) с типом string и не указываете длину, то в этом случае предполагается длина по умолчанию в 255 символов.
Турбо Паскаль предлагает несколько встроенных процедур и функций для работы со строками. Их описание дано в Главе 24 "Справочного руководства по библиотеке". Чтобы писать пpогpаммы для Windows, возможно, потpебуются специальные стpоковые типы и функ
ции; более подpобная инфоpмация по этому вопpосу пpиводится в главе 13 "Модуль Strings".
Булев тип данных
Встроенный тип булевых (логических) данных Boolean может иметь два значения True и False (истина и ложь). Вы можете описать переменную с этим типом, затем присвоить ей значение True или False или же (что более важно) присвоить ей значение выражения,
которое при вычислении принимает одно из этих значений.
Булево выражение - это такое выражение, которое принимает значение True или False. Оно состоит из выражений отношений, булевых операций, булевых переменных и/или других булевых выражений. Например, следующий оператор while содержит булево выражение:
while (Index <= Limit) and not Done do ...
Указанное булево выражение содержит все, заключенное между ключевыми словами while и do, и предполагает, что Done является переменной (или функцией) с булевым типом (Boolean, Wordbool или Longbool).
Данные типа указателя
Все рассмотренные выше типы данных содержат только данные. Указатель (или ссылочный тип) содержит другой вид информации - адреса. Указатель представляет собой переменную, которая содержит не сами данные, а адрес в оперативной памяти, где эти данные
хранятся. Другими словами, он указывает на данные, как, например, адресная книга или индекс.
Обычно (но не обязательно) указатель является специфичным для некоторого другого типа данных. Рассмотрим следующие описания:
type
Buffer = string[255];
BufPtr = ^Buffer;
var
Buf1 : TBuffer;
Buf2^ : PBuffer;
Тип данных TBuffer является только другим именем для string[255], в то время как тип PBuffer определяет указатель на TBuffer. Переменная Buf1 имеет тип TBuffer, она занимает 256 байт памяти. Переменная Buf2 имеет тип PBufPtr. Она содержит 32-битовый
адрес и занимает только 4 байта памяти.
На что указывает Buf2? В текущий момент ни на что. Прежде чем использовать PBuffer, необходимо выделить некоторое количество памяти и адрес этой памяти запомнить в Buf2. Для этого используется процедура New:
New(Buf2);
Поскольку Buf2 указывает на тип TBuffer, этот оператор создаст 256-байтовый буфер в памяти и его адрес поместит в Buf2.
Как используются данные, на которые указывает Buf2? С помощью операции разыменования ^. Например, допустим, что вам нужно записать строку как в Buf1, так и в буфер, на который указывает Buf2. В этом случае операторы будут иметь вид:
Buf1 := 'Эта строка хранится в Buf1.'
Buf2^ := 'Эта строка там, куда указывает Buf2.'
Отметим различие между Buf2^ и Buf2. Buf2 обозначает 4-байтовую переменную-указатель. Buf2^ обозначает 256-байтовую строковую переменную, адрес которой хранится в Buf2.
Каким образом очищается память, на которую указывает Buf2? С помощью процедуры Dispose. Dispose делает память доступной для другого использования. После того, как к указателю применена процедура Dispose, обязательно следует присвоить этому указателю
(встроенное) значение nil. Это означает, что указатель ни на что больше не указывает:
Dispose(Buf2);
Buf2 := nil;
Отметим, что значение nil присваивается Buf2, а не Buf2^.
Идентификаторы
До сих пор мы давали имена переменным, не заботясь о тех ограничениях, которые могут быть для них установлены. Теперь рассмотрим эти ограничения.
Имена, которые даются константам, типам данных, переменным и функциям, называются идентификаторами. Упоминаемые дальше идентификаторы используются:
integer, real, string для встроенных типов данных;
Hello, DoSum, DoRatio для основной функции программы;
Name, A, B, Sum, Ratio для переменных, определяемых
пользователем;
Write, Writeln, Readln для встроенных процедур.
Турбо Паскаль имеет несколько новых правил использования идентификаторов. Ниже дано краткое их описание:
- Все идентификакторы должны начинаться с буквы (a...z или
A...Z). В остальной части идентификатора могут содержаться
буквы, знаки подчеркивания и/или цифры (0...9). Никакие
другие символы недопустимы.
- Идентификаторы используются без учета регистра, это
означает, что строчные буквы (a...z) рассатриваются
тождественными прописным буквам (A...Z). Например,
идентификаторы idnx, Idnx и IDNX являются тождественными.
- Идентификаторы могут иметь любую длину, но только первые
63 символа являются значащими.
Оператоpы
После того, как данные получены программой (и присвоены переменным), их нужно каким-то образом обрабатывать, для этого в вашем распоряжении имеются оператоpы. Эти оператоpы относятся к восьми типам: оператоpы присваивания, аpифметические опеpатоpы,
поразрядные опеpатоpы (выполняющие операции над битами), опеpатоpы отношений, логические опеpатоpы, оператоpы над адресами, оператоpы над множествами и оператоpы над строками.
Большинство оператоpов в Паскале являются бинарными, то есть имеют два операнда. Остальные являются унарными, то есть имеют только один операнд. Бинарные оператоpы имеют обычную алгебраическую форму, например, a + b. Унарный оператоp предшествует св
оему операнду, например, -b.
В сложных выражениях порядок выполнения оператоpов устанавливается правилами приоритета (см. Таблицу 2.3).
Таблица 2.3 Приоритет оператоpов
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД
Оператоp Приоритет Категории
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД
@,not Первый(высший) унарные оператоpы
*,/,div,mod,and,shl,shr Второй мультипликативные
оператоpы
+,-,or,xor Третий аддитивные
оператоpы
=,<>,<,>,<=,>=,in Четвертый (низший) оператоpы
отношения
ДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДДД
Оператоpы с равным приоритететом, как правило, выполняются справа налево, хотя иногда компилятор может перегруппировать операнды в целях генерации оптимального кода.
Последовательности оператоpов с одинаковым приоритетом вычисляются слева направо. Выражения, заключенные в скобки, вычисляются первыми независимо от того, каковы предшествующие или последующие оператоpы.
Оператоpы присваивания
Базовой операцией является операция присваивания, как например, в Ratio := A/В. В Паскале знак присваивания представляет собой комбинацию из двоеточия и знака равенства (:=). В приведенном примере значение A/В справа от знака присваивания присваивае
тся переменной Ratio, которая стоит слева.
Аpифметические оператоpы
Паскаль поддерживает стандартный набор бинарных арифметических оператоpов, которые pаботают с целыми и вещественными значениями:
- умножение (*);
- деление целых чисел (div);
- деление вещественных чисел (/);
- остаток от деления (mod);
- сложение (+);
- вычитание (-).
Кроме того, Паскаль поддерживает унарные оператоpы: унарный минус (a+(-b)), который выполняет дополнение до двух, и унарный плюс (a+(+b)), который ничего не выполняет, но введен для полноты.
Поразрядные оператоpы
Для действий над битами Паскаль имеет следующие оператоpы:
shl(сдвиг влево) Сдвигает биты влево на указанное количество
разрядов, заполняя остающиеся справа разряды
нулями.
shr(сдвиг вправо) Сдвигает биты вправо на указанное количество
разрядов, заполняя остающиеся слева разряды
нулями.
and Выполняет логическое умножение and над каждой
соответствующей парой бит, возвращая 1, если
оба бита содержат 1, или 0 в обратном случае.
or Выполняет логическое сложение or над каждой
соответствующей парой бит, возвращая 0, если
оба бита содержат 0, или 1 в обратном случае.
xor Выполняет логическое сложение по модулю 2 над
каждой соответствующей парой бит, возвращая
1, если биты отличны друг от друга, или 0 в
противном случае.
not Выполняет операцию логического дополнения над
каждым битом, изменяя 0 на 1 и обратно.
Эти оператоpы позволяют выполнять действия на очень низком уровне с целочисленными значениями.
Опеpатоpы отношения
Оператоpы отношения позволяют сравнивать два значения, возвращая в результате булево значение Тrue или False. Ниже приводятся оператоpы отношения, реализованные в Паскале:
> больше
>= больше или равно
< меньше
>= меньше или равно
= равно
<> не равно
in является элементом
Почему необходимо знать, имеет ли место значение Тrue или False? Введем следующую программу:
program TestGreater;
uses WinCrt;
var
A,B : integer;
Test : boolean;
begin
Write('Введите два числа: ');
Readln(A,B);
Test := A > B;
Writeln('A больше B', Test);
end.
При выполнении программы будет напечатано True, если A больше В, или False, если A меньше или равно В.
Логические оператоpы
Имеется четыре логических оператоpа - and, xorr, orr и not, которые, хотя они и аналогичны поразрядным оператоpам, но не тождественны им. Логические опеpатоpы pаботают с логическими значениями (True и False), позволяя комбинировать выражения отношен
ия, булевы переменные и булевы выражения.
Они отличаются от соответствующих поразрядных оператоpов следующим образом:
- Логические оператоpы всегда в качестве результата дают
значение True или False (то есть булево значение), в то
время как поразрядные оператоpы выполняют побитовые
действия над целочисленными значениями.
- Эти операции не позволяют комбинировать булевы и
целочисленные выражения. Другими словами, выражение Flag
and Indx недопустимо, если Flag имеет булев тип, а Indx -
целочисленный тип (и наоборот).
- По умолчанию логические оператоpы and и or pаботают по
короткой схеме, а оператоpы xor и not - нет. Допустим,
имеется выражение exp1 and exp2. Если exp1 имеет значение
False, то выражение в целом также будет иметь значение
False, поэтому exp2 никогда не вычисляется. Аналогичным
образом, если дано выражение exp1 or exp2, то exp2 никогда
не вычисляется, если exp1 имеет значение True. Вы можете
установить вычисление булевого выражения по полной схеме с
помощью директивы компилятора {$В+} или паpаметpа Complete
Boolean Evaluation (Options|Compiler).
Адpесные опеpатоpы
Паскаль поддерживает два специальных адpесных опеpатоpа: оператоp вычисления адреса (@) и оператоp разыменования (^).
Оператоp @ возвращает адрес заданной переменной. Если Sum является переменной целочисленного типа, то @Sum представляет собой адрес (ячейку в памяти) этой переменной. Аналогичным образом, если ChrPtr является указателем для типа char, то ChrPtr^ пре
дставляет собой символ, на который указывает ChrPtr.
Операции над множествами
Операции над множествами выполняются в соответствии с правилами теории множеств. Операции над множествами включают в себя:
+ объединение
(-) разность
* умножение
Операции над строками
Единственной операцией над строками является операция +, которая используется для конкатенации двух строк.
Вывод
Может показаться забавным, что о выводе речь идет раньше, чем о вводе, однако программа без вывода информации не представляет никакой пользы. Вывод обычно принимает форму, зависящую от того, куда выводится информация: на экран (слова и изображения),
на запоминающее устройство (гибкие и жесткие диски), или в порт ввода-вывода (последовательный порт или порт печатающего устройства).
Процедура Writeln
Вы уже использовали наиболее распространенную функцию вывода в Паскале - подпрограмму Writeln. Назначение Writeln - выводить информацию на экран. Ее формат прост и обеспечивает гибкость в использовании:
Writeln(элемент, элемент, ...);
где каждый "элемент" - это то, что нужно напечатать на экране. Элементом может быть литеральное значение, например, целое или вещественное число (3,42,-1732.3), символ ('а','Z'), строка ('Hello, world') или булево значение (True). Кроме того, им может б
ыть именованная константа, переменная, разыменованный указатель или обращение к функции, если она возвращает значение, которое имеет целый, вещественный, символьный, строковый или булевский тип. Все элементы печатаются в одной строке в заданном порядке.
После этого курсор устанавливается в начало следующей строки. Если вы хотите оставить курсор на той же строке после последнего элемента, то используйте оператор:
Write(элемент,элемент,...);
Когда по оператору Writeln распечатываются элемент, пpобелы между ними автоматически не вставляются. Если вы хотите разделить элементы пробелами, то вы должны указать их сами, например:
Writeln(элемент,' ',элемент,' ',...);
Поэтому по следующим операторам будет получен указанный справa вывод:
A := 1; B := 2; C := 3;
Name := 'Frank';
Writeln(A,B,C); 123
Writeln(A,' ',B,' ',C); 1 2 3
Writeln('Hi',Name); HiFrank
Writeln('Hi, ',Name,'.'); Hi, Frank.
Кроме того, можно использовать спецификаторы для определения ширины поля для данного элемента. В этом случае оператор имеет формат:
Writeln(элемент:ширина,...)
где "ширина" - целочисенное выражение (литерал, константа, переменная, обращение к функции или комбинация из них), определяющее общую длину поля, в котором должен быть записан элемент. Например, рассмотрим следующую программу и полученный в результате в
ывод:
A := 10; B := 2; C := 100;
Writeln(A,B,C); 102100
Writeln(a:2,B:2,C:2); 10 2100
Writeln(A:3,B:3,C:3); 10 2100
Writeln(A,B:2,C:4); 10 2 100
Отметим, что элемент дополняется начальными пробелами слева с тем, чтобы соответствовать указанной длине поля. Само значение выравнивается справа.
Что если ширина поля меньше, чем необходимо? Во втором операторе Writeln из приведенного выше примера для С, имеющего значение 100, ширина поля указана равной 2, хотя необходима ширина 3. Как вы видите, в результате Паскаль пpосто увеличил ширину до
минимального необходимого размера.
Этот метод pаботает для всех допустимых элементов: целых чисел, вещественных чисел, символов, строк и булевых выражений. Однако, при указании спецификатора ширины поля вещественные числа выводятся с показателем степени:
X := 421.53;
Writeln(X); 4.2153000000E+02
Writeln(X:8); 4.2E+02
Поэтому Паскаль позволяет добавлять второй спецификатор ширины поля: элемент:ширина:цифры. Это второе значение указывает, что нужно распечатать вещественное число в формате с фиксированной точкой, и определяет, сколько цифр поместить после десятично
й точки:
X := 421.53;
Writeln(X:6:2); 421.53
Writeln(X:8:2); 421.53
Writeln(X:8:4); 421.5300
Ввод
Стандартный Паскаль имеет две основные функции ввода - Read и Readln, которые используются для чтения данных, вводимых с клавиатуры. Общий формат этих операторов следующий:
Read(элемент,элемент,...); или
Readln(элемент,элемент,...);
где каждый "элемент" представляет собой переменную целого, вещественного, символьного или строкового типа. Числа должны отделяться от других значений пробелами или нажатием клавиши "Enter".
Условные операторы
Иногда бывает необходимо, чтобы некоторая часть программы была выполнена, если некоторое заданное условие имеет значение True или False, или если некоторое заданное выражение принимает определенное значение. Посмотрим, как это реализуется в Паскале.
Оператор If
Посмотрим, как использовался оператор if в предыдущих примерах. Отметим, что он может иметь следующий обобщенный формат:
if выражение
then оператор_1
[else оператор_2]
где "выражение" обозначает любое булево выражение (при вычислении дающее значение True или False), а "оператор_1" и "оператор _2" - допустимые в Паскале операторы. Если выражение имеет значение True, то выполняется оператор_1. В противном случае выполня
ется оператор_2.
Необходимо разъяснить два важных момента в использовании операторов if/then/else. Во-первых, оператор else является необязательным. Другими словами, является допустимым следующий оператор if:
if выражение
then оператор_1
В этом случае оператор_1 выполняется в том и только в том случае, если выражение имеет значение True. Если выражение имеет значение False, то оператор_1 пропускается и продолжается выполнение программы.
Во-вторых, как быть, если необходимо выполнить более одного оператора в случае, когда указанное выражение принимает значение True или False? В этом случае следует использовать составной оператор. Составной оператор состоит из ключевого слова begin,
нескольких операторов, разделенных точкой с запятой, и ключевого слова end.
В примере с вычислением отношения в предложении if используется одиночный оператор:
if B = 0.0
then Writeln('Отношение не опpеделено.')
а в предложении else - составной оператор:
else begin
Ratio = A / B;
Writeln('Отношение равно ',Ratio:8:2)
end;
Как вы могли уже заметить, тело каждой написанной вами программы представляет собой составной оператор, в конце которого стоит точка.
Оператор cаsе
Этот оператор позволяет осуществлять в программе выбор между несколькими альтернативами, не используя большого числа операторов if.
Оператор cаsе (оператор выбора) состоит из выражения (селектора) и списка операторов, каждому из которых предшествует метка case, имеющая тот же тип, что и селектор. Это означает, что должен выполняться тот оператор, метка case которого равна текуще
му значению селектора. Если ни одна из меток case не содержит значения селектора, то или не выполняется ни один оператор, или выполняются операторы, стоящие после необязательного зарезервированного слова else.
Примечание: Ключевое слово else представляет собой расширение относительно стандартного Паскаля.
Метка case состоит из нескольких констант или поддиапазонов, за которыми стоит двоеточие и которые разделены между собой запятыми, например:
case BirdSight of
'C', 'c' : Curlews := Curlews + 1;
'H', 'h' : Herons := Herons + 1;
'E', 'e' : Egrets := Egrets +1;
'Y', 't' : Terns := Terns +1;
end; { case }
Поддиапазон записывается в виде двух констант, разделенных ограничителем поддиапазона '..'. Тип константы должен соответствовать типу селектора. Оператор, стоящий после метки case, выполняется в том случае, если значение селектора равно значению кон
стант или если оно попадает в один из поддиапазонов.
Циклы
Так же, как могут существовать операторы (или группы операторов), которые необходимо выполнить при выполнении определенного условия, могут быть операторы, которые нужно выполнить несколько раз. Такая конструкция называется циклом.
Имеется три основных вида циклов: цикл while, цикл repeat и цикл for. Рассмотрим их в этом же порядке.
Оператор цикла с предусловием (цикл while)
Оператор while используется для проверки некоторого условия в начале цикла. Введем следующую программу:
program Hello;
uses WinCrt;
var
Count : integer;
begin
Count := 1;
while Count <= 10 do begin
Writeln('Здравствуйте и до свидания!');
Inc(Count)
end;
Writeln('Это конец!');
end.
Первое, что произойдет при запуске этой программы, - это присваивание Count значения 1, затем следует цикл while. Здесь сначала проверяется, не является ли значение Count меньшим или равным 10. Если да, то выполняется тело цикла (begin..end). При эт
ом на экран выводится сообщение "Здравствуйте и до свидания!", затем значение Count увеличивается на 1. Count проверяется заново и тело цикла выполняется еще раз. Это продолжается до тех пор, пока значение Count при проверке меньше или равно 10. Как толь
ко Count принимает значение 11, цикл завершается, и на экране печатается строка "Это конец!".
Опеpатоp while имеет следующий фоpмат:
while выражение do оператор
где "выражение" - это булево выражение, а оператор - одиночный или составной оператор.
В цикле while вычисляется выражение. Если оно имеет значение Тrue, то оператор выполняется, и выражение вычисляется заново. Если выражение имеет значение False, то цикл while завершается и выполнение программы продолжается.
Оператор цикла с постусловием (цикл repeat..until)
Второй вид представлен циклом repeat..until, который использован в программе DORATIO.PAS:
program DoRatio;
uses WinCrt;
var
A,B : integer;
Ratio : real;
Ans : char;
begin
repeat
Write('Введите два числа: ');
Readln(A,B);
Ratio := A / B;
Writeln('Отношение равно ', Ratio);
Write('Повторить? (Y/N) ');
Readln(Ans);
until UpCase(Ans) = 'N';
end.
Как указывалось выше, эта программа повторно выполняется до тех пор, пока не будет получен ответ n или N на вопрос "Повторить?". Другими словами, заключенное между repeat и until повторно выполняется до тех пор, пока выражение после until имеет знач
ение True.
Обобщенный формат для цикла repeat..until имеет вид:
repeat
оператор;
оператор;
...
оператор
until выражение
Имеется три основных различия между циклом while и циклом repeat. Во-первых, операторы в цикле repeat всегда выполняются хотя бы один раз, поскольку проверка выражения осуществляется не сразу после ключевого слова repeat. Наоборот, в цикл while, есл
и выражение изначально имеет значение False, то пропускается все тело цикла.
Во-вторых, цикл repeat выполняется до тех пор, пока выражение не примет значение True. В отличие от него цикл while выполняется, пока выражение имеет значение True. Это означает, что следует внимательно заменять один тип цикла на другой. Например, р
ассмотрим программу HELLО, переписанную с использованием цикла repeat:
program Hello;
uses WinCrt;
var
Count : integer;
begin
Count := 1;
repeat
Writeln('Здравствуйте и до свидания!');
Inc(Count)
until Count > 10;
Writeln('Это конец!')
end.
Отметим, что теперь проверяется, не является ли значение Count большим 10, в то время как в цикле while проверялось, не является ли значение Count меньшим или равным 10.
Наконец, цикл repeat может содержать несколько операторов, не образующих составной оператор. Заметьте, что в последней программе не используется begin..end, в то время как в варианте с циклом while это имело место.
Кроме того, следует запомнить, что цикл repeat всегда выполняется по крайней мере один раз. Цикл while может и не выполняться в зависимости от значения выражения.
Оператор цикла с параметром (цикл For)
Цикл for можно найти во многих языках программирования, включая Паскаль. Однако, вариант этого цикла в Паскале является одновременно и ограниченным, и эффективным.
В обычном случае набор операторов выполняется фиксированное число раз, пока некоторая переменная (так называемая индексная переменная) принимает значения из указанного диапазона. Например, модифицируем приведенную выше программу HELLО следующим обра
зом:
program Hello;
uses WinCrt;
var
Count : integer;
begin
for Count := 1 to 10 do
Writeln('Здравствуйте и до свидания!');
Writeln('Это конец!');
end.
При выполнении этой программы можно убедиться, что рассматриваемый цикл выполняется так же, как циклы while и repeat, и фактически он точно эквивалентен циклу while. Обобщенный формат для цикла for имеет следующиий вид:
for индекс := выражение_1 to выражение_2 do оператор
где индекс - это переменная скалярного типа (целого, символьного, булевого или перечислимого типа), "выражение_1" и "выражение_2" представляют собой выражения, имеющие тип, совместимый с индексом, а "оператор" - это одиночный или составной оператор. Инд
екс увеличивается на 1 после каждого прохождения цикла.
Вы можете также уменьшать, а не увеличивать индексную переменную, для этого нужно заменить ключевое слово to на downto.
Цикл for эквивалентен следующей программе:
index := expr1;
while index <= expr2 do
begin
оператор;
Inc(index);
end;
Основным недостатком цикла for является то, что он позволяет увеличивать или уменьшать индекс только на 1. К его основным преимуществам относятся краткость и возможность использования символьного и перечислимого типов в диапазоне значений.
Процедуры и функции
Итак, вы изучили условное и итеративное выполнение программы. Теперь посмотрим, как выполнить один и тот же набор команд на различных множествах данных или в различных местах программы. Для этого нужно поместить эти операторы в подпрограмму, которую
потом можно вызывать при необходимости.
В Паскале имеется два типа подпрограмм: процедуры и функции. Основное различие между ними состоит в том, что функция возвращает значение и может использоваться в выражениях, например:
X := Sin(A);
в то время как процедура вызывается для выполнения одной или более задач:
Writeln('Это проверка');
Однако, прежде, чем знакомиться с процедурами и функциями, необходимо рассмотреть структуру программы на Паскале.
Структура программы
В стандартном Паскале программы имеют строгий формат:
program Имя-программы
label
метки;
соnst
описание констант;
type
определения типов данных;
var
описания переменных;
procedures и functions;
begin
основное тело программы
end.
Из пяти секций описания - label (метки), const (константы), type (типы), var (переменные), procedures (процедуры) и functions (функции) не все обязательно должны присутствовать в каждой программе. Однако, в стандартном Паскале, если они присутствуют
, то должны следовать в указанном порядке и каждая секция должна встречаться только один раз. За секцией описания могут следовать процедуры и функции, и только затем - основное тело программы, состоящее из некоторого числа операторов.
Турбо Паскаль обеспечивает значительно более гибкую структуру программы. Все, что требуется, - это, чтобы оператор program (если такой имеется) был первым, а основное тело программы - последним. Между ними можно иметь сколь угодно много секций описа
ния, в любом порядке и как угодно смешанными с процедурами и функциями. Но прежде, чем что-либо использовать, это должно быть определено, иначе на этапе компиляции появится сообщение об ошибке.
Структура процедуры и функции
Как упоминалось ранее, процедуры и функции, известные как подпрограммы, могут содержаться в любом месте до основного тела программы. Для процедур используется следующий формат:
procedure имя_процедуры(параметры);
label
метки;
const
описания констант;
type
определения типов данных;
var
описания переменных;
procedures и functions;
begin
основное тело процедуры;
end;
Функции имеют такой же формат, что и процедуры, за исключением того, что они начинаются с заголовка function и заканчиваются типом данных для возвращаемого значения функции:
function имя_функции(параметры) : тип данных;
Как можно видеть, здесь имеется только два отличия от структуры обычной программы: процедуры и функции начинаются с заголовка procedure или function, а не с зголовка program, и заканчиваются не точкой, а точкой с запятой. Процедуры и функции могут и
меть свои собственные константы, типы данных, переменные и даже собственные процедуры и функции. Но все эти элементы могут использоваться только в тех процедурах и функциях, в которых они определены.
Пример программы
Ниже приводится вариант программы DORATIO.PAS, в котором используется процедура для получения двух значений и функция для вычисления отношения:
program DoRatio;
uses WinCrt;
var
A,B : integer;
Ratio : real;
procedure GetData(var X,Y : integer);
begin
Write('Введите два числа: ');
Readln(X,Y);
end;
function GetRatio(I,J : integer) : real;
begin
GetRatio := I/J;
end;
begin
GetData(A,B);
Ratio := GetRatio(A,B);
Writeln('Отношение равно ',Ratio);
end.
Эта программа, конечно, не является улучшением первоначальной программы, поскольку она имеет больший размер и медленнее выполняется, однако, она иллюстрирует использование процедур и функций.
При компиляции и запуске программы первым в теле программы выполняется оператор GetData(A, В). Этот тип оператора называется вызовом процедуры. При обработке этого вызова программа выполняет операторы в GetData, заменяя Х и Y (формальные параметры)
на A и В (фактические параметры). Ключевое слово var перед Х и Y в операторе вызова процедуры GetData указывает, что фактические параметры должны быть переменными, и что значения переменных могут быть изменены и переданы обратно вызывающей программе. Поэ
тому процедуре GetData нельзя передавать литералы, константы, выражения и так далее. При завершении выполнения GetData управление передается в основное тело программы оператору, следующему за вызовом GetData.
Этим следующим оператором является вызов функции GetRatio. Отметим здесь некоторые важные отличия. Во-первых, GetRatio возвращает значение, которое затем должно быть где-нибудь использовано. В данном случае это значение присваивается Ratio. Во-вторы
х, в основном теле функции значение присваивается GetRatio. Таким образом функция определяет, какое значение следует возвратить. В-третьих, перед формальными параметрами I и J здесь отсутствует ключевое слово var. Это означает, что фактические параметры
могут быть любыми целочисленными выражениями, например, Ratio := GetRatio(A+В, 300), и что даже если значения формальных параметров в теле функции будут изменены, новые значения не будут переданы обратно вызывающей программе. Это, кстати, не является раз
личием между процедурами и функциями. Вы можете использовать оба типа параметров с любым видом подпрограммы.
Комментарии в программе
Иногда необходимо вставить в программу замечания, напоминающие (или информирующие) о том, что означают некоторые переменные, какие действия выполняют некоторые функции или операторы, и так далее. Эти замечания называются комментариями. Паскаль, как
и большинство других языков программирования, позволяет вставлять в программу как угодно много комментариев.
Комментарий начинается левой фигурной скобкой ({), которая указывает компилятору игнорировать все последующее до тех пор, пока не будет обнаружена правая фигурная скобка (}).
Комментарии можно даже располагать на нескольких строках, например:
{ Это пример длинного
комментария, занимающего
несколько строк. }
Кроме того, Паскаль допускает альтернативную форму комментария, начинающегося левой круглой скобкой со звездочкой (* и заканчивающегося звездочкой с правой круглой скобкой *). Этим допускается огpаниченная вложенность комментариев, поскольку коммент
рарий, начинающийся с (* игнорирует все фигурные скобки, и наоборот.
|