Целое десятичное число
FF - шестнадцатеричное число
Вещественное число
-12.3 - отрицательное вещественное число
Вещественные десятичные числа в форме с плавающей точкой представлены в экспоненциальном виде: тЕ+р, где т - мантисса (целое или дробное число с десятичной точкой), Е- означает '•десять в степени", р - порядок (целое число),
Пример:
5.18E+02= 5.18 * 102 = 518
Пользовательские типы - перечисляемый и интервальный - разрабатываются самим программистом.
Структурированные типы в своей основе имеют один или несколько скалярных типов данных. К структурированным типам относятся строки, массивы, множества, записи, файлы и данные совершенно новой природы: процедурного типа и типа object, двум последним типам трудно поставить в соответствие данные в обычном понимании этого слова.
Скалярные типы данных.
Целочисленные типы. Целочисленные типы данных представляют собой значения, которые могут использоваться в арифметических выражениях и занимать в памяти от 1 до 4 байт.
| Тип | Диапазон | Требуемая память (бит) |
| Byte | 0..255 | |
| Shortint | -128..127 | |
| Smallint | -32768..32767 | |
| Integer | -32768..32767 | |
| Longint | -2147483648.. | |
| Word | 0..65535 |
Пример:
Var
XI, Х2: byte;
YI: integer;
Вещественные типы данных представляют собой вещественные значения, которые используются в арифметических выражениях и занимают в памяти от 4 до 6 байт. Delphi допускает представление вещественных значении в виде как с плавающей, так и с фиксированной точкой.
| Тип | Диапазон | Мантиса | Требуемая память |
| Real | 2.9*10-39..1.7*1038 | 11-12 | |
| Single | 1.5*10-45..3.4*1038 | 7-8 | |
| Double | 5.0*10-324..1.7*10308 | 15-16 | |
| Extended | 3.4*10-4932..1.1*104932 | 19-20 |
Пример:
Var
XI, Х2: real;
YI: double;
2. Данные. Обзор типов данных. Особенности строковых данных.
Строковый тип представлен в виде набора символов из той или иной кодовой страницы и различаются по размеру и способу обращения. По размеру различают строки конечной и бесконечной длины.
Конечные строки бывают двух типов: ShortString (состоит из 255 символов) и String[ ] (в квадратных скобках указывается количество символов в строке).
Бесконечные строки задаются ключевым словом String.
Пример: Var
S1: String;
S2, s3: String[27];
S4: ShortString;
3. Данные. Обзор типов данных. Особенности пользовательских данных.
Пользовательские типы
Кроме стандартных типов данных Паскаль поддерживает скалярные типы, определенные самим пользователем. К ним относятся перечислимые типы (когда непосредственно, в разделе описания типов, заранее записываются все значения для переменных этого типа) и интервальные (когда задаются границы диапазона значений для данной переменной), указательные тип (кроме Pointer), структурированные типы и процедурные типы.
Данные этих типов занимают в памяти один байт, поэтому скалярные пользовательские типы не могут содержать более 256 элементов. Их применение значительно улучшает наглядность программы, делает более легким поиск ошибок, экономит память.
Перечислимый тип
Перечислимый тип данных задается непосредственно перечислением всех значений, которые может принимать переменная данного типа. При описании отдельные значения указываются через запятую, а весь список заключается в круглые скобки. Например,
Var Season: (winter,spring,summer,autum);
Temp: (23,24,25,26);
Интервальный тип
Интервальный тип позволяет задавать две константы,определяющие границы диапазона значений для каждой переменной.Обе константы должны принадлежать одному и тому же стандартному типу (кроме real). Например,
Var S:1..30;
Сh:'a'..'f';
Указательный тип
Указательные типы - их значениями являются адреса памяти. В отличие от стандартного указательного типа Pointer, пользовательский тип определяет множество значений, которые указывают на динамические переменные определенного типа, называемого базовым типом. Указатель на какой-либо тип может быть описан до объявления самого типа:
Type PtStack=^Stack;
Stack=array[1..40] of real;
Процедурный тип
Процедурный тип позволяет объявлять переменные, которым допускается присваивание имен процедур, функций и методов, а также передавать такие переменные и имена в качестве параметров. Описание процедурных типов имеет такой же синтаксис, как и объявление процедур и функций:
Type Tproc1=procedure (var x,y:real);
Tproc2=function (x:real):real;
4. Данные. Обзор типов данных. Объявление переменных и констант.
5. Арифметические операции с данными.
Основное предназначение арифметических операций - выполнять определенные арифметические действия над числовыми данными: складывать, вычитать, умножать, делить и т. д. Это означает, что для арифметических операций все операнды вычисляются в числовом скалярном контексте. При этом строки, содержащие правильные числовые литералы, автоматически будут преобразованы в числовые значения: если строка не содержит правильного числового литерала, то интерпретатор попытается выделить из нее число, начиная с левого символа, и использовать его в качестве операнда; если не удается выделить правильный числовой литерал, то строковый операнд принимает нулевое значение.
Арифметические операции
| Операция | Действие | Типы операндов | Тип результата | Пример | |
| Бинарные | + | Сложение | Целый Вещественный | Целый Вещественный | 1 + 5 = 6 1.5 + 5.3 = 6.9 |
| - | Вычитание | Целый Вещественный | Целый Вещественный | 6 – 1 = 5 7.2 – 4.1 = 3.1 | |
| * | Умножение | Целый Вещественный | Целый Вещественный | 3 * 5 = 15 3.2 * 2 = 6.4 | |
| / | Деление | целый Вещественный | Вещественный | 30 / 5 = 6 30 / 60 = 0.5 | |
| Div | Целочисленное Деление | Целый | Целый | 12 div 5 = 2 11 div 3 = 3 1 div 3 = 0 | |
| Mod | Остаток | целый | Целый | 11 mod 5 = 1 10 mod 3 = 1 14 mod 5 = 4 | |
| And | Арифметическое И | Целый | Целый | 1 and 1 = 1, 1 and 0 = 0, 0 and 1=0, 0 and 0 = 0 12 and 22 = 4 | |
| Or | Арифметическое ИЛИ | Целый | Целый | 1 or 1 = 1, 1 or 0 = 1, 0 or 1 = 1, 0 or 0 = 0, 12 or 22 = 30 | |
| Унарные | + | Сохранение знака | Целый Вещественный | Целый Вещественный | +(-12) = -12 +(34) = 34 |
| - | Отрицание знака | Целый Вещественный | Целый Вещественный | -(-17) = 17 -(24) = -24 | |
| Not | Арифметическое отрицание | Целый | Целый | Not 0 = -1 Not 78 = -79 |
Операции сложения (+), вычитания (-), умножения (•) и деления (/) выполняются так же, как и в обычных арифметических выражениях. Целочисленное деление (div) отличается от обычной операции деления тем, что возвращает целую часть частного, дробная часть отбрасывается. Перед выполнением операции оба операнда округляются до целых значений. Результат целочисленного деления всегда равен нулю, если делимое меньше делителя.
Деление по модулю (mod) восстанавливает остаток от выполнения целочисленного деления.
Арифметическое И (and) производит логическое умножение операндов.
Операнды записываются в десятичной форме,но во время выполнения переводятся в двоичную форму. Результат представлен в десятичной форме.
Пример. Вычислить результат выражения A and В, если А=12 и В=22. А и В занимают в памяти 2 байта и в двоичной форме имеют вид: 000000000001100 и 000000000010110. В результате выполнения операции 0000000000001100 and 0000000010110 в соответствии с таблицей истинности получим результат 0000000000000100, или 4 в десятичной форме. Следовательно. 12 and 22 = 4.
Логическое сложение (or) выполняет сложение операндов в двоичной форме.
Пример. Вычислить результат выполнения выражения 12 or 22. 12 и 22 занимают в памяти по 2 байта и в двоичной форме имеют вид 0000000000001100 и 0000000000010110 соответственно.. Выполнив сложение в соответствии с таблицей истинности, получим двоичное значение суммы 0000000000011110, что соответствует числу 30 в десятичной форме. Следовательно, 12 or 22 = З0.
Применение операции not к данным целочисленных типов вызывает побитную инверсию соответствующего данному числу двоичного кода.
6. Структура программы. Разделы объявления модулей, меток, данных, процедур и функций.
Программа на языке Pascal всегда состоит из двух основных частей: описания последовательности действий, которые необходимо выполнить, и описания данных, с которыми оперируют действия. Действия представляются операторами языка, данные вводятся посредством описаний и определений. Кроме того, программа может быть снабжена заголовком, который задаст имя программы и ее параметры.
Описания данных текстуально предшествуют описанию действий и должны содержать упоминание всех объектов, используемых в действиях (операторах).
Рассмотрим полную структуру программы на языке Паскаль. В общем случае программа состоит из:
- заголовка программы - раздел начинается с ключевого слова program, далее идет название вашей программы.
Например, program Area; - обратите внимание, что любой оператор языка Паскаль заканчивается точкой запятой.
Также распространенной ошибкой является заголовок программы вида: program 1;
Имя программы - это пользовательский идентификатор, и он не может начинаться с цифры. - блок описаний состоит из множества различных блоков программы, каждый из которых отвечает за определенные аспект программы. Мы будем рассматривать возможные блоки по мере необходимости. на схеме ниже вы можете увидеть все из них.
- блок операторов - единственный обязательный блок программы, в нем вы размещайте, те команды которые должны быть выполнены в процессе выполнения программы. Блок операторов начинается с ключевого слова begin и заканчивается end с точкой.
Описание меток вводит совокупность идентификаторов и/или целых чисел, предназначенных для организации последовательности вычислений. Посредством меток можно отметить (указать) те операторы, на которые будет передано управление из других точек программы. Передача управления на помеченный оператор реализуется с помощью специального оператора перехода.
Определение констант задает в программе идентификаторы, являющиеся синонимами (представителями) некоторых значений.
Определение типов предназначено для задания конкретных множеств значений. Указанные множества обозначаются именами (идентификаторами) и в дальнейшем могут служить для описания переменных.
Описание переменных вводит совокупность данных, с которыми производятся действия. Переменная обозначается идентификатором; с каждой переменной связывается ее тип, определяющий множество допустимых значений этой переменной и, соответственно, набор допустимых операций.
Наконец, описание процедуры или функции определяет часть программы как отдельную синтаксическую единицу и сопоставляет с ней имя. Впоследствии действия, сосредоточенные в процедуре (функции), могут быть выполнены ("вызваны") посредством указания ее имени. Кроме действий, описание процедуры (функции) может содержать совокупность описаний локальных объектов, образующих собственный контекст имен. Процедуры и функции являются основным средством структурирования программы.
В авторской версии языка Pascal описания всех перечисленных объектов должны быть сосредоточены в соответствующих разделах, а порядок следования разделов фиксирован. Однако, современные реализации, в частности, Turbo Pascal, не содержат такого ограничения. Иными словами, описания и определения всех объектов в блоке могут следовать в произвольном порядке.
7. Объявление переменных различных типов.
объявления переменных в языке Delphi:
var имя_переменной: тип_переменной;
Слово var - ключевое. Именем может быть любой идентификатор, если он не был описан ранее и не является одним из ключевых или зарезервированных слов языка Delphi. Если нужно описать несколько переменных одного типа, то их перечисляют, отделяя запятой:
var A, B, C: Integer;
Если несколько описаний следуют друг за другом, то ключевое слово var повторно можно не указывать:
var A, B: Integer;
C, D: String;
8. Объявление констант различных типов.
const pi = 3.1415;
ZnakPi: String = 'Это значение числа пи';
9. Библиотечный модуль пользователя. Структура модуля. Секции модуля, их назначение.
Приложения очень часто используют уже ранее созданные автономные программные блоки (процедуры и функции), созданные или самим программистом, или другими авторами. С целью упорядочиния их расположения при программировании используется модульный принцип построения программы, когда основная программа обращается к процедурам и функциям, которые могут находиться не только в самой основной программе (это не очень приветствуется), но и в автономных отдельно существующих макропрограммных единицах – модулях.
Каждый модуль представлен как минимум одним файлом, носящим имя модуля, – файлом *.pas, в котором хранится создаваемый программистом исходный код. Если модуль является еще и описателем какой-либо формы (модуль формы), то для него автоматически создается еще и файл *.dfm, в котором записаны значения параметров самой формы и компонентов на ней расположенных (кнопки, окна, списки и др.). После компилляции модуля образуется еще один файл - *.dcu, который содержит необходимый для выполнения программы код и именно такой файл требуется для подключения к основной программе, однако такой файл уже непригоден для чтения и редактирования программистом. Так основные стандартные модули со стандартными процедурами и функциями Delphi представлены именно в виде таких файлов. Например, описания компонентов кнопок хранятся в стандартном файле модуля buttons.dcu, который размещен в папке LIB.
Программист может использовать как уже существующие модули (с находящимися в них данными, процедурами и функциями), так и создавать свои собственные модули и помещать в них требуемые процедуры и функции.
Для создания нового модуля (без формы) следует выбрать опцию меню File\New и в открывшемся окне выбрать вариант Unit.
Для сохранения кода модуля в виде файла следует выбрать опцию меню File\Save и в открывшемся окне задать имя файла модуля, которое лучше сделать таким же, как и имя самого модуля.
Для подключения модуля к любой другой программной единице (в том числе и другому модулю) следует в разделе uses указать имя требуемого модуля.
Рассмотрим принцип построения модуля.
Заголовок модуля содержит ключевое слово Unit и имя модуля, совпадающее с именем файла модуля. Каждый модуль может состоять из трех секций: секции Интерфейса (Interface), секции Реализации (Implementation) и необязательной секции Инициализации.
Секция Интерфейса (Interface) предназначена для объявления глобальных данных (типов, констант, переменных), а также процедур и функций, которые будут доступны (видимы) для тех модулей, из которых происходит вызов нашего модуля. Процедуры и функции в этой секции только объявляются (со всеми своими параметрами), но не раскрывается их содержимое (это будет в следующей секции).
Секция Реализации (Implementation) позволяет подключить другие требующиеся для выполнения процедур и функций модули. В этой секции описываются данные (типы, константы и переменные), предназначенные для использования только в рамках данного модуля и недоступные (невидимые) для вызывающих модулей (локальные данные), а также приводится текст процедур и функций, объявленных в секции Интерфейса.
Секция Инициализации не имеет своего ключевого слова и начинается со слова Begin, а завершается словом End. Код, записанный между этими программными скобками, предназначен для исполнения при первом же вызове (из какого-либо модуля). Если необходимости в этом нет, то данная секция может отсутствовать.
Приведем пример структуры библиотечного модуля пользователя:
Unit <имя модуля>;
Interface {Секция Интерфейса}
Procedure Integral1(a,b: real; var c: real);
Procedure Summa(d,e: real; var f: real);
Function Integral2(ff,dd: real): real;
Implementation {Секция Реализации}
Uses <имена подключаемых модулей>
Procedure Integral1(a,b: real; var c: real);
Begin
Текст процедуры
End;
Procedure Summa(d,e: real; var f: real);
Begin
Текст процедуры
End;
Function Integral2(ff,dd: real): real;
Begin
Текст функции
End;
Begin {Секция Инициализации}
Текст секции Инициализации
End.
10. Операторы присваивания, безусловного перехода и вызова процедур.
Оператор присваивания
Оператор присваивания (:=) вычисляет выражение, заданное в его правой части, и присваивает результат переменной, идентификатор которой расположен в левой части. Например:
X:= 4;
Y:= 6;
Z:= (X + Y) / 2;
Во избежании ошибок присваивания необходимо следить, чтобы тип выражения был совместим с типом переменной. Под совместимостью типов данных понимается возможность автоматического преобразования значений одного типа данных в значения другого типа данных. Например, все целочисленные типы данных совместимы с вещественными (но не наоборот!).
В общем случае для числовых типов данных действует следующее правило: выражение с более узким диапазоном возможных значений можно присвоить переменной с более широким диапазоном значений. Например, выражение с типом данных Byte можно присвоить переменной с типом данных Integer, а выражение с типом данных Integer можно присвоить переменной с типом данных Real. В таких случаях преобразование данных из одного представления в другое выполняется автоматически:
var
B: Byte;
I: Integer;
R: Real;
begin
B:= 255;
I:= B + 1; // I = 256
R:= I + 0.1; // R = 256.1
I:= R; // Ошибка! Типы данных несовместимы по присваиванию
end.
Исключение составляет случай, когда выражение принадлежит 32-разрядному целочисленному типу данных (например, Integer), а переменная - 64-разрядному целочисленному типу данных Int64. Для того, чтобы на 32-разрядных процессорах семейства x86 вычисление выражения происходило правильно, необходимо выполнить явное преобразование одного из операндов выражения к типу данных Int64. Следующий пример поясняет сказанное:
var
I: Integer;
J: Int64;
begin
I:= MaxInt; // I = 2147483647 (максимальное целое)
J:= I + 1; // J = -2147483648 (неправильно: ошибка переполнения!)
J:= Int64(I) + 1; // J = 2147483648 (правильно: вычисления в формате Int64)
end.
Оператор безусловного перехода
Среди операторов языка Delphi существует один редкий оператор, о котором авторы сперва хотели умолчать, но так и не решились. Это оператор безусловного перехода goto ("перейти к"). Он задумывался для того случая, когда после выполнения некоторого оператора надо выполнить не следующий по порядку, а какой-либо другой, отмеченный меткой, оператор.
Метка - это именованная точка в программе, в которую можно передать управление. Перед употреблением метка должна быть описана. Раздел описания меток начинается зарезервированным словом label, за которым следуют имена меток, разделенные запятыми. За последним именем ставится точка с запятой. Типичный пример описания меток:
label
Label1, Label2;
В разделе операторов метка записывается с двоеточием. Переход на метку выполняется с помощью зарезервированного слова goto, за которым следует имя метки:
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
label
M1, M2;
begin
M1:
Write('Желаем успеха ');
goto M2;
Write('А этого сообщения вы никогда не увидите!');
M2:
goto M1;
Writeln('в освоении среды Delphi!');
Writeln('Press Enter to exit...');
Readln;
end.
Эта программа будет выполняться бесконечно, причем второй оператор Write не выполнится ни разу!
Внимание! В соответствии с правилами структурного программирования следует избегать применения оператора goto, поскольку оно усложняет понимание логики программы. Оператор goto использовался на заре программирования, когда выразительные возможности языков были скудными. В языке Delphi без него можно успешно обойтись, применяя условные операторы, операторы повтора, процедуры Break и Continue, операторы обработки исключений
Оператор вызова процедуры
Оператор вызова процедуры представляет собой не что иное, как имя стандартной или пользовательской процедуры. О том, что это такое, вы узнаете чуть позже, а пока достаточно просто наглядного представления. Примеры вызова процедур:
Writeln('Hello!'); // Вызов стандартной процедуры вывода данных
MyProc; // Вызов процедуры, определенной программистом
11. Условные переходы. Два варианта операторов условного перехода «if».
Оператор ветвления if
Оператор ветвления if - одно из самых популярных средств, изменяющих естественный порядок выполнения операторов программы. Вот его общий вид:
if <условие> then
<оператор 1>
else
<оператор 2>;
Условие - это выражение булевского типа, оно может быть простым или сложным. Сложные условия образуются с помощью логических операций и операций отношения. Обратите внимание, что перед словом else точка с запятой не ставится.
Логика работы оператора if очевидна: выполнить оператор 1, если условие истинно, и оператор 2, если условие ложно. Поясним сказанное на примере:
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
A, B, C: Integer;
begin
A:= 2;
B:= 8;
if A > B then
C:= A
else
C:= B;
Writeln('C=', C);
Writeln('Press Enter to exit...');
Readln;
end.
В данном случае значение выражения А > В ложно, следовательно на экране появится сообщение C=8.
У оператора if существует и другая форма, в которой else отсутствует:
if <условие> then <оператор>;
Логика работы этого оператора if еще проще: выполнить оператор, если условие истинно, и пропустить оператор, если оно ложно. Поясним сказанное на примере:
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
A, B, C: Integer;
begin
A:= 2;
B:= 8;
C:= 0;
if A > B then C:= A + B;
Writeln('C=', C);
Writeln('Press Enter to exit...');
Readln;
end.
В результате на экране появится сообщение С=0, поскольку выражение А > В ложно и присваивание С:= А + В пропускается.
Один оператор if может входить в состав другого оператора if. В таком случае говорят о вложенности операторов. При вложенности операторов каждое else соответствует тому then, которое непосредственно ему предшествует. Например:
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
A: Integer;
begin
Readln(A);
if A >= 0 then
if A <= 100 then
Writeln('A попадает в диапазон 0 - 100.')
else
Writeln('A больше 100.')
else
Writeln('A меньше 0.');
Writeln('Press Enter to exit...');
Readln;
end.
Конструкций со степенью вложенности более 2-3 лучше избегать из-за сложности их анализа при отладке программ
12. Условные операторы. Особенности оператора «Case».
Оператор ветвления case
Оператор ветвления case является удобной альтернативой оператору if, если необходимо сделать выбор из конечного числа имеющихся вариантов. Он состоит из выражения, называемого переключателем, и альтернативных операторов, каждому из которых предшествует свой список допустимых значений переключателя:
case <переключатель> of
<список?1 значений переключателя>: <оператор 1>;
<список?2 значений переключателя>: <оператор 2>;
...
<список?N значений переключателя>: <оператор N>;
else <оператор N+1>
end;
Оператор case вычисляет значение переключателя (который может быть задан выражением), затем последовательно просматривает списки его допустимых значений в поисках вычисленного значения и, если это значение найдено, выполняет соответствующий ему оператор. Если переключатель не попадает ни в один из списков, выполняется оператор, стоящий за словом else. Если часть else отсутствует, управление передается следующему за словом end оператору.
Переключатель должен принадлежать порядковому типу данных. Использовать вещественные и строковые типы в качестве переключателя не допускается.
Список значений переключателя может состоять из произвольного количества констант и диапазонов, отделенных друг от друга запятыми. Границы диапазонов записываются двумя константами через разграничитель в виде двух точек (..). Все значения переключателя должны быть уникальными, а диапазоны не должны пересекаться, иначе компилятор сообщит об ошибке. Тип значений должен быть совместим с типом переключателя. Например:
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
Day: 1..31;
begin
Readln(Day);
case Day of
20..31: Writeln('День попадает в диапазон 20 - 31.');
1, 5..10: Writeln('День попадает в диапазон 1, 5 - 10.');
else Writeln('День не попадает в заданные диапазоны.');
end;
Writeln('Press Enter to exit...');
Readln;
end.
Если значения переключателя записаны в возрастающем порядке, то поиск требуемого оператора выполняется значительно быстрее, так как в этом случае компилятор строит оптимизированный код. Учитывая сказанное, перепишем предыдущий пример:
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
Day: 1..31;
begin
Readln(Day);
case Day of
1, 5..10: Writeln('День попадает в диапазон 1, 5 - 10.');
20..31: Writeln('День попадает в диапазон 20 - 31.');
else Writeln('День не попадает в заданные диапазоны.');
end;
Writeln('Press Enter to exit...');
Readln;
end.
13. Операторы повтора. Сравнительный анализ трех типов операторов повтора.
Операторы повтора - циклы
Алгоритм решения многих задач требует многократного повторения одних и тех же действий. При этом суть действий остается прежней, но меняются данные. С помощью рассмотренных выше операторов трудно представить в компактном виде подобные действия в программе. Для многократного (циклического) выполнения одних и тех же действий предназначены операторы повтора (циклы). К ним относятся операторы for, while и repeat. Все они используются для организации циклов разного вида.
Любой оператор повтора состоит из условия повтора и повторяемого оператора (тела цикла). Тело цикла представляет собой простой или структурный оператор. Оно выполняется столько раз, сколько предписывает условие повтора. Различие среди операторов повтора связано с различными способами записи условия повтора.
14. Оператор повтора «For». Пример.
Оператор повтора for
Оператор повтора for используется в том случае, если заранее известно количество повторений цикла. Приведем наиболее распространенную его форму:
for <параметр цикла>:= <значение 1> to <значение 2> do
<оператор>;
где <параметр цикла> - это переменная любого порядкового типа данных (переменные вещественных типов данных недопустимы); <значение 1> и <значение 2> - выражения, определяющие соответственно начальное и конечное значения параметра цикла (они вычисляются только один раз перед началом работы цикла); <оператор> - тело цикла.
Оператор for обеспечивает выполнение тела цикла до тех пор, пока не будут перебраны все значения параметра цикла от начального до конечного. После каждого повтора значение параметра цикла увеличивается на единицу. Например, в результате выполнения следующей программы на экран будут выведены все значения параметра цикла (от 1 до 10), причем каждое значение - в отдельной строке:
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
I: Integer;
begin
for I:= 1 to 10 do Writeln(I);
Writeln('Press Enter to exit...');
Readln;
end.
Заметим, что если начальное значение параметра цикла больше конечного значения, цикл не выполнится ни разу.
В качестве начального и конечного значений параметра цикла могут использоваться выражения. Они вычисляются только один раз перед началом выполнения оператора for. В этом состоит важная особенность цикла for в языке Delphi, которую следует учитывать тем, кто имеет опыт программирования на языках C/C++.
После выполнения цикла значение параметра цикла считается неопределенным, поэтому в предыдущем примере нельзя полагаться на то, что значение переменной I равно 10 при выходе из цикла.
Вторая форма записи оператора for обеспечивает перебор значений параметра цикла не по возрастанию, а по убыванию:
for <параметр цикла>:= <значение 1> downto <значение 2> do
<оператор>;
Например, в результате выполнения следующей программы на экран будут выведены значения параметра цикла в порядке убывания (от 10 до 1):
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
I: Integer;
begin
for I:= 10 downto 1 do Writeln(I);
Writeln('Press Enter to exit...');
Readln;
end.
Если в такой записи оператора for начальное значение параметра цикла меньше конечного значения, цикл не выполнится ни разу.
15. Оператор повтора «While». Пример.
Оператор повтора while
Оператор повтора while имеет следующий формат:
while <условие> do
<оператор>;
Перед каждым выполнением тела цикла происходит проверка условия. Если оно истинно, цикл выполняется и условие вычисляется заново; если оно ложно, происходит выход из цикла, т.е. переход к следующему за циклом оператору. Если первоначально условие ложно, то тело цикла не выполняется ни разу. Следующий пример показывает использование оператора while для вычисления суммы S = 1 + 2 +.. + N, где число N задается пользователем с клавиатуры:
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
S, N: Integer;
begin
Readln(N);
S:= 0;
while N > 0 do
begin
S:= S + N;
N:= N - 1;
end;
Writeln('S=', S);
Writeln('Press Enter to exit...');
Readln;
end.
16. Оператор повтора «Repeat». Пример.
Оператор повтора repeat
Оператор повтора repeat используют в тех случаях, когда тело цикла должно быть выполнено перед тем, как произойдет проверка условия завершения цикла. Он имеет следующий формат:
repeat
<оператор 1>;
...
<оператор N>;
until <условие завершения цикла>;
Тело цикла выполняется до тех пор, пока условие завершения цикла (выражение булевского типа) не станет истинным. Оператор repeat имеет две характерные особенности, о которых нужно всегда помнить:
между словами repeat и until может находиться произвольное число операторов без операторных скобок begin и end;
так как условие завершения цикла проверяется после выполнения операторов, цикл выполняется, по крайней мере, один раз.
В следующем примере показано, как оператор repeat применяется для суммирования вводимых с клавиатуры чисел. Суммирование прекращается, когда пользователь вводит число 0:
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
S, X: Integer;
begin
S:= 0;
repeat
Readln(X);
S:= S + X;
until X = 0;
Writeln('S=', S);
Writeln('Press Enter to exit...');
Readln;
end.
Часто бывает, что условие выполнения цикла нужно проверять перед каждым повторением тела цикла. В этом случае применяется оператор while, который, в отличие от оператора repeat, содержит условие выполнения цикла, а не условие завершения.
17. Понятие о процедурах и функциях. Общее и различия между процедурами и функциями.
Процедуры программиста
Очевидно, что встроенных процедур и функций для решения большинства прикладных задач недостаточно, поэтому приходиться придумывать собственные процедуры и функции. По своей структуре они очень напоминают программу и состоят из заголовка и блока. Заголовок процедуры состоит из зарезервированного слова procedure, имени процедуры и необязательного заключенного в круглые скобки списка формальных параметров. Имя процедуры - это идентификатор, уникальный в пределах программы. Формальные параметры - это данные, которые вы передаете в процедуру для обработки, и данные, которые процедура возвращает (подробно параметры описаны ниже). Если процедура не получает данных извне и ничего не возвращает, формальные параметры (в том числе круглые скобки) не записываются. Тело процедуры представляет собой локальный блок, по структуре аналогичный программе:
procedure <имя процедуры> (<список формальных параметров>);
const...;
type...;
var...;
begin
<операторы>
end;
Описания констант, типов данных и переменных действительны только в пределах данной процедуры. В теле процедуры можно использовать любые глобальные константы и переменные, а также вызывать любые подпрограммы (процедуры и функции).
Вызов процедуры для выполнения осуществляется по ее имени, за которым в круглых скобках следует список фактических параметров, т.е. передаваемых в процедуру данных:
<имя процедуры> (<список фактических параметров>);
Если процедура не принимает данных, то список фактических параметров (в том числе круглые скобки) не указываются.
Понятие процедуры является чрезвычайно важным, так как именно оно лежит в основе одной из самых популярных технологий решения задач на языке Delphi. Технология эта внешне проста: задача разбивается на несколько логически обособленных подзадач и решение каждой из них оформляется в виде отдельной процедуры. Любая процедура может содержать в себе другие процедуры, их количество ограничено только объемом памяти вашего компьютера.
Приведем пример небольшой программы, использующей процедуру Power для вычисления числа X в степени Y. Результат вычисления процедура Power заносит в глобальную переменную Z.
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
Z: Double;
procedure Power(X, Y: Double); // X и Y - формальные параметры
begin
Z:= Exp(Y * Ln(X));
end;
begin
Power(2, 3); // 2 и 3 - фактические параметры
Writeln('2 в степени 3 = ', Z);
Writeln('Press Enter to exit...');
Readln;
end.
Функции программиста
Функции программиста применяются в тех случаях, когда надо создать подпрограмму, участвующую в выражении как операнд. Как и процедура, функция состоит из заголовка и блока. Заголовок функции состоит из зарезервированного слова function, имени функции, необязательного заключенного в круглые скобки списка формальных параметров и типа возвращаемого функцией значения. Функции возвращают значения любых типов данных кроме Text и file of (см. файлы). Тело функции представляет собой локальный блок, по структуре аналогичный программе.
function <имя функции> (<список формальных параметров>): <тип результата>;
const...;
type...;
var...;
begin
<операторы>
end;
В теле функции должен находиться по крайней мере один оператор, присваивающий значение имени функции или неявной локальной переменной Result. Если таких присваиваний несколько, то результатом функции будет значение последнего из этих операторов. Преимущество от использования переменной Result состоит в том, что она может участвовать в выражениях как операнд.
В качестве примера заменим явно неуклюжую процедуру Power (см. выше) на функцию с таким же именем:
program Console;
{$APPTYPE CONSOLE}
uses
SysUtils;
function Power(X, Y: Double): Double; // X и Y - формальные параметры
begin
Result:= Exp(Y * Ln(X));
end;
begin
Writeln('2 в степени 3 = ', Power(2, 3)); // 2 и 3 - фактические параметры
Writeln('Press Enter to exit...');
Readln;
end.
18. Процедуры и функции. Способы и особенности передачи данных через имя и окно данных.
Параметры процедур и функций
Параметры служат для передачи исходных данных в подпрограммы и для приема результатов работы этих подпрограмм.
Исходные данные передаются в подпрограмму с помощью входных параметров, а результаты работы подпрограммы возвращаются через выходные параметры. Параметры могут быть входными и выходными одновременно.
Входные параметры объявляются с помощью ключевого слова const; их значения не могут быть изменены внут