Если у вас возникли сложности с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой - мы готовы помочь.
Предоплата всего
Подписываем
Лабораторная работа №4
Разработка программ с использованием циклов c неизвестным числом повторений
4.1. Цель работы
Освоение процесса разработки циклических программ с использованием условных циклов (с неизвестным числом повторений) на языке Turbo Pascal.
4.2. Задание на лабораторную работу
Требуется разработать две программы (или одну с двумя циклами) с использованием операторов повтора (циклических операторов) WHILE и REPEAT.
4.3. Требования к программе
Программа должна выводить:
– сообщения о назначении программы, разработчике и варианте задания;
- сообщения – подсказки перед вводом данных;
- результаты вычислений каждого выполнения цикла.
Программа должна проверять допустимые значения аргумента при вычислениях, например, чтобы не было деления на ноль.
4.4. Порядок выполнения работы
1. Получить вариант задания (п. 4.8).
2. Изучить правила использования операторов While и Repeat для разработки циклических программ (п. 4.6 и 4.7).
3. Определить область сходимости.
4. Составить и отладить программу вычисления суммы ряда с заданной точностью с использованием циклического оператора WHILE.
5. Составить и отладить программу вычисления суммы ряда с заданной точностью с использованием циклического оператора REPEAT.
6. Проследить с помощью средств отладки системы Turbo Pascal изменения значений переменных и результатов проверки условий продолжения (окончания) цикла.
7. Устно ответить на контрольные вопросы (п. 4.9).
8. Оформить отчет (см. п. 1.10).
4.5. Оператор цикла REPEAT
Оператор цикла REPEAT организует выполнение цикла, состоящего из любого числа операторов, с неизвестным заранее числом повторений. Тело цикла выполняется хотя бы один раз. Выход из цикла осуществляется при истинности некоторого логического выражения S. Структура этого оператора:
repeat
Instruction1
Instruction2
...
InstructionN
until S,
В этой структуре:
Instructionl, Instructfon2, ..., InstructionN – выполняемые операторы, составляющие тело цикла;
S – логическое выражение, истинность которого проверяется в конце каждой итерации.
Так как слова repeat и until являются своеобразными операторными скобками, точку с запятой перед словом until ставить не обязательно.
Алгоритм работы оператора REPEAT:
1 – выполняется тело цикла;
2 – проверяется условие выхода из цикла: если результат булевского выражения равен False, то выполняется переход к пункту 1, если результат – True, то происходит выход из цикла, т.е. переход на следующий оператор.
Рисунок 4.1- Схема работы цикла Repeat Until
Пример. Программа, вычисляющая сумму двух чисел:
program EXAMPLE6;
var
X, Y, Sum: Real;
Ch: Char;
begin
repeat {начало цикла}
Write('Введите числа X и Y ');
ReadLn(X, Y);
Sum : = X + Y;
Writen ('Сумма чисел X и Y равна ',Sum);
Write ('Завершить программу?Y/N (Д/Н) ');
ReadLn (Ch)
Until (Ch=’y’ ) or (UpCase (Ch) = 'Y' ) or (Ch = 'д' ) or (Ch = 'Д' )
{ Upcase – преобразование строчной буквы в заглавную }
end.
4.6. Оператор цикла WHILE
Оператор цикла WHILE организует выполнение одного оператора неизвестное заранее число раз, если истинно логическое выражение S. Выход из цикла осуществляется, если логическое выражение S окажется ложным. Так как истинность логического выражения проверяется в начале каждой итерации, тело цикла может не выполниться ни разу.
Структура оператора цикла WHILE имеет вид:
while s do Instruction;
В этой структуре:
S – логическое выражение, истинность которого проверяется в начале каждой итерации;
Instruction – выполняемый оператор цикла, который может быть составным.
Алгоритм работы оператора WHILE:
1 – вычисляется значение условия S;
2 – проверяется условие, если результат равен True, тело цикла выполняется и происходит переход к п. 1; если результат равен False, происходят выход из цикла и переход к первому после while оператору.
Рисунок 4.2 Схема работы цикла While do
Пример. Найти все делители целого положительного числа (кроме 1 и самого числа).
program EXAMPLE;
var
Х: Integer;
Half: Integer;
Divider: Integer;
i: Integer;
begin
repeat
Write('Введите число больше нуля: ');
ReadLn(X);
if X<=0 then
WriteLn( 'Неправильный ввод')
until X > 0;
Half := X div 2;
Divider := 2;
i : = 0;
While Divider <= Half do
begin
if X mod Divider = 0
then
begin
inc(i); {увеличение счетчика на единицу}
WriteLn(i, '-й делитель равен:' Divider)
end;
inc(Divider) {увеличение делителя на единицу}
end;
if i=0
then
WriteLn( 'Делителей нет');
WriteLn('Конец решения')
end .
|
|
=0,001 |
4.8. Содержание отчета (см. п. 1.10)
4.9. Контрольные вопросы
1. Каково назначение условных операторов повтора (циклов)?
2. Какие требования предъявляются к выражениям, управляющим повторениями?
3. В чем отличия операторов повтора while и repeat?
4. В каких случаях предпочтительнее использовать для организации циклов оператор повтора for? Что записывается в заголовке этого оператора?
5. Какие правила пунктуации необходимо соблюдать при записи операторов?
6. Что такое вложенные циклы? Какие дополнительные условия необходимо соблюдать при организации вложенных циклов?
Лабораторная работа № 5
Приобретение навыков разработки программ отработки символьных и строковых данных на языке Turbo Pascal.
Составить программу обработки строковых данных заданной структуры (в соответствии с вариантом задания (п. 5.7)) и преобразования исходных данных.
Программа должна выполнять следующие действия:
– ввод данных и вывод сообщений-подсказок перед вводом данных;
– вывод результатов:
– преобразования: выражения типа байт в символ (Chr); изображения символа в код типа байт (Ord); числа (целого или вещественного) в строку (Str) и вывод строки; строки в число целого или вещественного типа (Val) и вывод результатов преобразований.
1. Составить вариант задания (п. 5.7, таблицы 5.4, 5, 5.6)
2. Изучить операторы определения переменных символьного и строкового типа (п. 5.5).
3. Разработать и отладить программу обработки строковых данных, преобразования данных.
4. Устно ответить на контрольные вопросы (п. 5.9).
5. Оформить отчет (см. п. 1.10).
Тип данных CHAR обозначает множество символов ASCII, коды которых представлены в таблице (см. приложение 1). Диапазон значений кодов от 0 до 255. Первые 32 символа таблицы кодов ASCII являются управляющими символами, используемыми при работе с внешними устройствами и передаче данных.
Переменная типа CHAR имеет длину 1 байт. Символьные константы задаются путем заключения отдельного символа в апострофы.
Например,
в разделе констант: const sym1 = ‘A’ ;
или в операторах присваивания: S: = ’B’;
или в выражениях: S > ‘A’.
Переменные символьного типа, например S1 и S2, определяются в разделе переменных по правилу:
var S1, S2: char;
Информация о функциях для переменных типа Сhar дана в таблице 5.2.
Таблица 5.2
|
Назначение функции |
Идентификатор |
Тип аргумента |
Тип функции |
Пример |
|
Преобразование выражения типа байт в символ |
Chr |
Byte |
char |
x:=68; y:=chr(2*x-5); {y='Г'} |
|
Преобразование изображения символа в код типа байт |
Ord |
Char |
Byte |
x:='A'; |
|
Возвращение предыдущего символа |
Pred |
Char |
Char |
x:='Б'; |
|
Возвращение следующего символа |
Succ |
Char |
Char |
x:='Г'; |
|
Преобразование строчной буквы в прописную |
Upcase |
Char |
Char |
Ch:=’d’ Y:=Upcase(Ch) {Y=’D’} |
Строка – это последовательность символов кодовой таблицы персонального компьютера.
Доступ к отдельному символу может быть получен путем ссылки на него при помощи индекса. Байт в позиции 0 (доступный лишь при отмене проверки диапазона) хранит число, представляющее длину текущего значения переменной типа STRING.
Применение строковых переменных в качестве селектора в операторе CASE недопустимо.
Формат определения констант строкового типа:
Const <идентификатор>=<значение>;
Например,... С1 = ‘строка 1’; ...
Формат определения переменных строкового типа:
{Описание переменной типа String с помощью заданного программистом типа}
Type
<имя типа> = string[максимальная длина строки];
Var
<идентификатор,...>:<имя типа>;
{Описание переменной типа String без заданного программистом типа}
<идентификатор,...>:string[максимальная длина строки];
Максимальная длина строки не более 255; значение 255 можно не задавать.
Пример описания строк и считывания строки:
Program StrTest;
const
S1='Начало работы программы’ {Пример константы строкового типа};
var
S2: string[10];
Begin
WriteLn(S1); {Вывод значения строковой константы}
Write(' Введите строку:');
ReadLn(S2);
WriteLn(' Длина введенной строки ',S,' равна ',ord(S2[0]));
End.
Запись S[0] дает доступ к нулевому байту, содержащему значение текущей длины строки.
Значение нулевого байта не должно превышать 255, но нарушение этого правила не вызывает программного прерывания, так как директива компилятора R по умолчанию находится в пассивном состоянии {$R-}. Для обеспечения строгого контроля за диапазоном допустимых значений индекса следует перевести директиву R в активное состояние {$R+}. Активный режим R устанавливается на стадии отладки программ.
Выражения, в которых операндами служат строковые данные, называются строковыми. Они состоят из строковых констант, переменных, указателей функций и знаков операций над ними.
Над строками могут выполняться операции отношения и сцепления (конкатенации):
1. Операции отношения : <,>, =, <>, >=, <=. Результат операции отношения будет иметь тип BOOLEAN. Строки сравниваются посимвольно слева направо. При обнаружении первого несовпадающего символа принимается решение о <больше> или <меньше> в соответствии с таблицей кодов ASCII. Если две сравниваемые строки имеют различную длину, но совпадают вплоть до последнего символа более короткой строки, то более короткая строка считается меньшей.
Например:
'Pascal'='pascal' -> false
'prim'<'primer' -> true
'+'<'-' -> true
2. Сцепление : +. Использование знака + позволяет разместить строки одну за другой.
Например:
'Новый'+' '+'год'='Новый год';
Операция + дает тот же результат, что и функция CONCAT, присутствующая в языке Turbo Pascal для обеспечения его совместимости с другими версиями (описывается ниже).
Информация о строковых процедурах и функциях дана в таблице 5.3.
Таблица 5.3
|
Назначение процедуры или функции |
Заголовок процедуры или функции |
Пример |
|
Удаление N символов строки St начиная с позиции Pos |
Delete (St: string, Pos,N: byte) |
St:= 'абвгде'; Delete(St, 4, 2); {St='абве'} |
|
Вставка строки Str1 в строку Str2 начиная с позиции Pos |
Insert ('*', Str2, 4) |
Str2:='абвгде'; Insert '*', Str2, 4 {Str2='абв*где'} |
|
Преобразование числового значения величины V(integer или real) и помещение результата в строку St |
Str (V: real, St: string) |
V:=1500; Str(V:6, St); {St:=' 1500'} |
|
Преобразование строки St в величину целочисленного или вещественного типа и помещение результата в V |
Val (St: string,V: real, Code: integer) |
St:='1.455'; Val(St,V,Cod); {V=1.455, Cod=0} |
|
Сцепление строк St1, St2,... |
Concat (St1,St2,..,Stn:string): string |
St1:=’За’; St2:=’дача’; Y:=Concat(St1,St2) (Y=Задача) |
|
Выделение из строки St подстроки длиной N символов начиная с позиции Pos |
Copy (St: string, Pos,N: byte): string |
St:='абвгде'; Y:=Copy(St, 2, 3); {Y='бвг'} |
|
Вычисление длины строки St |
Length (St: string): byte |
St:='абвгде'; Y:=Length(St); {Y=6} |
|
Определение позиции первого появления в строке St2 подстроки St1 |
Pos (St1,St2): byte |
St2:='abcdef'; Y:=Pos('de',St2); {Y=4} |
Программа, осуществляющая ввод массива из 10 слов длиной 6-8 символов, в каждом слове заменяет символы 'a' на 'б', а также осуществляет преобразования вещественной и строковой констант.
Program Prim_Str;
Const CH=12.34;
KST= '12.34';
Var X : array [1..10] of string[8]; {Массив слов}
St : srting[7]; {Параметр для процедуры Str()}
V : real; {Параметр для процедуры Val}
Code : byte; {Параметр для процедуры Val}
Dl : integer; {Длина слова в массиве}
n : integer; {Позиция символа 'а'}
i, j : byte; {Переменные цикла}
Begin
{---------------Ввод массива из десяти слов-----------------}
Writeln('Программа обработки данных строкового типа');
Writeln;
Writeln('Введите 10 слов из 6-8 символов');
For i:=1 to 10 do begin
Write(i, ' -е слово ');
Readln(X[i]); end;
{----------------Вывод на экран введенных данных---------------}
Writeln('Введенные слова');
For i:=1 to 10 do Writeln(i, '-ое слово ', X[i]);
dl:=length(X[1]); {определение длины первого слова}
{----------------Вывод кодов символов первого слова--------------}
For i:=1 to dl do
Begin
Write ORD (X [1,i]); Writeln
End;
{---------------Преобразование числа в строку -----------------}
Str(CH,St);
Writeln('Число ',CH:7:3,' преобразуется в строку ', St);
{---------------Преобразование строки в число ------------------}
Val(KST, V, Code);
Writeln('Строка ', KST, ' преобразуется в число ', V);
Writeln(' код ошибки ', Code);
{------ Поиск в словах символа 'a' и замена его на символ 'б' ---}
For i:=1 to 10 do begin
{- Определение наличия символа 'а' в слове X[i] и его позиции }
n:=pos('а', X[i]);
{---Запись символа 'б' на место, занимаемое символом 'а'-----}
if n>0 then X[n]:='б' end;
{-----------Преобразование массива из 10 слов в строку и------}
{-----------------вывод результата ---------------------------}
{------предлагается запрограммировать самостоятельно------}
End.
Таблица 5.4
|
№ варианта |
Исходные данные табл. 5.5 |
Результат табл. 5.5 |
Длина слова |
Количество слов |
Решаемая задача табл. 5.6 |
|
6 |
1 |
2 |
[5-8] |
11 |
6 |
Таблица 5.5
|
№ |
Структура данных |
|
1 |
Массив слов |
|
2 |
Строка слов, разделенных пробелом |
Таблица 5.6
|
№ |
Решаемые задачи |
|
1 |
Поменять местами слова с максимальной и минимальной длиной при условии, что такие слова единственные |
|
2 |
Заменить окончания (последние два символа) на 'ая' в словах, длина которых равна 5 |
|
3 |
Поменять местами слово, начинающееся на 'a', со словом, оканчивающимся на 'я', при условии, что такие слова существуют и являются единственными |
|
4 |
Удалить последние 3 символа из слов, начинающихся на 'a' |
|
5 |
Удалить первые 3 символа из слов, оканчивающихся на 'ие' |
|
6 |
Дополнить символом '*' слова, имеющие длину меньше максимальной по варианту задания, до максимальной |
|
7 |
Заменить первые 3 символа слов, имеющих выбранную длину, на символ '*' |
|
8 |
Удалить все символы 'а' из слов, длина которых равна выбранной |
|
9 |
Заменить все символы 'a' на 'd' в словах, длина которых меньше выбранной |
|
10 |
Заменить первые строчные буквы на заглавные в каждом слове, длина которого больше выбранной |
|
11 |
Вставить пробел после первых 2-х символов в слова, имеющие длину, на 1 меньше максимальной по варианту задания |
|
12 |
Заменить первую строчную букву на заглавную в словах, имеющих выбранную длину |
|
13 |
Вставить пробел перед последними 2-мя символами в слова, имеющие минимальную по варианту задания длину |
1. Что такое строка?
2. Каким идентификатором определяются данные строкового типа?
3. Какова максимальная длина строки? Как определить текущую длину строки?
4. Какие выражения называются строковыми?
5. Какие операции допустимы над строковыми данными?
6. Каким образом производится сравнение строк?
7. Как можно обратиться к отдельным символам строки?
8. Каково назначение специальных процедур и функций обработки данных строкового типа?
Лабораторная работа №6
Приобретение навыков разработки программ с использованием процедур и функций пользователя на языке Turbo Pascal.
Разработать программу для вычисления значений функции в соответствии с вариантом задания и вывести результаты в табличном виде.
Программа должна выводить сообщения-подсказки перед вводом данных, сообщение о выводе результатов и результаты в виде, описанном ниже.
Программа должна состоять из трех подпрограмм (процедура ввода данных, подпрограмма-функция вычисления значения, процедура вывода данных) и основной части программы.
Форма вывода результата.
|
Значение функции в интервале [a,b] с шагом 0.1 |
|
|
Аргумент |
Функция |
|
... |
... |
Выбор значений параметров a, b, c и формата вывода результатов вычислений осуществляется разработчиком программы.
1. Получить вариант задания (п. 6.6). Варианты задания содержат данные о функции, начальном и конечном значении аргумента, шаге табуляции, абсолютной погрешности.
2. Изучить структуру Pascal-программы, содержащей процедуры и функции пользователя (п. 6.5).
3. Составить схему программы.
4. Запустить интегрированную среду программирования. Ввести текст программы, записать файл на диск, откомпилировать его с использованием среды Turbo Paskal. После успешной компиляции задать для просмотра в окне отладчика значения исходных данных. Установить видимыми одновременно окна редактора с текстом программы и окно просмотра. Исполнить программу в пошаговом режиме с входом в процедуры и функции и пронаблюдать за изменениями значений переменных в основной программе, в процедурах и функциях. Обратить внимание на передачу значений при вызове процедур и функции от фактических параметров основной программы формальным параметрам, на возвращение вычисленных подпрограммами значений в точку вызова главной программы, а также на характер изменения значений локальных и глобальных переменных.
5. Устно ответить на контрольные вопросы (п.6.9).
6. Оформить отчет (см. п. 1.10).
Процедуры и функции имеют общее название – подпрограммы. Применение подпрограмм дает возможность уменьшать число повторений одной и той же последовательности операторов, а также конструировать программу как набор отдельных подпрограмм.
В программе описание процедур и функций должно располагаться между разделами переменных и операторов. Каждая процедура или функция определяется только один раз, но может использоваться многократно.
Правило расположения описаний процедур и функций относительно друг друга: описание вызывающей подпрограммы должно быть ниже описания вызываемой подпрограммы, иначе следует использовать директиву forward (см. п. 6.5.1).
Структура Pascal-программы с процедурами и/или функциями:
Program Name_Prog;
{----------Разделы основной (головной) программы---}
uses ...
const ...
type ...
var ...
{---------------Описание процедуры 1----------------}
Procedure Proc1 ( ... );
Const ...;
Type ...;
Var ...;
Begin
.......
End;
{---------------Описание процедуры 2-----------------}
Procedure Proc2 ( ... );
Const ...;
Type ...;
Var ...;
Begin
.......
End;
.........................................
{----------------Описание функции 1-------------------}
Function Func1 ( ... ):Real;
Const ...;
Type ...;
Var ...;
Begin
.......
End;
.........................................
{-----------Начало блока головной программы-----------}
Begin
....... { Блок содержит вызовы процедур и функций }
End;
Структура процедур и функций аналогична структуре полной программы на языке Turbo Pascal. В процедурах и функциях могут быть описаны собственные метки, константы, типы, а также собственные процедуры и функции. Внутренние описания должны следовать в том же порядке, что и разделы основной программы.
Передача данных из главной программы в подпрограмму и возврат результата выполнения функции осуществляется с помощью параметров, указываемых в заголовке подпрограммы.
Описание каждой процедуры начинается с заголовка, в котором задаются имя процедуры и список формальных параметров с указанием их типов. Процедура может быть и без параметров, тогда в ее заголовке указывается только ее имя. С помощью параметров осуществляется передача исходных данных в процедуру, а также передача результатов работы обратно в вызывающую ее программу.
Структура описания процедуры
Procedure <имя> (<список формальных параметров>)<директива>;
Const ...;
Type ...;
Var ...;
{-------------------------Блок процедуры---------------------}
Begin
<операторы>
End;
<имя> - любой допустимый идентификатор, напр., Proc1.
<список формальных параметров> - последовательность идентификаторов (имен) формальных параметров и их типов, напр., Step:real, Mas: Type_mas,..., разделенных запятой.
Список формальных параметров может включать в себя параметры-значения, параметры-переменные (перед ними должно стоять ключевое слово Var), параметры процедуры (перед ними должно стоять ключевое слово Procedure) и параметры-функции (перед ними должно стоять ключевое слово Function), нетипизированные параметры, перед которыми должно стоять служебное слово Var и отсутствует указание типа.
<директива> - одна из директив: Interrupt, External, Assembler, Inline, Forward. При выполнении лабораторной работы может быть использована директива опережающего описания Forward. Опережающее описание заключается в том, что объявляется лишь заголовок процедуры, ее тело заменяется зарезервированным словом Forward, а само тело процедуры записывается в другом месте той же программы.
Вызов и выполнение процедуры осуществляется при помощи оператора процедуры:
<имя процедуры>(<список фактических параметров>);
Между формальными и фактическими параметрами должно быть полное соответствие, т.е. формальных и фактических параметров должно быть одинаковое количество; порядок следования фактических и формальных параметров должен быть один и тот же; тип каждого фактического параметра должен совпадать с типом соответствующего ему формального параметра.
При вызове процедуры значения фактических параметров присваиваются формальным параметрам, а результаты работы присваиваются параметрам-переменным.
Процедуры могут возвращать результат в основную программу не только при помощи параметров, но и непосредственно изменяя глобальные переменные. Переменные, описанные в основной программе, являются глобальными по отношению к внутренним процедурам и функциям.
Переменные, описанные внутри процедур и функций, называются локальными. Они порождаются при каждом входе в процедуру и уничтожаются при выходе из этой процедуры, т.е. локальные переменные существуют только при выполнении процедуры и недоступны в основной программе.
Пример программы, которая выполняет ввод и вывод значений элементов массивов из 10 вещественных чисел после ввода исходных данных, после возведения в квадрат и возведения в 4-ую степень. Для выполнения вышеназванных операций используются процедуры, определенные пользователем.
Program DemoProc;
{Определение типа Mas (массива из 10 вещественных чисел)}
Type
Mas=Array[1..10] of real;
{Объявление фактических параметров}
Var
M1, M2 :Mas;
{Процедура ввода массива из 10 вещественных элементов с формальным параметром X}
Procedure MasInp (Var X:Mas);
Var
I: Byte; {I - локальная переменная для организации цикла}
Begin
For I:=1 to 10 do
Begin
Write('Введите ', i:3 , '-й элемент массива');
Readln(X[i])
End
End;
{Процедура вывода массива из 10 вещественных чисел с формальным параметром X}
Procedure MasOut (X:Mas);
Var
I: Byte;{i - локальная переменная для организации цикла}
Begin
For I:=1 to 10 do
Writeln(i:3 , '-й элемент массива ', X[i]:6:2)
End;
{Процедура возведения в квадрат значений элементов массива с формальными параметрами X и Y}
Procedure MasMult (X:Mas; var Y:Mas);
Var
i:Byte; {i - локальная переменная для организации цикла}
Begin
For i:=1 to 10 do
Y[i]:=X[i]*X[i]
End;
{Начало основной программы}
Begin
Writeln('Введите массив из 10 чисел ');
{Вызов процедуры MasInp для ввода значений элементов массива с передачей ей фактического параметра M1}
MasInp(M1);
Writeln('Введенный массив ');
{Вызов процедуры MasOut для вывода значений введенных элементов массива, с передачей ей фактического параметра M1}
MasOut(M1);
{Вызов процедуры MasMult для возведения значений элементов массива в квадрат с передачей ей фактических параметров: M1 (исходные данные) и M2 (результат)}
MasMult(M1,M2);
Writeln('Квадраты чисел: ');
{Вызов процедуры MasOut для вывода значений элементов массива, возведенных в квадрат с передачей ей фактического параметра M2}
MasOut(M2);
{Вызов процедуры MasMult для возведения значений элементов массива в четвертую степень с передачей ей фактических параметров: M2 (исходные данные) и M1 (результат)}
MasMult(M2,M1);
Writeln('Числа в четвертой степени: ');
{Вызов процедуры MasOut для вывода значений элементов массива, возведенных в четвертую степень с передачей ей фактического параметра M2}
MasOut(M1);
End.
Функция, определенная пользователем, состоит из заголовка и тела функции. Заголовок содержит зарезервированное слово function, идентификатор (имя) функции, необязательный список формальных параметров, заключенный в круглые скобки, и тип возвращаемого функцией значения. Тело функции представляет собой локальный блок, по структуре аналогичный программе:
Function <имя>[(<список формальных параметров>)]:<тип результата>;
Const ...;
Type ...;
Var ...;
Begin
<операторы>
End;
<имя> - любой допустимый идентификатор, напр., Fun1;
<список формальных параметров> - последовательность идентификаторов (имен) формальных параметров и их типов, напр., Step:real, Mas: Type_mas, ..., разделенных запятой;
<тип результата > - тип возвращаемого функцией результата, напр. Integer, Real, и др.
Среди входящих в функцию операторов должен обязательно присутствовать оператор присваивания, в левой части которого стоит имя данной функции. В точку вызова возвращается результат последнего присваивания.
Обращение к функции осуществляется по имени с указанием списка аргументов. Каждый аргумент должен соответствовать формальным параметрам, указанным в заголовке, и иметь тот же тип.
Рассмотрим пример вычисления выражения Z=(A5+AM)/2, в котором возведение в степень выполняется функцией Step.
{Программа вычисления выражения Z=(A**5+A**M)/2}
Рrogram DemoFunc;
Var A,Z: Real;
{Функция вычисления степени. N, X - формальные параметры,
результат, возвращаемый функцией в точку вызова,
имеет вещественный тип}
Function Step(N: integer; X:real): Real;
{Описание локальных переменных функции}
Var
I: Byte; {локальная переменная для организации цикла}
Y: Real; {локальная переменная для хранения произведения
одинаковых сомножителей}
Begin
Y:=1;
{Цикл вычисления N-й степени числа X}
For I:=1 to N do Y:=Y*X;
{Присваивание функции результата вычисления степени}
Step:=Y
End;
{Начало основной программы}
Begin
Write('Введите значение числа А и показатель степени M');
Readln(A,M);
{Вызов функции Step с передачей ей фактических параметров}
Z:=(Step(5,A)+Step(M,A))/2;
Writeln('Для А =', A, ' M=', M, 'значение выражения равно', Z)
End.
Если функция изменяет значения формальных параметров-переменных или значения глобальных по отношению к данной функции переменных, то говорят, что функция имеет побочный эффект. Применение функций с побочным эффектом нарушает структурированность программы, поэтому их использование нежелательно.
В Turbo Pascal допускается любой уровень вложенности процедур и функций. Для сложных программ имеются правила локализации имен, определяющие область действия для любого имени.
Любое имя (константы, типа, переменной, процедуры или функции) определено только в пределах той процедуры или функции, в которой оно описано. Область действия распространяется на все внутренние процедуры или функции.
Одно и то же имя может быть определено в каждой отдельной процедуре, функции или программе. При этом областью действия этого имени является процедура, функция или вся программа, в которой описан объект с данным именем, за исключением внутренних процедур, содержащих описание объекта с тем же именем.
|
№ варианта |
Функция |
Начальное значение |
Шаг |
Конечное значение |
Абсолют. погрешность результата |
|
6 |
6 |
0,5 |
8 |
0,00001 |
1. Что называется подпрограммой?
2. Какова структура программы с подпрограммами?
3. Какова структура процедур?
4. Какова структура подпрограммы-функции?
5. В чем состоит различие и сходство подпрограмм-процедур и подпрограмм-функций в Turbo Paskal?
6. Как обратиться к процедурам и функциям?
7. Что называется параметром и каково его назначение?
8. Назначение формальных и фактических параметров и их взаимосвязь.
9. Опишите последовательность событий при вызове процедур или функций.
10. Для чего используется пошаговый режим с заходом в процедуры и как его осуществить?
11. Каковы отличия параметров-значений от параметров-переменных, особенности их описания и применения?
12. Чем отличаются локальные и глобальные параметры? Какова область их действия?
PAGE 53