Синтаксис опису і виклику процедури
Курсова робота
Виконав Дзотцоев Лев Казгеріевіч
Північно-Кавказький гірничо-металургійний інститут
(СКГТУ)
Кафедра промислової електроніки
Факультет електронної техніки, ПЕ-04-1
Владикавказ 2004 рік
Завдання
Наведіть
синтаксис опису і виклику процедури. Опишіть види, призначення формальних і
фактичних параметрів. Наведіть приклад опису процедури, її виклику і
поясніть його.
Дани
цілі m та n. Скласти програму
обчислення
x = (m! + n!)/(m + n)!, де k = 1x2x3x4x .. xK
В
програмі передбачити:
Введення
m і n
Опис
процедури-функції для обчислення значення факторіалу: f (k) = k! =
1x2x3x .. xK
Відображення
на екрані дисплея значення Х
Коментарі
в основних місцях програми
2.1
Налагодити і провести рахунок за програмою.
2.2
Привести в пояснювальній записці:
Текст
програми з поясненнями
Вихідні
дані та результати рахунки
Синтаксис опису і виклику процедури.
Програма
об'ємом до 10000 операторів вважається малою, до 100000 операторів - середнього.
Зрозуміло, що будувати такі програми безпосередньо з елементарних операції
практично неможливо. Для спрощення розробки програм в Pascal-е можна використовувати підпрограми
- Процедури та функції. Вони являють собою інструмент, за допомогою якого
будь-яка програма може бути розбита на ряд певною мірою незалежних один
від одного частин. Таке розбиття необхідно з двох причин.
По-перше,
це засіб економії пам'яті: кожна підпрограма існує в програмі в
одному примірнику, в той час як звертатися до неї можна багато разів з
різних точок програми. При виклику підпрограми активізується
послідовність утворюючих її операторів, а за допомогою переданих
підпрограмі параметрів потрібним чином модифікується реалізований в ній
алгоритм.
Друга
причина полягає в застосуванні сучасних методів спадного проектування
програм. В результаті застосування цих методів алгоритм представляється у вигляді
послідовності щодо великих підпрограм, що реалізовують більш -
менш самостійні смислові частини алгоритму. Підпрограми у свою чергу
можуть розбиватися на менш великі підпрограми, ті - на підпрограми нижнього
рівня і т.д. Послідовне структурування програми продовжується до тих
пір, поки що реалізуються підпрограмами алгоритми не стануть настільки простими,
щоб їх можна було легко запрограмувати.
Pascal навіть у порівнянні з
промисловими системами програмування має дуже потужними засобами
роботи з підпрограмами.
Процедури
і функції, як вже зазначалося, являють собою відносно самостійні
фрагменти програми, оформлені особливим чином та обладнаний ім'ям. Згадування
цього імені в тексті програми називається викликом процедури (функції). Відмінність
функції від процедури полягає в тому, що результатом виконання операторів,
що утворюють тіло функції, завжди є деяке єдине значення
простого, строкового типу або покажчика, тому звернення до функції можна
використовувати у відповідних виразах поряд зі змінними і константами.
В
структурі Pascal
програм існує спеціальний розділ для опису процедур і функцій. Як
відомо, будь-яке ім'я в програмі має бути обов'язково описано перед тим, як
воно з'явиться серед виконуваних операторів. Чи не робиться винятку і відносно
процедур: кожну необхідно описати в розділі описів.
Описати
підпрограму - це означає вказати її заголовок і тіло. У заголовку оголошуються
ім'я процедури і формальні параметри, якщо вони є. За заголовком слід тіло
підпрограми, що складається із розділу описів і розділу виконуваних
операторів. У розділі описів процедур можуть зустрітися опису процедур
нижчого рівня, у тих - опису інших підпрограм і т.д.
Синтаксис
і виклик (в загальному) процедур:
Procedure <ім'я
процедури>
Uses <імена
модулів>
Label <імена міток>
Const <імена
констант>
Type <імена типів>
Var <імена локальних
змінних>
<розділ
оголошення підпрограм>
Begin
<оператори>
End;
Для
виконання процедури необхідний її виклик. Виклик здійснюється по імені даної
процедури в тілі програми. Назва процедури сприймається як оператор. При його
виконання виконується вся підпрограма.
Опис
підпрограми складається із заголовка і тіла підпрограми.
Заголовок
Заголовок
процедури має вигляд:
PROCEDURE <ім'я> (<сп.ф.п. >);
Тут
<ім'я> - ім'я підпрограми <сп.ф.п.> - список формальних параметрів;
(Відразу
за заголовком підпрограми може слідувати один зі стандартних директив
ASSEMBLER, EXTERNAL, FAR, FORWARD, INLINE, INTERRUPT, NEAR)
Параметри
Параметри
бувають формальні і фактичні. Параметри, що записуються в дужках
після імені процедури, називаються формальними параметрами. Вони вказують на те,
що для виконання цієї процедури необхідні додаткові дані --
фактичні параметри.
Список
формальних параметрів необов'язковий, і може бути відсутнім. (Використання
процедур без параметрів виправдано тільки в тому випадку, якщо в них не
використовується звернення до глобальних змінних. Використання таких процедур
обмежено тією програмою, для якої вони написані і утруднене для інших
програм).
Якщо
ж він є, то в ньому повинні бути перераховані імена формальних параметрів і їх
тип, наприклад:
Procedure YZ (a: real; b: integer:
з: char)
Як
видно з прикладу, параметри у списку відокремлюються один від одного крапкою з
комою. Кілька наступних підряд однотипних параметрів можна об'єднувати в
підсписки, наприклад, замість
Procedure Z (а: integer; b: integer)
можна
написати простіше:
Procedure Z (a, b: integer)
Оператори
тіла підпрограми розглядають список формальних параметрів як своєрідне
розширення розділу описів: всі змінні з цього списку можуть
використовуватися в будь-яких виразах всередині підпрограми. Таким способом
здійснюється настройка алгоритму підпрограми на конкретне завдання.
Перший
формальний параметр замінюється першим фактичним, другу-друга і т. д.
Механізм
заміни формальних параметрів на фактичні дозволяє належним чином налаштувати
алгоритм, реалізований у підпрограмі. Турбо Паскаль стежить за тим, щоб
кількість і тип формальні параметрів строго відповідали кількості і типах
фактичних параметрів у момент звернення до підпрограмі. Нагадаємо: сенс
використовуваних фактичних параметрів залежить від того, в якому порядку вони
перераховані при виклику підпрограми. Користувач повинен сам стежити за
правильним порядком перерахування фактичних параметрів при зверненні до
підпрограмі. Наведемо приклад. розглянемо, що цікавить нас частина програми (не
найбільш вдалою, але це поки не важливо) для обчислення x = (5! + 2!)/(5 +2)!
Program factorial (input, output);
... ...
(далі
нас цікавить опис процедури:)
Procedure FL (L: integer, var z: integer); (оголошення
процедури, її ім'я, список формальних параметрів)
Begin
Z: = 1;
While L> 1 do
Begin
Z: = ZxL; (тіло процедури, яка також
передбачає, що 0! і 1! = 1)
L: = l-1;
end;
end;
... ... ..
begin
... ... ..
(тепер
розглянемо виклик процедури)
FL (5, a);
FL (2, b);
FL (2 +5, c);
..........
end.
В
даному випадку l, z формальні
параметри. До речі, їх не треба описувати в розділі глобальних змінних.
Фактичні
параметри: 5, а, 2, b,
2 5, c. В "основному"
розділі VAR повинні бути описані а, b, c
При
перший виклик процедури фактичний параметр 5 замінить формальний L, фактичний a замінить формальний z, у другому 2 замінить L, b замінить z.
В
третьому відповідно 2 5 замінить L, c замінить z.
Для того, щоб остаточно розібратися в програмі, необхідно пояснити,
якими бувають види формальних і фактичних параметрів, їх призначення.
Види
параметрів.
За
способу передачі даних параметри можна розділити на кілька категорій.
Будь-який
з формальних параметрів підпрограми може бути або параметром-значенням,
або параметром-змінною, або параметром-константою. Якщо параметри
визначаються як параметри-змінні, перед ними необхідно ставити
зарезервоване слово VAR, наприклад:
Procedure tide (var a: real) Тут параметр А --
параметр-змінна. Заголовок процедури може бути влаштована так, що деякі
групи формальних параметрів не містять слова VAR. Наприклад:
Procedure qwerty (a, b, c: real; var
s: real);
Формальні
параметри, які входять до групи, що не містять слова VAR, називаються формальними параметрами-значеннями.
Визначення
формального параметра той чи інший спосіб істотно тільки для викликає
програми: якщо формальний параметр оголошений як параметр-змінна, то при
виклику підпрограми йому повинен відповідати фактичний параметр у вигляді
змінної певного типу; якщо формальний параметр оголошений як параметр-значення,
то при виклику йому може відповідати довільне вираження. Контроль за
неухильним дотриманням цього правила здійснює компілятором Турбо
Паскаля.
Для
того щоб зрозуміти, в яких випадках використовувати параметри значення, а в яких --
параметри-змінні, розглянемо, як здійснюється заміна формальних
параметрів на фактичні в момент звернення до підпрограмі.
Якщо
параметр визначений як параметр-значення, то перед викликом підпрограми це
значення обчислюється, отриманий результат копіюється у тимчасову пам'ять і
передається підпрограмі. Важливо врахувати, що навіть якщо в якості фактичного
параметра вказано найпростіше вираження у вигляді змінної або константи, все
одно підпрограмі буде передана лише копія змінної (константи). Таким
чином, призначення параметра-значення - передача даних з програми в
підпрограму. Якщо ж параметр визначений як параметр-змінна, то при виклику
підпрограми передається сама змінна, а не її копія. Будь-які можливі зміни
в підпрограмі параметра-значення ніяк не сприймаються що викликає
програмою, тому що в цьому випадку змінюється копія фактичного параметра, в той
час як зміна параметра-змінної приводить до зміни самого
фактичного параметра в викликає програмі. Параметр-константа схожий з
параметром-змінною: в підпрограму передається сама константа, але зміна
її неможливо. Призначення такого параметра збігається з призначенням
параметра-значення. Формальні параметри-константи вказуються в заголовку
програми після службового слова const. Його дія поширюється до найближчої точки з
комою.
Пояснимо
викладене.
.....
var
a, b: integer;
......
procedure squar (a: integer; var b:
integer);
begin
a: = sqr (a);
b: = sqr (b);
writeln ( 'в квадраті вони виглядають
так: ', a,', ', b);
end;
........
begin
a: = 4; b: = 6;
writeln ( 'уважно
подивіться на ці числа: ', a,',
', B);
squar (a, b);
writeln ( 'а так а не в
квадраті: ', a,', ', b);
end.
Результати
виглядають так: уважно подивіться на ці числа: 4, 6
в квадраті вони виглядають так: 16, 36
а так а не в квадраті: 4, 36
Цей
приклад може служити ще й ілюстрацією механізму «закривання» глобальної
змінної а однойменної локальної: хоча мінлива оголошена як глобальна
(вона описана в зухвалому програмі перед описом процедури), в тілі
процедури її «закрила» локальна змінна а, оголошена як
параметр-значення.
Отже,
параметри-змінні використовуються як засіб зв'язку алгоритму, реалізованого
в підпрограмі, з «зовнішнім світом»: за допомогою цих параметрів підпрограма може
передавати результати своєї роботи викликає програмі. Зрозуміло, в
розпорядженні програміста завжди є й інший спосіб передачі результатів --
через глобальні змінні. Однак зловживання глобальними зв'язками робить
програму, як правило, заплутаною, важкою в розумінні і складною в налагодженні. У
відповідно до вимог хорошого стилю програмування рекомендується там,
де це можливо, використовувати передачу результатів через фактичні
параметри-змінні.
З
іншого боку, опис всіх формальних параметрів як параметрів-змінних
небажано з двох причин. По-перше, це виключає можливість виклику
підпрограми з фактичними параметрами у вигляді виразів, що робить програму
менш компактною. По-друге, і головних, в підпрограмі можливе випадкове
використання формального параметра, наприклад, для тимчасового зберігання
проміжного результату, тобто завжди існує небезпека ненавмисно
«Зіпсувати» фактичну змінну. Ось чому параметри-змінні слід
оголошувати тільки ті, через які підпрограма насправді передає
результати викликає програмі. Чим менше параметрів оголошено
параметрами-змінними і чим менше в підпрограмі використовується глобальних змінних,
тим менше небезпека отримання непередбачених програмістом побічних
ефектів, пов'язаних з викликом підпрограми, тим простіше програма в розумінні і
налагодженні.
Існує
одна обставина, яку слід враховувати при виборі виду формальних
параметрів. Як вже говорилося, при оголошенні параметра-значення
здійснюється копіювання фактичного параметра в тимчасову пам'ять. Якщо
цим параметром буде масив великої розмірності, то суттєві витрати
часу і пам'яті на копіювання при багаторазових зверненнях до підпрограмі
можуть стати peшающім доказом на користь оголошення такого параметра
параметром-змінною або передачі його в якості глобальної змінної.
Параметри масиви та параметри рядка
Може
скластися враження, що оголошення змінних в списку формальних параметрів
підпрограми нічим не відрізняється від оголошення їх у розділі опису
змінних. Дійсно, в обох випадках багато спільного, але є одне істотне
відмінність: типом будь-якого параметра в списку формальних параметрів може бути
тільки стандартний або раніше оголошений тип. Тому не можна, наприклад,
оголосити наступну процедуру:
Procedure
S (а: array (1 .. 10] of real);
так
як в списку формальних параметрів фактично оголошується тип - діапазон,
вказує кордону індексів масиву.
Якщо
ми хочемо передати якийсь елемент масиву, то проблем, як правило, не
виникає, але якщо в підпрограму передається весь масив, то слід
спочатку описати його тип. Наприклад:
... ...
type
mas = array [1 .. 10] of real;
.......
PROCEDURE S (a: mas);
... ...
Оскільки
рядок є фактично своєрідним масивом, її передача в
підпрограму
здійснюється аналогічним чином:
.......
type
intype = string [15];
outype = string [30];
FUNCTION St (i: intype): outype:
Вимога
описати будь-який тип-масив або тип-рядок перед оголошенням підпрограми на
перший погляд здається несуттєвим. Дійсно, в рамках найпростіших
обчислювальних задач зазвичай заздалегідь відома структура всіх використовуваних в
програмі даних, тому статичний опис масивів не викликає проблем. Однак
розробка програмних засобів універсального призначення пов'язана зі
значними труднощами. По суті, мова йде про те, що в Турбо Паскалі
неможливо використовувати в підпрограма масиви з «плаваючими» кордонами
зміни індексів. Наприклад, якщо розроблена програма, обробна
матрицю з 10 х 10 елементів, то для обробки матриці з 9 х 11 елементів
необхідно перевизначити тип, тобто перекомпіліровать всю програму. Цей
недолік, як і відсутність у мові засобів обробки виняткових ситуацій
(переривань), успадкований з стандартного Паскаля і являє собою об'єкт
постійної і цілком заслуженою його критики. Розробники Турбо Паскаля НЕ
ризикнули кардинально змінити властивості базової мови, але, тим не менше,
включили в нього деякі засоби, що дозволяють до певної міри пом'якшити
зазначені недоліки.
Перш
за все, в середовищі Турбо Паскаля можна встановити режим компіляції, при якому
відключається контроль над збігом довжини фактичного і формального
параметра-рядка. Це дозволяє легко вирішити питання про передачу підпрограмі
рядки довільної довжини. При передачі рядка меншого розміру формальний
параметр буде мати ту ж довжину, що й параметр звернення; передача рядка
більшого розміру приведе до її усікання до максимального розміру формального
параметра. Слід сказати, що контроль включається тільки при передачі рядки,
оголошеної як формальний параметр-змінна. Якщо відповідний параметр
оголошений параметром-значенням, ця опція ігнорується і довжина не
контролюється.
Зна?? ітельно
складніше йде справа з передачею масивів довільної довжини. Вирішити цю
проблему за допомогою не типізованих параметрів
Процедурні типи
Процедурні
типи - це нововведення фірми Borland (у стандартному Паскалі таких типів немає).
Основне призначення цих типів - дати програмісту гнучкі засоби передачі
функцій і процедур в якості фактичних параметрів звернення до інших
процедур і функцій.
Для
оголошення процедурного типу використовується заголовок процедур, в якому
опускається її ім'я, наприклад:
type
Proc = Procedure (a, b, з: real; Var d: real);
Proc2 = Procedure (var a, b);
РгосЗ
= Procedure;
В
програмі можуть бути оголошені змінні процедурних типів, наприклад, так:
var
р1: Proc;
ар: array [1 .. N] of Proc2;
змінним
процедурних типів допускається привласнювати як значення імена
відповідних підпрограм. Після такого присвоювання ім'я змінної стає
синонімом імені підпрограми.
В
відміну від стандартного Паскаля, в Турбо Паскалі дозволяється використовувати в
переданої процедури як параметри-значення, так і параметри-змінні.
нетипізований параметри-змінні
Ще
один і дуже корисне нововведення фірми Borland - можливість використання нетипізований
параметрів. Параметр вважається нетипізований, якщо тип формального
параметра-змінної в заголовку підпрограми не зазначений, при цьому
відповідний йому фактичний параметр може бути змінною будь-якого типу.
Зауважимо, нетипізований можуть бути тільки параметри-змінні.
нетипізований
параметри зазвичай використовуються у випадку, коли тип даних неістотний. Такі
ситуації найчастіше виникають різного роду копіювання одній області пам'яті в
іншу. Нетипізовані параметри дуже зручно використовувати для передачі
підпрограмі одновимірних масивів змінної довжини.
Параметри-складні типи даних
Розглянуто
перш категорії параметрів не вичерпують всіх питань передачі інформації в Pascal-e. Використання в якості параметрів
складних типів даних має свої особливості.
Розглянемо
масиви та рядки відкритого типу. Відкритий масив (рядок) - масив (рядок) без
вказівки типу індексу (розміру масиву (рядки )).
Приклад:
Procedure getfive (var massiv: array
of real);
В
даному випадку замість формального параметра може використовуватися будь-який масив з
елементами типу real.
Індексація елементів відкритого масиву завжди починається з нуля. Такі масиви
введені для того, щоб підпрограма могла обробляти масиви будь-якого розміру.
Програма
обчислення x = (m! + n!)/(m + n)!,
де m, n цілі (невід'ємні)
program factorial_ (input, output); (назва програми)
label 0; (описуємо мітку)
var
rez: real;
m, n: longint; (описали глобальні змінні, використовувані в програмі)
function fact (z: longint): real;
(заголовок функції з формальним параметром-значенням, типом)
var
y: real; (описали локальну змінну)
begin
y: = 1; (для отримання
результату необхідно надати у значення 1. також за допомогою цього
реалізується обчислення 0! і 1!)
while z> 1 do (запускаємо цикл у зворотний бік, для
спрощення опустимо множник 1)
begin
y: = y * z;
z: = z-1
end;
fact: = y (обчислюємо факторіал, присвоюємо його
значення функції)
end; (кінець функції)
begin (початок тіла програми)
writeln ( 'введіть невід'ємні
числа '); (для зручності користувача просимо ввести числа)
0: readln (m, n); (в пам'ять вводяться числа)
if m or n <0 then begin
writeln ( 'ви помилилися, вводите
невід'ємні числа');
goto 0 (при помилку
користувача запобігаємо видачу невірного результату)
end;
rez: = (fact (m) + fact (n))/fact (m + n); (обчислюється
значення даного виразу)
writeln ( 'результат:', rez) (виводимо
на екран результати рахунки)
end.
Вихідні
дані та результати рахунку:
m = 0, n = 0, x = 2.0000000000E +00
(2)
m = 3, n = 5, x = 3.1250000000E-03
(0,003125)
m = 7, n =- 3, ви помилилися, вводите
невід'ємні числа
Пояснювальна записка
Тепер
пояснимо нашу програму. program factorial_ (input, output) - з цим ускладнень не
виникає, factorial --
ім'я програми, input-файл,
звідки відбувається зчитування даних, output-файл, куди відбувається виведення даних. У нашому випадку (input, output) показує, що програма
вимагає введення даних і проводить їх висновок.
Label 0; описуємо позначку,
яка нам стати в нагоді пізніше
var
rez: real;
m, n: longint; - описуємо глобальні змінні.
function fact (z: longint): real;
оголошуємо функцію, даємо їй ім'я fl,
вказуємо формальні параметри. У даному випадку це параметр-значення z.
var
y: real; описуємо локальну змінну,
тобто вона буде використовуватися тільки в тілі функції. Real використаний тому, що вже 13!
Виходить за рамки longint
begin
y: = 1; необхідно привласнити
змінної значення, рівне одиниці, принаймні з двох причин:
при
збільшенні числа на 1 виходить це ж число, тому при у = 1 виключені помилки
на початку обчислення факторіалу.
відомо,
що 0! = 1, тому при m
або n = 0 цикл не
запускається, а значення 0! Виявляється рівним 1.
while z> 1 do запускаємо
цикл у зворотний бік, оскільки результат виходить один і той же, але при цьому
не доводиться описувати додаткову локальну змінну для запуску циклу з
параметром. 1 виключаємо з обчислення факторіалу з вищезгаданих причин.
begin
y: = y * z;
z: = z-1
end;
fact: = y цим
оператором присвоюємо функції значення факторіалу.
Крапку
з комою перед end
можна не ставити.
end; кінець функції
begin початок тіла програми
writeln ( 'введіть
невід'ємні числа '); даний оператор виводить на екран текст, укладений
між'', допомагає зрозуміти, чого ж вимагає програма.
0: readln (m, n); за допомогою цього оператора вводу інформації вихідні дані
заносяться до комірки пам'яті.
if m or n <0 then begin writeln ( 'ви помилилися, вводите
невід'ємні числа');
goto 0
end; якщо користувач все ж таки
ввів негативні числа, то програма видасть невірний результат, дана
послідовність операторів виводить на екран повідомлення про помилку користувача
і повертає до введення чисел
rez: = (fact (m) + fact (n))/fact (m + n); обчислюємо значення (m! + n!)/(m + n)!
writeln ( 'результат:', rez) даний
оператор виводу інформації виводить на екран обчислена значення.
end.
кінець програми
Наведемо
для більшої надійності ще кілька результатів рахунки
M = 2 N = 8 X = 1.1111662257Е-02
M = 4 N = 4 X = 1.1904761905Е-03
M = 0 N = 3 X = 1.1666666667Е 00
M = 3 N = 15 X = 2.0424836601Е-04
ВИСНОВОК
Система
програмування Турбо Паскаль містить потужний інструмент розробки програм --
підпрограми. У даній курсовій наведено синтаксис процедур, види і призначення
параметрів. Як ми побачили, програма обчислення факторіалу з використанням
функції набагато більш компактна, ніж та ж програма без процедур-функцій. Використання
процедур-функцій аж ніяк не є поганим тоном в програмуванні, тому
кожний вивчає мову програмування Паскаль повинен обов'язково мати
уявлення про процедури-функції і уміти ними користуватися.
Список літератури
А.
Масюков. Короткий конспект лекцій з інформатики.
Інтерактивний
підручник Turbo Pascal
7.0
С.
А. Абрамов. Почала програмування на мові паскаль
Додаток
ASSEMBLER
- Ця директива скасовує стандартну послідовність машинних інструкцій,
виробляються при вході в процедуру і перед виходом з неї.
EXTERNAL
- За допомогою цієї директиви оголошується зовнішня підпрограма.
FAR
- Компілятор повинен створювати код підпрограми, розрахований на дальню модель
дзвінка. Директива NEAR змусить компілятор створити код, розрахований на ближню
модель пам'яті. За замовчуванням всі стандартні підпрограми генеруються з
розрахунком на дальню модель виклику, а всі інші підпрограми - на ближню
модель.
В
Згідно з архітектурою мікропроцесора ПК, в програмах можуть
використовуватися дві моделі пам'яті: близька і далека. Модель пам'яті визначає
можливість виклику процедури з різних частин програми: якщо використовується
ближня модель, виклик можливий тільки в межах 64 Кбайт (у межах одного
сегмента коду, який виділяється основній програмі і кожному що використовується в
ній модулю); при далекої моделі виклик можливий з будь-якого сегменту. Ближня
модель економить один байт і кілька мікросекунд на кожному виклику
підпрограми, тому стандартний режим компіляції припускає цю модель
пам'яті. Однак при передачі процедурних параметрів відповідні підпрограми
повинні компілюватися з розрахунком на універсальну - дальню модель пам'яті,
однаково придатну при будь-якому розташуванні процедури і викликає її програми
в пам'яті.
Явна
оголошення моделі пам'яті стандартними директивами має більш високий пріоритет
в порівнянні з налаштуванням середовища.
FORWARD
- Використовується при випереджаючому описі для повідомлення компілятору, що опис
підпрограми слід десь далі по тексту програми (але в межах поточного
програмного модуля).
INLINE
- Вказує на те, що тіло підпрограми реалізується за допомогою вбудованих
машинних інструкцій.
INTERRUPT
- Використовується при створенні процедур обробки переривань
випереджаючий
опис:
Procedure В (j: byte);
forward;
Procedure A (i: byte);
begin
B (i);
End;
Procedure B;
Begin
... ... ... ... ....
A (j);
End;
Як
бачимо, що випереджає опис полягає в тому, що оголошується лише заголовок
процедури В, а її тіло замінюється стандартною директивою FORWARD. Тепер у
процедурою А можна використовувати звернення до процедури В - адже вона вже описана,
точніше, відомі її формальні параметри, і компілятор може правильним чином
організувати її виклик. Зверніть увагу: тіло процедури У починається
заголовком, у якому вже не вказуються описані раніше формальні параметри.
Модуль
- Самостійна програмна одиниця, ресурси якої можуть бути використані
іншими програмами (фактично та ж сама програма, але з іншим типом -. tpu);
