Программирование на языке Паскаль

Текстовые файлы представляют собой последовательность строк различной длины, каждая из которых заканчивается меткой EOLn - End Of Line - конец строки (последовательность символов #13#10). В конце файла стоит метка EOF - End Of File.

Запись данных в текстовый файл практически не отличается от вывода данных на экран терминала. Чтение же данных из текстового файла имеет свои особенности.

Объявить текстовый файл можно двумя способами:

1. указанием его имени и типа в разделе описания переменных:

Var f_text : Text; объявлен текстовый файл f_text,

f_text - имя логического файла - файловой переменной

Внимание! При описании файла его размер не указывается.

2. указанием его типа в разделе определения типов TYPE и имени - в разделе описания переменных:

Type TFile_text = Text;

Var f_text : TFile_text;

Перед началом работы с файлом необходимо связать имя логического файла (файловую переменную) с физическим файлом на внешнем носителе:

Assign(имя файловой переменной, `путь к физическому файлу');

Assign(f_text,'D:\User\f_text.txt');

f_text - имя файловой переменной (логического файла),

D:\User\f_text.txt - полный путь к физическому файлу на внешнем носителе: диск D:, директория (папка) User,

файл f_text.txt

Внимание! Желательно совпадение имени физического файла и имени файловой переменной; расширение имени текстового файла всегда .txt.

После установления пути к физическому файлу его можно открыть:

а) открытие нового файла для записи в него данных:

ReWrite(f_text);

При этом на внешнем носителе создается новый физический файл с заданным именем. Если файл с таким же именем уже существовал, то он очищается,

б) открытие существующего файла для чтения из него данных:

ReSet(f_text);

При этом на внешнем носителе отыскивается файл с заданным именем и, если он найден, то указатель текущей записи становится в начало файла ,

в) открытие существующего файла для записи в его конец новых строк:

Append(f_text);

При этом на внешнем носителе отыскивается файл с заданным именем и, если он найден, то указатель текущей записи становится в конец файла.

Запись в открытый для записи файл осуществляется операторами:

Write( файловая переменная, имя записываемой переменной);

WriteLn( файловая переменная, имя записываемой переменной);

Во втором случае после записи в файл значения переменной текстовый курсор переходит в начало новой строки (как на экране терминала).

В текстовый файл можно записывать данные только целого, вещественного, символьного типа или строки.

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

номер учебной группы

фамилию студента

имя студента

его оценку по информатике

средний балл сдачи сессии

Данные вводить с экрана. Все данные записывать в файл с новых строк.

Интерфейс:

Номер группы: ИС-09

Фамилия: Иванов

Имя: Иван

Оценка:4

Ср. балл:4.12

Программа:

Program File_2;

Uses CRT;

Var ocenka : 2..5; оценка

sr_ball : Real; средний балл

name : String[15]; фамилия или имя

nomer : String[10]; номер группы

f_text : Text; текстовый файл

Begin

ClrScr;

Assign(f_text, `d:\User\f_text.txt');

ReWrite(f_text); открываем файл для записи

Write(`Номер группы:');

ReadLn(nomer); вводим номер группы

WriteLn(f_text, nomer); записываем его в файл

Write(`Фамилия:');

ReadLn(name); вводим фамилию

WriteLn(f_text, name); записываем ее в файл с новой строки

Write(`Имя:');

ReadLn(name); вводим имя

WriteLn(f_text, name); записываем его в файл с новой строки

Write(`Оценка:');

ReadLn(ocenka); вводим оценку

WriteLn(f_text, ocenka:3); записываем ее в файл с новой строки в 3 позициях

Write(`Ср. балл:');

ReadLn(sr_ball); вводим средний балл

WriteLn(f_text, sr_ball:6:2); записываем его в файл с новой строки в 6 позициях

Close(f_text); закрываем файл

ReadLn;

End.

Структура созданного файла:

ИС-09

Иванов

Иван

4

4.12

Внимание! Все данные желательно записывать в текстовый файл форматным

способом.

Чтение данных из открытого для чтения файла осуществляется операторами:

Read( файловая переменная, имя переменной);

ReadLn( файловая переменная, имя переменной);

Во втором случае после чтения из файла значения переменной текстовый курсор переходит в начало новой строки (как на экране терминала).

Внимание! Переменная, указанная в операторах чтения, должна совпадать по типу со считываемым из файла значением.

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

Программа:

Program File_3;

Uses CRT;

Var ocenka : 2..5; оценка

sr_ball : Real; средний балл

name : String[15]; фамилия или имя

nomer : String[10]; номер группы

f_text : Text; текстовый файл

Begin

ClrScr;

Assign(f_text, `d:\User\f_text.txt');

ReSet(f_text); открываем файл для чтения

ReadLn(f_text, nomer); читаем из файла номер группы

WriteLn(nomer); выводим его на экран

ReadLn(f_text, name); читаем из файла фамилию

WriteLn(name); выводим ее на экран

ReadLn(f_text, name); читаем из файла имя

WriteLn(name); выводим его на экран

ReadLn(f_text, ocenka); читаем из файла оценку

WriteLn( ocenka:3); выводим ее на экран

ReadLn(f_text, sr_ball); читаем из файла средний балл

WriteLn( sr_ball:6:2); выводим его на экран

Close(f_text); закрываем файл

ReadLn;

End.

На экран будет выведено:

ИС-09

Иванов

Иван

4

4.12

Внимание! Функции и процедуры, используемые при работе с типизированными файлами (FileSize, FilePos, Seek, Truncate), для текстовых файлов не используются.

Сложнее работать с текстовыми файлами, в каждой строке которых записаны разнотипные данные.

Пример: создать текстовый файл baza.txt, в каждой строке которого хранить следующие данные:

номер учебной группы

фамилию студента

имя студента

его оценку по информатике

средний балл сдачи сессии

Другими словами, необходимо создать базу данных на основе текстового файла.

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

Интерфейс:

Номер группы: ИС-09

Фамилия: Иванов

Имя: Иван

Оценка:4

Ср. балл:4.12

Номер группы: ПО-09

Фамилия: Петров

Имя: Петр

Оценка:5

Ср. балл:4.27

Номер группы: ЗИ-09

Фамилия: Сидоров

Имя: Сидор

Оценка:3

Ср. балл:3.42

Номер группы:

Программа:

Program File_4;

Uses CRT;

Var ocenka : 2..5; оценка

sr_ball : Real; средний балл

name : String[15]; фамилия или имя

nomer : String[10]; номер группы

baza : Text; текстовый файл

Begin

ClrScr;

Assign(baza, `d:\User\baza.txt');

ReWrite(baza); открываем файл для записи

Repeat

Write(`Номер группы:');

ReadLn(nomer); вводим номер группы

If (Length(nomer) = 0) если длина строки с номером группы равна нулю (сразу нажата клавиша ENTER),

Then Break; то выходим из цикла ввода

Write(baza, nomer:10); если нет, то записываем его в файл в 10 позициях (по описанию переменной nomer)

Write(`Фамилия:');

ReadLn(name); вводим фамилию

Write(baza, name:15); записываем ее в файл в той же строке в 15 позициях

Write(`Имя:');

ReadLn(name); вводим имя

Write(baza, name:15); записываем его в файл в той же строке в 15 позициях

Write(`Оценка:');

ReadLn(ocenka); вводим оценку

Write(baza, ocenka:3); записываем ее в файл в той же строке в 3 позициях

Write(`Ср. балл:');

ReadLn(sr_ball); вводим средний балл

WriteLn(baza, sr_ball:6:2); записываем его в файл в 6 позициях и переходим на новую строку

Until (False); псевдобесконечный цикл с постусловием

Close(baza); закрываем файл

ReadLn;

End.

Структура созданного файла:

ИС-09 Иванов Иван 4 4.12

ПО-09 Петров Петр 5 4.27

ЗИ-09 Сидоров Сидор 3 3.42

10 позиций 15 позиций 15 позиций 3 поз. 6 поз.

Внимание! Все данные необходимо записывать в текстовый файл форматным

способом, иначе их нельзя будет прочитать из этого файла. Записываемые числовые данные необходимо разделять хотя бы одним пробелом.

В данном случае для записи в файл выделяется

для номера группы - 10 позиций,

для фамилии или имени - 15 позиций,

для оценки - 3 позиции,

для среднего балла - 6 позиций.

При чтении разнотипных данных из текстового файла, записанных в одной строке, необходимо учитывать следующие особенности:

строки читаются в соответствии с их описанием: если строка описана как String[10], то будут прочитаны ровно 10 позиций,

числа читаются до разделителя (пробела, запятой, признака конца строки),

в списке ввода оператора чтения Read (ReadLn) формат переменных не указывается.

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

Программа:

Program File_3;

Uses CRT;

Var ocenka : 2..5; оценка

sr_ball : Real; средний балл

fam, name : String[15]; фамилия или имя

nomer : String[10]; номер группы

baza : Text; текстовый файл

Begin

ClrScr;

Assign(baza, `d:\User\baza.txt');

ReSet(baza); открываем файл для чтения

While NOT(EOF(baza)) Do

Begin

ReadLn(baza, nomer, fam, name, ocenka, sr_ball); читаем из файла очередную строку с данными

WriteLn(nomer:10, fam:15, name:15, ocenka:3, sr_ball:6:2 ); выводим ее на экран

End;

Close(baza); закрываем файл

ReadLn;

End.

На экране появится:

ИС-09 Иванов Иван 4 4.12

ПО-09 Петров Петр 5 4.27

ЗИ-09 Сидоров Сидор 3 3.42

Конечно, правильное чтение данных из текстового файла возможно только тогда, когда мы точно знаем структуру этого файла.

Записи

На начальных этапах развития программирования, при решении математических, экономических или инженерных задач программисты, как правило, обходились десятком переменных, которые обрабатывались разными алгоритмами. С течением времени объемы обрабатываемых данных стали расти. Приходилось обрабатывать не один-два десятка чисел, а целые таблицы. К тому же таблицы стали содержать не только числовую, но и текстовую информацию. И тут на помощь пришли новые типы данных - массивы, строки, множества. С их помощью можно объединить несколько объектов под одним именем, а затем обращаться к ним поэлементно. Основное требование при создании таких структур - однотипность объединяемых объектов. Однако сложность многих реальных ситуаций требует для своего отражения более гибких средств программирования.

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

Так возникла необходимость в особой структуре данных, которая позволила бы одновременно хранить и обрабатывать данные различных типов.

Для работы с данными различных типов, но объединенных в одну структуру под одним именем, в Паскале введен новый тип данных - запись.

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

В отличие от ранее рассмотренных типов данных, тип записи описывается в разделе определения типов:

Type TStudent = Record

nomer, fam, name : String[15];

ocenka : 2..5;

sr_ball : Real;

End;

Внимание! Описание записи заканчивается словом End, для которого нет слова Begin.

Описан тип записи с именем TStudent, имеющий поля:

nomer, fam, name - номер группы, фамилия и имя - строки длиной 15 символов,

ocenka - оценка по информатике - интервал от 2 до 5,

sr_ball - средний балл сдачи сессии - вещественное.

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

После определения типа записи можно описать разные базовые структуры этого нового типа в разделе описания переменных:

Var stud_1 : TStudent;

gruppa : Array [1..15] Of TStudent;

baza_gruppa : File Of TStudent;

Описанная переменная stud_1 имеет те же поля, что и запись типа TStudent. Чтобы обратиться к любому поля, необходимо написать имя переменной и через точку - имя поля. Поле записи определенного типа может являться операндом в любых выражениях того же типа, то есть к нему могут применяться операции, допустимые для переменных данного типа:

stud_1.nomer := `ИС-09';

stud_1.fam := `Иванов';

stud_1.name := `Ваня';

stud_1.ocenka := 4;

stud_1.sr_ball := 4.12;

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

.nomer := `ИС-09'; это неправильно!

.fam := `Иванов'; это неправильно!

Для упрощения работы с записями в Паскале введен специальный оператор, позволяющий сократить написание имен записей - оператор присоединения:

With x Do

оператор;

где With - служебное слово c,

x - имя переменной-записи,

Внутри этого оператора поля переменной-записи обозначаются без имени самой записи:

With stud_1 Do

Begin

nomer := `ИС-09';

fam := `Иванов';

name := `Ваня';

ocenka := 4;

sr_ball := 4.12;

End;

Внимание! Запись может быть введена с клавиатуры и выведена на экран только по полям, а не целиком, то есть в операторах ввода и вывода ReadLn и WriteLn нельзя указывать имя записи без имени поля:

ReadLn(stud_1); это неправильно!

WriteLn(stud_1); это неправильно!

ReadLn(stud_1.ocenka); это правильно!

WriteLn(stud_1.ocenka); это правильно!

Записи могут являться элементами массивов, то есть разрешены массивы записей, например, описанный выше массив gruppa. Каждый элемент этого массива - отдельная запись со всеми полями, определенными при ее описании. При обращении к элементу такого массива указывается имя массива, индекс элемента и через точку - имя поля:

gruppa[5].nomer := `ИС-09';

gruppa[5].fam := `Иванов';

gruppa[5].name := `Ваня';

gruppa[5].ocenka := 4;

gruppa[5].sr_ball := 4.12;

В этом случае тоже можно использовать оператор присоединения:

With gruppa[5] Do

Begin

nomer := `ИС-09';

fam := `Иванов';

name := `Ваня';

ocenka := 4;

sr_ball := 4.12;

End;

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

ReadLn(stud_1.nomer);

ReadLn(stud_1.fam);

ReadLn(stud_1.name);

ReadLn(stud_1.ocenka);

ReadLn(stud_1.sr_ball);

а затем записать эту переменную в файл целиком:

Write(baza_gruppa, stud_1);

Очередная запись читается из файла тоже целиком:

Read(baza_gruppa, stud_1);

после этого ее можно, например, вывести на экран по полям:

With stud_1 Do

WriteLn(nomer:10, fam:15, name:15, ocenka:3, sr_ball:6:2);

В данном случае запись выведена в одну строку форматным способом.

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

Пример: создать базу данных (файл записей), в которой можно было бы хранить следующие данные о студентах:

учебная группа,

личные данные:

фамилия,

имя,

отчество,

дату рождения:

год,

месяц,

день,

адрес:

город,

улица,

дом,

корпус,

квартира,

телефон.

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

Интерфейс:

Группа: ИС-09

Фамилия: Иванов

Имя: Иван

Отчество: Иванович

Год рождения: 1993

Месяц рождения: 2

День рождения: 23

Город: Иркутск

Улица: Трилиссера

Дом: 123

Корпус: 2

Квартира: 45

Телефон: 235347

Группа:

На экран будет выведено:

ИС-09 Иванов Иван Иванович

Программа:

Program Baza_student;

Uses WinCrt;

Type TKadr = Record основная запись

gruppa : String[10];

fio : Record запись в записи

fam, name : String[10];

otch : String[15];

End;

adres: Record запись в записи

gorod, ulica : String[20];

korp, dom, kv: String[5];

telefon : String[10];

End;

data : Record запись в записи

den : 1..31;

mes : 1..12;

god : 1900..2000;

End;

End;

Var student : TKadr;

baza : File Of TKadr;

Begin

ClrScr;

Assign(baza, 'D:\User\baza_student.dat');

ReWrite(baza); открываем файл для записи

Repeat начало цикла ввода

With student Do оператор присоединения

Begin

Write('Группа: ');

ReadLn(gruppa);

If (Length(gruppa)=0) если номер группы не введен,

Then Break; то выходим из цикла ввода

Write('Фамилия: ');

ReadLn(fio.fam);

Write('Имя: ');

ReadLn(fio.name);

Write('Отчество: ');

ReadLn(fio.otch);

Write('Год рождения: ');

ReadLn(data.den);

Write('Месяц рождения: ');

ReadLn(data.mes);

Write('День рождения: ');

ReadLn(data.den);

Write('Город: ');

ReadLn(adres.gorod);

Write('Улица: ');

ReadLn(adres.ulica);

Write('Дом: ');

ReadLn(adres.dom);

Write('Корпус: ');

ReadLn(adres.korp);

Write('Квартира: ');

ReadLn(adres.kv);

Write('Телефон: ');

ReadLn(adres.telefon);

End; конец оператора присоединения

Write(baza, student); запись в базу данных

Until (False); конец цикла ввода

ReSet(baza); открываем файл для чтения

While Not(EOF(baza)) Do пока не конец файла

Begin

Read(baza, student); читаем данные из файла

With student Do и выводим на экран форматным способом

WriteLn(gruppa:10, fio.fam:10, fio.name:10, fio.otch:15);

End;

Close(baza); закрываем файл

ReadLn;

End.

На практике часто бывает удобно сделать некоторые поля записи изменяемыми (вариантными).

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

Записи с вариантными полями называются записями с вариантами. Вариантные поля в них описываются после неизменяемых. Наличие вариантного поля указывается конструкцией:

Case селектор: тип Of

ключ-1: (варимант-1);

ключ-2: (вариант-2);

ключ-3: (вариант-3);……………………

ключ-n:(вариант-n);

End;

Тип селектора и перечень его возможных значений задаются в разделе определения типов Type.

Например, положение точки на плоскости можно задавать прямоугольными (x, y) или полярными (r, ц) координатами. Тогда запись с вариантами coord может быть описана так:

Type TDecpol = (decart, polar);

TCoord = Record

Case wid : TDecpol Of

decart : (x, y : Real);

polar : (r : Real; fi : 0..360);

End;

End;

Var coord : TCoord;

Селектором в данном случае является поле перечисляемого типа coord.wid , принимающее только два значения - decart и polar. При значении селектора decart поля переменной coord будут следующими:

coord.x , coord.y типа Real,

а при значении поля polar - следующими:

coord.r типа Real,

coord.fi типа 0..360.

При использовании записей с вариантами необходимо руководствоваться следующими правилами:

все имена полей должны быть различными, даже если они встречаются в разных вариантах,

если вариант пустой (для него поля нет), то он записывается так:

ключ : ();

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

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

Подпрограммы

Современный процесс программирования представляет собой коллективное промышленное изготовление программных продуктов на основе новых технологий программирования.

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

Метод структурного программирования предполагает:

проектирование программ на основе метода пошаговой детализации (нисходящее программирование),

использование модульного программирования,

структурное кодирование программы.

Основой метода пошаговой детализации является идея программирования “сверху вниз” с постепенной разбивкой исходной задачи на ряд более мелких подзадач, при этом выполняется последовательное уточнение: сначала задача определяется в общих чертах, затем происходит постепенное уточнение ее структуры. На очередном шаге каждая подзадача, в свою очередь, разбивается на ряд других. Решение отдельного фрагмента сложной задачи может представлять собой самостоятельный программный блок - подпрограмму. Поэтому программу решения сложной задачи при нисходящем программировании можно представить как иерархическую совокупность относительно самостоятельных модулей-подпрограмм. В этом и заключается идея модульного программирования.

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

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

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

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

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

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

В Паскале различают два типа подпрограмм:

подпрограммы-функции,

подпрограммы-процедуры.

Подпрограммы-функции

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

Функции располагаются в основной программе между разделом описания переменных Var и Begin основной программы. Функции используются для вычисления единственного значения, присваиваемого имени самой функции. Это значение вычисляется внутри самой функции по нужному алгоритму с помощью переменных (аргументов), называемых формальными параметрами.

Как и все программы в Паскале, функция состоит из заголовка, блока описаний и блока операторов:

Function Geron(x, y, z : Real):Real; заголовок функции

Var p : Real; описание локальных переменных

Begin начало блока операторов

p := (x + y + z)/2.0;

Geron := Sqrt(p*(p - x)*(p - y)*(p - z));

вычисленное значение присваивается имени функции

End;

Внимание! После оператора End ставится точка с запятой.

Эта функция вычисляет площадь треугольника по формуле Герона - по трем его сторонам.

Заголовок функции

Function Geron(x, y, z : Real):Real;

начинается со слова Function , за которым следует ее имя, в данном случае Geron. После имени функции в скобках перечисляются имена и типы аргументов функции - входных данных или формальных параметров. В данном случае это x, y, z типа Real. Если имеются формальные параметры нескольких типов, то они группируются по типам, а между типами ставятся точки с запятой. Заголовок заканчивается указанием типа самой функции, то есть типа результата, вычисляемого этой функцией. В данном случае это Real.

Аргументы функции называются формальными параметрами лишь потому, что они определяют только способ вычисления значения функции, реализацию алгоритма. При обращении к функции в основной программе формальные параметры автоматически заменяются фактическими параметрами или их конкретными значениями, для которых необходимо произвести вычисления:

s := Geron(3.0, 4.0, 5.0);

В данном случае формальные параметры x, y, z функции Geron заменяются соответственно фактическими аргументами 3.0, 4.0, 5.0 , для которых и вычисляется значение функции. Вычисленное значение присваивается имени самой функции Geron и далее - переменной s. В этом примере s = 6.0.

Вся программа, использующая функцию Geron, может иметь следующий вид:

Program Primer;

Uses CRT;

Var a, b, c, s : Real; описание фактических (глобальных) параметров

Function Geron(x, y, z : Real):Real; заголовок функции

Var p : Real;

Begin

p := (x + y + z)/2.0;

Geron := Sqrt(p*(p - x)*(p - y)*(p - z));

End; конец функции

Begin начало основной (головной) программы

ClrScr;

a := 3.0; инициализация фактических параметров

b := 4.0;

c := 5.0;

s := Geron(a, b, c); обращение к функции с фактическими параметрами a, b, c

WriteLn(`Площадь треугольника равна ', s:6:2);

ReadLn;

End.

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

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

Структура функции, как и структура всех программ Паскаля, включает следующие разделы:

описание меток Label,

определение констант Const

определения типов Type

описание переменных Var

описание процедур и функций Function, Procedure

операторы функции Begin … End;

Построение и использование функций подчиняется следующим правилам:

1. имя функции не должно совпадать со служебными словами, именами стандартных функций, именем основной (головной) программы или именами переменных в ней,

2. в программе не должно быть двух функций с одинаковыми именами,

3. формальные и фактические параметры должны совпадать по порядку следования, количеству и типам,

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

5. формальные параметры не должны совпадать по имени:

Function Err(x, y: Word; a, b, y: Real): Real; ошибка!

6. в конце функции обязательно должен присутствовать оператор присваивания, в левой части которого стоит имя этой функции без списка формальных параметров; в противном случае функция ничего не вычислит:

Function Summa(x, y: Real): Real;

Var s : Real;

Begin

s := x + y; эта функция ничего не вычисляет!

End;

7. помимо формальных параметров, в функции могут использоваться локальные переменные. Они описываются внутри функции в разделе Var , существуют только в ней и служат для реализации алгоритма вычислений. При выходе из функции их значения исчезают:

Function Fact(n: Word): Word; n - формальный параметр

Var i, f : Word; i, f - локальные переменные

Begin эта функция вычисляет факториал

f:=1; заданного числа

For i:=1 To n Do

f := f * i;

Fact := f;

End;

8. если в функции используется цикл с параметром (цикл For), то параметр цикла должен быть описан внутри этой функции, то есть он должен быть обязательно локальной переменной (предыдущий пример),

9. связь вызывающей (головной) программы с функцией может осуществляться как через формальные и фактические, так и через глобальные параметры. Глобальные параметры (переменные) не описываются ни в заголовке функции, ни внутри ее. Они описываются в вызывающей программе и существуют как в ней, так и в любой функции, вызываемой из этой программы. Глобальные переменные могут изменять свои значения как в вызывающей программе, так и внутри функции:

Program Global;

Uses CRT;

Var a, b, c, s : Integer; с - глобальная переменная

Function Sum(x, y : Integer) : Integer;

Begin

c := c + 1; изменение значения глобальной

Sum := x + y + c; переменной в функции

End;

Begin

a := 1;

b := 1;

c := 1; инициализация глобальной переменной

s := c + Sum(a, b);

WriteLn(`s=', s);

ReadLn;

End.

После выполнения этой программы s = 5.

Следует избегать использования глобальных переменных в функциях, так как это может привести к непредсказуемым результатам вычислений. В предыдущем примере значение переменной s определялось оператором присваивания:s := c + Sum(a, b);

и принимало значение s = 5. Поменяем местами слагаемые в этом операторе присваивания:s := Sum(a, b) + c;

Казалось бы, результат измениться не должен, но после вычислений получим

s = 6 - значение глобальной переменной c изменилось внутри функции и стало равным с = 2, и с таким значением оно было добавлено в общую сумму в вызывающей программе.

Локальные и глобальные переменные размещаются в оперативной памяти в различных сегментах (частях). При трансляции программы формируются:

сегмент кода, в котором хранится программа в виде машинных команд,

сегмент данных, в котором выделяется память под глобальные переменные,

сегмент стека, предназначенный для размещения локальных переменных:

Размер каждого сегмента не может превышать 64Кбайт. Адреса сегментов хранятся во время выполнения программы в сегментных регистрах:

CS - адрес сегмента кода,

DS - адрес сегмента данных,

SS - адрес сегмента стека.

В связи с размещением в различных сегментах памяти, глобальные и локальные переменные действуют по-разному:

время жизни глобальных переменных - от начала работы программы до ее завершения,

если глобальные переменные не были инициализированы явным образом, то есть им не были присвоены начальные значения, то перед началом работы программы они обнуляются,

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

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

неинициализированные локальные переменные предварительно не обнуляются, а принимают произвольные значения, зависящие от информации, оставшейся в занимаемых ими ячейках памяти,

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

Function Func(k: Word) : Word;

Const n: Word = 0; n - типизированная константа

Var i: Word;

Begin

WriteLn(`i=',i); неопределенное значение переменной i

WriteLn(`n=',n);

n:= n + k;

Func:=n;

End;

Переменной i будет присвоено заранее неизвестное значение. При первом обращении к функции переменная n, определенная в CONST, будет равна нулю, и при каждом последующем обращении она будет увеличиваться на k.

время жизни такой переменной - время работы всей программы: значения этой переменной сохраняются между вызовами подпрограммы,

область действия такой переменной - подпрограмма, в которой она описана, то есть вне подпрограммы к этой переменной обратиться нельзя,

10. локальные и глобальные переменные могут совпадать по имени; в этом случае в функции работают локальные переменные,

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

в качестве формальных параметров функций нельзя использовать конкретные значения (числа, символы), элементы массивов, поля записей, выражения и стандартные функции,

12. в качестве фактических параметров функций можно использовать константы, переменные, имена и элементы массивов, множеств, файлов, имена и поля записей, комбинированных структур, а также выражения, стандартные функции и имена ранее описанных функций,

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

Program Primer;

Uses CRT;

Var a, b, c : Integer;

Function Sum(x, y : Integer) : Integer; x, y - параметры-значения

Begin

x := x + 1; изменение значений формальных

y := y + 1; параметров в функции

Sum := x + y;

End;

Begin

a := 1;

b := 1;

c := Sum(a, b);

WriteLn(`a=', a, ` b=', b);

ReadLn;

End.

Входные значения фактических параметров x = 1, y = 1. После выполнения программы они останутся теми же, хотя внутри функции соответствующие им формальные параметры изменились,

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

Program Primer;

Uses CRT;

Var a, b, c : Integer;

Function Sum(Var x, y : Integer) : Integer; x, y - параметры-переменные

Begin

x := x + 1; изменение значений формальных

y := y + 1; параметров в функции

Sum := x + y;

End;

Begin

a := 1;

b := 1;

c := Sum(a, b);

WriteLn(`a=', a, ` b=', b);

ReadLn;

End.

Входные значения фактических параметров x = 1, y = 1. После выполнения программы они изменятся и примут значения x = 2, y = 2.

При использовании параметров-переменных в функцию передаются не копии фактических параметров, как это имело место с параметрами-значениями, а адреса фактических параметров, что позволяет сохранять их измененные функцией значения.

Зачастую использование параметров-переменных может тоже привести к непредсказуемым результатам вычислений:

Program Primer;

Uses CRT;

Var a, b : Integer;

Function Nemo(Var x : Integer; y : Integer) : Integer;

x - параметр-переменная,

y - параметр-значение

Begin

x := x + y;

a := y;

Nemo := x;

End;

Begin

a := 1;

b := 2;

WriteLn(`Nemo=', Nemo(a, b),` a=', a, ` b=', b);

ReadLn;

End.

Результат работы программы:

Nemo=2 a=2 b=2

Значение переменной a будет испорчено, так как значения переменных a и x будут записываться в одной ячейке памяти, а функция Nemo вместо 3 примет значение, равное 2. Ошибки такого рада трудно найти, поэтому в функциях и не рекомендуется использовать параметры-переменные,

15. в заголовке функции нельзя использовать формальные параметры безымянных типов (стандартные типы считаются поименованными):

Function Func(x : 1..10; r : array [1..20] Of Real) : Real;

Типы формальных параметров x и r являются безымянными, так как не относятся к стандартным. Поэтому в вызывающей эту функцию программе необходимо определить новые типы данных:

Type TCount = 20;

TVector = Array [1 .. TCount] Of Real;

TInterval = 1 .. 10;

а в заголовке функции использовать эти новые типы:

Function Func(x : TInterval; r : TVector) : Real;

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

Требования к таким функциям:

их тип должен быть определен в разделе описания типов Type,

они не должны быть стандартными,

они не должны быть вложенными,

они должны иметь только параметры-значения,

они должны быть откомпилированы с использованием директивы компилятору {$F+} - использование дальнего типа вызова подпрограмм.

Пример: создать функцию для определения суммы, произведения двух чисел и произведения их суммы на их разность. Функции для выполнения этих операций описать как параметры-функции:

Program Param_func;

Uses CRT;

Type TFunс = Function (x, y: Integer): Integer; описан процедурный тип TFunc - целой функции двух аргументов целого типа

Var a, b, c: Integer;

{$F+} директива компилятору- использование дальнего типа вызова подпрограмм

Function Add(x, y: Integer): Integer; функция для сложения двух переменных

Begin

Add := x + y;

End;

Function Mult(x, y: Integer): Integer; функция для перемножения двух переменных

Begin

Mult := x * y;

End;

Function Funny(x, y: Integer): Integer;

Begin

Funny := (x + y) * (x - y);

End;

{$F-} отмена директивы

функция, использующая параметр-функцию operation

Function Par_func(m, n : Integer; operation : TFunc): Integer;

Begin

Par_func := operation(m, n);

End;

Begin

ClrScr;

a := 5;

b := 3;

c := Par_func(a, b, Add); фактические параметры для параметров-функций не указываются!

WriteLn('c=', c);

c := Par_func(a, b, Mult);

WriteLn('c=', c);

c := Par_func(a, b, Funny);

WriteLn('c=', c);

ReadLn;

End.

На экран будет выведено:

с=8

с=15

с=16

17. в Паскале разрешено использовать рекурсию - обращение функции самой к себе, при этом имя функции со списком формальных параметров будет стоять в операторах функции справа от знака присваивания.

Рекурсия

Использование рекурсии в программировании базируется на рекурсивных математических определениях. Считается, что в математике рекурсивность как принцип определений используется с 1890 года. Впервые применил ее Д.Гильберт.

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

Например, вычисление факториала целого неотрицательного числа n! = 1·2·3·…·(n-1) · n . Кроме того, по определению, 0! = 1. Рекурсивное математическое определение факториала имеет вид:

Последовательность чисел Фибоначчи имеет вид 1, 1, 2, 3, 5, 8, 13…

В ней два первых числа фиксированы и равны единице, а каждое последующее число равно сумме двух предыдущих. Рекурсивное математическое определение числа Фибоначчи с порядковым номером n имеет вид:

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

На базе рекурсивных определений можно построить компактные и выразительные подпрограммы. Вполне очевидно, что за любым из приведенных рекурсивных определений прячется некий циклический процесс вычислений. Такой циклический процесс допускает реализацию на базе некоей рекуррентной формулы, производной от соответствующего рекурсивного определения. Рекуррентные формулы являются составными и определяют числовые последовательности, в которых каждый очередной член зависит от одного или нескольких предыдущих. При этом для рекуррентной формулы характерно, что она представляет собой зависимость очередного члена последовательности от строго определенных предыдущих ее членов. Составной частью рекуррентной формулы является прямое определение одного или нескольких начальных членов последовательности. Чаще всего определяемая последовательность бесконечна, поэтому требуется указать требуемое количество ее членов. Трансформируем вышеприведенные рекурсивные математические определения в рекуррентные формулы.

Рассмотрим последовательность факториалов целых чисел 0!, 1!, 2!, 3!,…, в которой ai = i!, i = 1, 2, 3,… Эту же последовательность можно представить в виде рекуррентной формулы: ai = ai-1·i, a0 = 1, i = 1, 2, 3… Эта формула задает последовательность, в которой каждый очередной член зависит непосредственно от предшествующего. Начальный член последовательности a0 задан прямою. Найдя член последовательности с порядковым номером i = n, мы тем самым решим задачу вычисления n!

Рекуррентная формула для вычисления числа Фибоначчи с заданным порядковым номером i = n практически не отличается от рекурсивного определения: Fi = Fi-2 + Fi-1 , F1 = 1 , F2 = 1 , i = 3, 4, 5,…

Итак, функция считается рекурсивной, если при решении задачи она обращается к самой себе или непосредственно, или через другие подпрограммы. Известно, как технически реализуется обращение к подпрограмме в общем случае:

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

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

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

При рекурсивном обращении каждый раз приходится запоминать не только адрес возврата, но и всю совокупность данных вызывающей подпрограммы (локальные переменные и параметры-значения). С этой целью используется автоматически выделяемая область памяти - стек, структура, работающая по принципу LIFO (Last in - first out: последним пришел - первым вышел). Такой метод работы с памятью обеспечивает строгое соответствие прямого порядка записи данных обратному порядку их чтения. Только с помощью стека можно достаточно просто обеспечить корректное завершение работы цепочки подпрограмм, каждая из которых вызывает следующую: сначала должна быть завершена последняя, затем - предпоследняя и так далее. Максимальный размер стека - 65520 байт. Поэтому последовательность рекурсивных обращений не может быть бесконечной. В любой рекурсивной подпрограмме должна быть нерекурсивная (терминальная) ветвь, обеспечивающая выход из рекурсии. При переполнении стека работа программы прерывается, и появляется сообщение об ошибке Error 202: Stack overflow error.

Рекурсивная функция, вычисляющая факториал заданного числа n, может иметь вид:

Function Factorial(n: Word): Word;

Begin

If (n=0)

Then Factorial := 1 выход из рекурсии

Else Factorial := n * Factorial(n - 1); рекурсия

End;

При n = 5 эта функция будет работать следующим образом:

Factorial := 5 * Factorial(4)

5 * 4 * Factorial(3)

5 * 4 * 3 * Factorial(2)

5 * 4 * 3 * 2 * Factorial(1)

5 * 4 * 3 * 2 * 1 = 120

В данном случае реализована так называемая нисходящая рекурсия: вызов Factorial(5) означает, что функция Factorial вызывает себя раз за разом: Factorial(4), Factorial(3), … до тех пор, пока не будет достигнута терминальная ситуация - ситуация окончания рекурсии. При каждом вызове текущие вычисления откладываются, локальные переменные и адрес возврата остаются в стеке. Терминальная ситуация Factorial := 1 достигается при n = 0. При этом рекурсивный спуск заканчивается, начинается рекурсивный возврат изо всех вызванных в данный момент копий функции: начинает строиться ответ n*Factorial(n-1). Сохраненные локальные параметры выбираются из стека в обратной последовательности, а получаемые промежуточные результаты: 1*1, 2*1, 3*2*1, 4*3*2*1, 5*4*3*2*1 - передаются вызывающим функциям.

Рекурсивная функция, вычисляющая n-й член ряда Фибоначчи, может иметь вид:

Function Fibo(n: Word): Word;

Begin

If (n=1) Or (n=2)

Then Fibo := 1 выход из рекурсии

Else Fibo := Fibo(n-2) + Fibo(n-1); рекурсия

End;

Мы рассмотрели непосредственную рекурсию - функция вызывает саму себя. Помимо непосредственной, возможна косвенная рекурсия - функция Func_1 вызывает функцию Func_2, а функция Func_2, в свою очередь - функцию Func_1. Но как описать две функции, вызывающие одна другую? Ведь по правилам Паскаля подпрограмма обязательно должна быть объявлена до своего использования. В этом случае используется опережающее описание с помощью директивы Forward. При объявлении подпрограммы указывается только ее заголовок со списком формальных параметров и директивой Forward, а тело создается далее без повторного описания этих параметров:

Program Primer;

Uses CRT;

Var i: Integer; описание переменных головной программы

Function Func_1(x: Integer): Integer; Forward; опережающее объявление функции Func_1

Function Func_2(y: Integer): Integer; описание функции

Var k: Integer; Func_2

Begin………

k := Func_1(y); обращение к функции Func_1………

End;

Function Func_1; описание функции

Var n: Integer; Func_1 без списка формальных

Begin параметров……….

n := Func_2(x); обращение к функции Func_2……….

End;

Begin основная программа……..

i := Func_1(i); обращение к функции Func_1

…….. в основной программе

End.

Примеры:

1. Составить функцию, рекурсивно определяющую значение биномиального коэффициента при 0<m<n по формулам:

= = 1, = +

Function Binom(m, n: Word): Word;

Begin

If (m=0) Or (m=n)

Then Binom := 1 выход из рекурсии

Else Binom := Binom(m, n-1) + Binom(m-1, n-1) рекурсия

End;

2. Составить функцию, рекурсивно определяющую максимальный элемент в заданной части целочисленного массива An , начиная с k-го и до n-го элемента:

Const n = 100;

Type TArray = Array [1..n] Of Integer;………………………

Function Max_element(a: TArray; k,n: Word): Integer;

Var temp : Integer;

Begin

If (k=n)

Then Max_element := a[n]

Else

Begin

temp := Max_element(a, k+1, n);

If (a[k] > temp)

Then Max_element := a[k]

Else Max_element := temp

End;

End;

Особенности рекурсии:

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

недостатки рекурсии состоят в следующем:

1. если глубина рекурсии велика, то программа будет требовать во время исполнения много памяти, что может привести к переполнению стека,

рекурсивные алгоритмы, как правило, выполняются более медленно,

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

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

В целях повышения безопасности работы рекомендуется:

для включения проверки переполнения стека необходимо использовать директиву компилятора {S+},

для включения проверки диапазона необходимо использовать директиву компилятора {R+},

в начале каждой рекурсивной процедуры или функции поместить строку

If KeyPressed Then Halt. Она позволяет при зависании программы выйти из нее без перезагрузки компьютера, просто нажав любую клавишу.

Процедуры

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

В этих случаях используют процедуру, которая позволяет одновременно вычислять несколько значений, присваиваемых различным переменным или элементам структур данных.

Как и функция, процедура располагается в вызывающей программе после раздела описания переменных Var и состоит из заголовка, блока описаний и блока операторов.

Заголовок записывается как первая строка процедуры и начинается словом Procedure, за которым следует ее имя. После имени процедуры в скобках перечисляются имена и типы формальных параметров (аргументов процедуры). Заголовок заканчивается точкой с запятой:

Procedure Proc(n,m: Integer; a: Real; Var k: Integer; Var s, d: Real);

Описан заголовок процедуры Proc, зависящей от двух аргументов (входных параметров) целого типа n, m и аргумента a вещественного типа. Выходные (вычисляемые) параметры: переменная k целого типа и переменные s и d вещественного типа.

Допускаются процедуры без списка формальных параметров:

Procedure Zagolovok;

Begin

WriteLn(`Группа ИС-09');

WriteLn(`Студент Иванов Иван');

End;

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

В остальном структура процедуры не отличается от структуры программы на Паскале и может включать в себя следующие разделы:

описания меток Label

определения констант Const

определения типов Type

описания переменных Var

описания процедур и функций Function, Procedure

операторов процедуры Begin … End;

Переменные, описанные в разделе Var процедуры или указанные в ее заголовке, считаются локальными, все остальные - глобальными. Локальные переменные существуют только в процедуре, в которой они описаны, и после выхода из процедуры исчезают.

Пример: описать процедуру, обменивающую значениями две переменных целого типа:

Procedure Swap(x, y: Integer); x и y - входные параметры-значения

Var temp: Integer; temp - локальная переменная

Begin

temp := x; реализация алгоритма

x := y; циклического обмена

y := temp;

End;

Эта процедура ничего не делает: в списке формальных параметров указаны параметры-значения. Правильное описание с использованием параметров-переменных:

Procedure Swap(Var x, y: Integer); x и y - входные параметры-

Var temp: Integer; переменные

Begin

temp := x;

x := y;

y := temp;

End;

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

...