Лекции на IV курс, уктц правец Съдържание Подпрограми в паскал 3 Дефиниране на подпрограми 3



Дата13.09.2016
Размер214.87 Kb.



П Р О Г Р А М И Р А Н Е
Лекции на IV курс, УКТЦ Правец

Съдържание


Подпрограми в ПАСКАЛ 3

Дефиниране на подпрограми 3

Локализация на имената в подпрограмата 5

Управление на данните 7

Подпрограмни типове 9

Безтипови параметри 15

Изпреварващо деклариране на подпрограми 16

Връзка на Turbo Pascal с други езици 17

Рекурсивни подпрограми 17

Модули 21

Видимост на имената 27

Рекурсия между модулите 28





Подпрограми в ПАСКАЛ


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

  • Подпрограми функции – те могат да се извикат само в пределите на израз и връщат в мястото на своето извикване определена стойност.

  • Подпрограми процедури – те се извикват за изпълнение като оператори ( в някои езици чрез специални оператори).

Функциите и процедурите могат да бъдат параметризирани. Параметрите дават възможност при всяко активиране подпрограмата да работи с различни данни, подадени от викащата среда. Параметрите на една подпрограма са имена, които имат свой тип, но не притежават стойност. Стойността си те получават при конкретно активиране на подпрограмата от, така наречените, аргументи на активация (действителни аргументи, действителни параметри).

Всяка алгоритмична среда предлага множество готови подпрограми. Те се делят на стандартни и библиотечни. Освен това почти всеки алгоритмичен език съдържа изразни средства, чрез които програмистът може да създаде свои собствени, потребителски подпрограми.



Дефиниране на подпрограми


Извършва се в раздела на процедурите и функциите и има за цел:

  • Да се зададе име на подпрограмата.

  • Да се опише броя и типа на използваните в подпрограмата формални параметри.

  • Ако подпрограмата е функция, да се опише типа на връщаната стойност.

  • Да се опише алгоритъма, който ще изпълнява подпрограмата, като евентуално, ако е необходимо могат да се създадат локални константи, типове, данни и евентуално други подпрограми, чрез които се реализира този алгоритъм.

Изброените цели се постигат, като дефиницията се оформя със заглавие и тяло.

Синтактично заглавието на подпрограмата изглежда така:




В езикът ПАСКАЛ типа на връщаната стойност може да бъде само скалар.

Тялото представлява блок, състоящ се от раздели, каквито могат да бъдат записани в главната програма. Тук също разделите могат да се доизграждат и също раздела на операторите трябва да е един и същ и последен. В него се описва алгоритъма, по който работи подпрограмата. При записване на раздела на операторите е желателно да се осигури съвпадение на физическия край (тиловото End) с логическия край на подпрограмата. Ако това е трудно реализуемо, може да се използва оператор



Exit;

който преустановява изпълнението на тялото и връща управлението във викащата среда. Тялото на функциите се различава от това на процедурите само по едно изискване. Задължително трябва да се срещне някакво присвояване, в което получаващата променлива е името на функцията. Присвоената стойност ще се върне в мястото на извикване.



Локализация на имената в подпрограмата


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

  • Живот (живост) – името е живо в дадена точка, ако за данни и имена на подпрограми името е свързано с памет, а за имена на типове са известни характеристиките на типа.

  • Интервал на живот – изгражда се от множеството точки, в които името притежава свойството живот. Интервалът може да бъде глобален (името се свързва с памет при стартиране на програмата и се развързва при нейното приключване) или локален (името се свързва с памет на някой етап от изпълнението н а програмата и губи тази памет в определен момент, като е възможно отново да се съживи и това зависи от начина на изпълнение на програмата). Определя се по следните правила:

    • Всички имена, които са дефинирани в главната програма, получават статично разпределение на паметта и следователно са глобално живи.

    • Имената на процедурите и функциите, дефинирани на произволно ниво на вложеност също са глобално живи.

    • Имената на данни, дефинирани в подпрограми, получават памет само когато подпрограмата се стартира. Памет за тях се разпределя от стека. След деактивиране на подпрограмата, тези имена освобождават паметта, т.е. те са локално живи само по време на работата на подпрограмата.

  • Видимост – името притежава това свойство в дадена точка, ако в нея на компилатора са известни всички характеристики на това име. Видимостта също бива локална и глобална.

  • Интервал на видимост – образува се от множеството точки, в които името е видимо.

  • Активност – името е активно, ако е едновременно живо и видимо.

  • Интервал на активност – диапазонът на правомерно ползване на едно име от програмиста. Той се управлява от следните правила:

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

    • Действието на името се блокира във вложен блок, ако там същото име е получило ново описание. Това локално описание е с предимство в пределите на своя блок.

Пример:




Главната програма

Тук могат да се използват А и В

С отново е недостъпно име

Procedure A

Тук В е недостъпно, a C е активно име



Procedure C

Procedure B

Тук В е активно, a C е недостъпно име






Управление на данните


Управлението на данните може да се реализира по два начина:

  • Чрез разместване на описанията и промяна на интервалите на активност.

  • С помощта на формалните параметри и аргументи. Свързването на аргументите с параметрите се нарича заместване на параметрите. Съответствието аргумент-формален параметър е позиционно (по ред на следване) като се изисква броят на формалните параметри и броят на аргументите да съвпадат.

Пример:

Програма

Състояние на стека

Program primer;

Procedure A(x,z:Real);



Var

V:Real;


Begin

End;



Begin


A (2.4,3.7);

End.





Ако зареждането на аргументите в стека е отляво на дясно, се говори за ПАСКАЛ конвенция за връзка между параметрите и аргументите.

Ако зареждането е обратно, е налична СИ конвенция за заместване на параметрите. ПАСКАЛ конвенцията изисква съвпадение по брой и тип на аргументите и формалните параметри, докато СИ конвенцията допуска създаване на подпрограми с променлив брой параметри.



Информационната връзка формален параметър-аргумент може да се реализира по два начина:

  • Заместване по стойност – реализира се за формалните параметри, които не са предхождани от служебната дума Var и се наричат параметри стойности. В този случай, при активиране на подпрограмата се заделя памет в стека за формалните параметри и локалните данни. В паметта за формалните параметри се зарежда стойността на аргументите. Подпрограмата може да ги ползва и/или променя, като това не се отразява върху оригиналният екземпляр. Параметри стойности трябва да бъдат параметрите, чрез които подпрограмата получава данни от викащата среда. Задължително параметър стойност трябва да бъде този, който се замества с израз. С изключение на файловите данни, които винаги трябва да се заместват по адрес, няма ограничения по отношение на това, как да се замества данната. Единственото правило, от което трябва да се ръководи програмиста, е дали чрез този параметър подпрограмата само получава стойност или изнася резултат. Желателно е сложните данни да не се заместват по стойност.

  • Заместване по адрес – формалните параметри, които се заместват по този начин трябва да бъдат предхождани от служебната дума Var и се наричат параметри променливи. За тях не се създава екземпляр в стека, а чрез формалният параметър на подпрограмата се осигурява достъп до оригиналният аргумент. Всеки опит да бъде променен формалният параметър се отразява върху оригинала. Следователно, чрез такива параметри, подпрограмата може да получи данни и да изнесе резултат към викащата среда, вследствие промяната на аргумента. Доста често чрез такива формални параметри, изобщо не се получават данни, а те се използват за генериране на резултат от работата на подпрограмата. Формалните параметри променливи могат да бъдат замествани единствено с аргументи, които са имена на променливи. Параметри от този тип трябва да бъдат всички формални параметри, чрез които се изнасят данни, формални параметри, които ще представляват файлови променливи. Препоръчва се такива да бъдат и параметрите, които са сложни данни.



Подпрограмни типове


За да могат да се предават имената на подпрограмите в качеството на параметри, е необходимо да съществува възможност за описанието на типа на формалния параметър. За целта в ПАСКАЛ са създадени подпрограмни типове. Всеки подпрограмен тип трябва да бъде деклариран в раздела на типовете (длъжни сме да го направим) и по този начин ще получим име, което може да се ползва при описанието на формалните параметри. При декларацията на подпрограмен тип се записва по-същество заглавието на подпрограмата, която ще се използва като аргумент без обаче да се ползва име. Именуването на формалните параметри в този шаблон е без всякакво значение (няма значение какво имена използваме), тъй като основната информационна тежест се поема от описанието на типа на формалният параметър. (По същество се задава типовият профил на формалните параметри и формално връщаната стойност).

Синтактично подпрограмният тип изглежда така:




Пример:

Type


Proc=Procedure; { Proc – подпрограмен тип, който представлява процедури без параметри }

Proc1=Procedure(x:Real;var y:Byte); {Proc1 е подпрограмен тип, който представя процедури с два формални параметъра: x е реален, предава се по стойност, а y е Byte и се предава по адрес }

Func=Function(x:Real):Real; {Func е подпрограмен тип от функционален тип и представя функциите с един реален аргумент заместван по стойност, който връща реална стойност }
Procedure abc(a:Real; var b:Byte);

Begin


End;


Procedure P(x:Integer; y:Proc1);

Begin



P(1.5, abc);

End.


Множеството стойности на един подпрограмен тип са имената на всички подпрограми, използвани в програмата, които имат съвпадащ профил.

От подпрограмен тип могат да бъдат създадени и данни по нормалният начин:

Var

Z:Proc1;


F:Func;

С данни от подпрограмен тип могат да се изпълняват две операции:



  • Присвояване между еднотипни променливи като е възможно на променлива да се присвои и име на подпрограма със съвпадащ профил, което по същество е константа.

  • Активиране на текущата подпрограма (тази, която текущо е стойност на данната): <име на данна>[<съвкупност аргументи>]

Синтактично активирането се изразява:


Пример:

Z:=abc;


Z(1.5,i); { стартира abc }

Всяка данна от подпрограмен тип по същество съдържа адреса на входната точка в подпрограмата, която е текуща стойност на данната. Тази стойност (адрес) не може да се ползва както се ползват стойностите на нормални данни, тъй като името на данната е опит за активация. Достъп до текущата стойност (адрес) се получава, ако името се предхожда от операцията @, която е с първи приоритет. Добавянето на @ пред променливата я преобразува в нетипизиран указател (pointer). Обърнете внимание, че за да получите адреса на променливата трябва да използвате



@@ <променлива>

Пример:

Type


Func=Function (X:Integer):Integer;

Function MyFunc (X:Integer):Integer;

Begin

MyFunc:=X*X;



End;

Var


F:Func;

P:Pointer;

N:Integer;

Begin


F:=MyFunc;

N:=F(3);


P:=@F;

N:=Func(P)(N);

F:=Func(P);

Func(P):=F;

@F:=P;

End.
Ограничения:



  1. Всички подпрограми, които ще се ползват в качеството на константи за подпрограмни типове, трябва да се опишат на първо ниво в главната програма, т.е. не могат да бъдат вложени в други подпрограми. Освен това те трябва да се компилират по т.нар. дълъг модел на паметта. Това се постига като подпрограмата се предхожда от директивата {$F+}. След края на процедурата се пише {$F-} за връщане в нормално състояние. {$F+} може да се замести с служебната дума far;, а {$F-} – с near;. Near и far се записват в заглавието на подпрограмата.

  2. Подпрограми inline (написани на машинен код) или interrupt (за обработка на прекъсване) не могат да бъдат константи на подпрограмен тип.

  3. Стандартните процедури и функции, дефинирани е модул system, не могат да бъдат използвани като константи на подпрограмен тип.


Пример: Да се състави програма, която отпечатва таблици за събиране и умножение, подпомагащи обучението в началният курс.

Program Table;

Type

Func=function (x,y:integer):integer;



Function Add (a,b:integer):integer; far;

Begin


Add:=a+b;

End;


Function Mult (a,b:integer):integer; far;

Begin


Mult:=a*b;

End;


Procedure MakeTable (W,H:integer; Operation:Func);

Var


I,j:integer;

Begin


Write (‘ ‘);

For i:=1 to W do

Write (i:5);

WriteLn;


Write (‘ ‘);

For i:=1 to W do

Write (‘-----‘);

WriteLn;


For i:=1 to H do Begin

Write (i:5,’ | ‘);

For j:=1 to W do

Write (Operation(j,i):5);

WriteLn;

End;


WriteLn;

End;


Begin

MakeTable (10,10,Add);

MakeTable (10,10,Mult);

End.



Безтипови параметри


За параметри променливи (това са параметрите предавани по адрес) може да не се указва тип. Тези параметри се заместват по адрес и се работи с паметта на аргумента. Ако в тялото на подпрограмата тази памет получи подходящо тълкуване, тя може да изпълни своето предназначение.

Пример: Да се състави подпрограма функция, която сумира N байта, представляващи паметта за един от параметрите.

Function Sum(var x;N:Integer):LongInt;

Type

xType=Array[1..65000] of Byte;



Var

Suma:LongInt;

I:Integer;

Begin


Suma:=0;

For i:=1 to N do

Suma:=Suma+xType(x)[i];

Sum:=Suma;

End;

Type


Vector=Array[1..1000] of Word;

Var


A:Vector;

Begin


Sum(a,100);

End.


Изпреварващо деклариране на подпрограми


Всяка подпрограма може да бъде извикана за изпълнение след като във програмата бъде записана нейната дефиниция (виж локализация на имената). Ако по някакви причини програмата трябва да се изпълни преди да е дефинирана, трябва да се направи изпреварващо деклариране, което лежи преди използването й и позволява да бъде видима в точката на извикване на подпрограмата.

Изпреварващата декларация е по същество заглавието на подпрограмата, последвано от forward;:



Function func(x:Real):Real; forward;

Наличието на изпреварваща декларация най-често говори за не съвсем коректно кодиране (писане) на програмата, но съществуват и случаи когато изпреварващите декларации не могат да бъдат избегнати: при пряка или косвена взаимна рекурсия на две или повече подпрограми. Подпрограмите А и В са в пряка взаимна рекурсия, ако А вика В, а В вика А. Рекурсията е косвена, ако се осъществява чрез други подпрограми.

Procedure B; forward;

Procedure A;



Begin

B;

End;



Procedure B;

Begin



End;



Връзка на Turbo Pascal с други езици


Turbo Pascal (TP) не поддържа в явен вид т.нар. обектни файлове (файлове, които се получават след компилация). По тази причина връзката с езици Асемблер, Си, Фортран е трудно реализуема и изисква детайлни познания по отношение на начина на заместване на параметрите. Във връзка с това се препоръчва при писане на програми максимално да се прибегне към вграденият асемблер.

Ако все пак се наложи да се прави връзка, то на мястото на тялото на подпрограмата се записва External;, а самата продпрограма трябва да е компилирана до OBJ файл, който се включва с



{$L <име обектен файл>}

Не трябва да се забравя и конвенцията за връзка, както и типовото съответствие между езиците, за да бъде връзката между тях безпроблемна.



Пример: ако е дефинирана подпрограма SqRoots:

Procedure SqRoots (A,B,C:Real); external;

{$L Roots.Obj}


Рекурсивни подпрограми


Една подпрограма е рекурсивна, ако в тялото й съществува извикване на самата нея. ВР разрешава рекурсиите, но добрият програмист трябва да има предвид, че всяка рекурсия може да се реализира чрез итерация.

Пример: Да се намери х!=1*2*3*4*...*х.

Рекурсивен вариант

Итеративен вариант

Function xFact(x:Real):Real;

Var


Rez:Real;

Begin


If x<0 Then Rez:=0

Else If x=0 Then Rez:=1

Else

Rez:=x*xFact(x-1);



xFact:=Rez;

End;


Function xFact(x:Real):Real;

Var


Rez:Real;

Begin


If x<0 Then Rezt:=0

Else Begin

Rez:=1;

For i:=2 to x do



Rez:=Rez*i;

End;


xFact:=Rez;

End;


При всяка подпрограма, която е рекурсивна, трябва да има път, който се изпълнява без самоизвикване и път който реализира влизането в рекурсия. В простият случай това е If…Then…Else оператор, в който действията след If (или Else) не предизвикват рекурсия. Клонът на програмата с рекурсия осъществява последователно навлизане в рекурсивните нива, докато се получи условие при което постоянно трябва да се изпълнява клонът без рекурсия. В този момент започва обратен ход и излизане от рекурсия.

За показаният по-горе пример, при х=5, се получава:



Прав ход на рекурсията

Обратен ход на рекурсията

5*xFact(4)

120

4*xFact(3)

24

3*xFact(2)

6

2*xFact(1)

2

1*xFact(0)

1

При всяко влагане в рекурсия се заделя нова памет за формалните параметри и локалните данни. Последното трябва да се има предвид при оптимизиране дълбочината на стека.

Накрая, нека покажем как изглежда тялото на една подпрограма синтактично:




Пример: Да се намери сумата на елементите на едномерен масив от 1000 реални числа. Задачата да се реши с подпрограми.

Ще създадем 3 подпрограми: една за въвеждане на данните (Input), другата – за обработка (Sum) и третата – за печат на резултата на екрана (Output). И трите ще имат като формален параметър променлива масива, за да не се товари много стека. (Задължително е само Input да получи масива като параметър променлива)

Const N=1000;

Type


Mas = Array [1..N] of real;

Procedure input (var x:mas);

Var

I:1..N;


Begin

WriteLn (‘Input the array’);

For i:=1 to N do Begin

Write (‘x[‘,I,’]= ‘);

Read (x[i]);

End;


End;

Function sum (Var x:mas):double;

Var

S:double;



I:1..N;

Begin


S:=0;

For i:=1 to N do

S:=s+x[i];

Sum:=s;


End;

Procedure output (s:double);

Begin

WriteLn (‘The sum of the array is ‘,s:10:4);



End;

Var


A:mas;

Begin


Input (A);

Output (sum(A));

End.


Модули


В стандартният ПАСКАЛ не се разрешава програмата да бъде записана в няколко файла. Това е отстранено в TР с въвеждане на модулно програмиране. Всяка програма може да бъде разположена в няколко файла, един от които съдържа главната програма и вложените в нея подпрограми. Всички останали файлове са файлове модули.

Всеки модул предлага определени услуги на своите клиенти като крие в себе си подробностите по реализацията на тези услуги. Това се постига като текста на модула е разделен на две части:



  • Специфицираща част: тя съдържа описание на услугите, които модула предлага на клиентите. Това описание осигурява използването им.

  • Реализираща част: в нея са скрити всички подробности, отнасящи се до реализацията на предлаганите услуги.

Потребителят трябва да заяви използването на модула чрез

Uses <име на модул>;

която се записва в главната програма непосредствено след нейното заглавие или на първият ред на програмата, ако заглавие липсва. Модулите в TР предлагат следните услуги:



  • Дефинирани константи;

  • декларирани типове;

  • дефинирани данни;

  • възможност за извикване на подпрограми.

От гледна точка на използването на тези компоненти потребителят не е длъжен да записва никакъв допълнителен (пояснителен) текст.

Структурно модулът изглежда така:



Unit <име на модула>;

Interface

[Uses <име на модул>,,,;]

[<декларация на публични константи>]

[<декларация на публични типове>]

[<дефиниция на публични данни>]

[<декларация на публични подпрограми>]

Implementation

[Uses <име на модул>,,,;]

[<декларация на локални константи>]

[<декларация на локални типове>]

[<дефиниция на локални данни>]

[<дефиниция на локални етикети>]

[<реализация на публични подпрограми>]

[<реализация на локални подпрограми>]

[Begin]

[<инициализиращи оператори>]

End.

Всички компоненти на модула, изброени в [] са незадължителни.



Пример:

Unit abc;

Interface

Implementation

End.

<Име на модул> се избира по правилата за именуване в TР. Може да съдържа до 64 символа. От тях първите 8 са значещи, а останалите имат коментарен смисъл. Причина за това е факта, че името на модула трябва да съвпада с името на pas файла, който го съдържа. Самият модул е единица за компилация и след компилацията се получава файл ТPU, който носи името на модула.

Частта между Interface и Implementation се нарича интерфейсна (специфицираща) част на модула. В нея се описват услугите, които предлага модула на своите клиенти. Ако интерфейсната част се нуждае от услугите на други модули, те се изброяват в uses клаузата в началото като се разделят със запетая.

Услугите се оформят във вид на раздели на константи, типове и данни по същите правила, по които се записват разделите в главната програма. Разделът на подпрограмите съдържа само прототипите (заглавията) на подпрограмите, които модула предлага за използване. В тези прототипи не могат да участват допълнения от типа на forward; external; interrupt;.

Частта между Implementation и Begin носи името реализация на модула. Тя се оформя също във вид на раздели като е възможно да се дефинират/декларират константи, типове, данни, етикети и подпрограми които са за локална употреба в частта реализация.

Най-важната част, която се включва в реализацията, са пълните дефиниции на публичните подпрограми. Разрешено е с цел да не се повтарят от интерфейсната част, да се използват съкратени заглавия от вида:

Function <име функция>;

Procedure <име процедура>;

Ако се запишат формални параметри, заглавията от интерфейсната част и частта реализация трябва напълно да съвпадат. Частта реализация може да ползва услуги от други модули. Те трябва да бъдат заявени чрез директивата uses в началото на Implementation.

Частта между Begin и End се нарича инициализираща част на модула. Тя може да включва произволни оператори, които работят с имената създадени в интерфейсната и реализиращата част. Обикновено тук се задават начални стойности на данните, за да може модулът да предлага услугите си. Инициализиращата част на всеки модул, използван в главната програма се стартира за изпълнение преди да се предаде управлението на главната програма. Ако тя ползва повече от един модули, инициализиращите части се стартират по ред на изброяване отляво надясно и отгоре надолу.

Ето и синтактичните диаграми на модулите:



Програма


Модул


Заглавие на модул

Интерфейс на модул


Спецификация Uses


Елементи на интерфейса


Реализация на модул


Елементи на реализацията


Инициализация на модул


След компилацията на програмата се създават TPU файлове за всеки модул. Схемата, по която се търсят модулите, е:

  • в системната библиотека TURBO.TPL;

  • в текущата директория;

  • пътищата, зададени в Options->Directories->Unit Directories или в опцията /U при работа с компилатор от команден ред.

Ако не се намерят всички модули, се сигнализира за грешка и програмата се сваля от компилация.

ТР има осем стандартни модула:



  • System – съдържа всички стандартни подпрограми и се включва автоматично при компилация.

  • Dos – осигурява достъп до функциите на операционната система.

  • Crt – дава възможност за работа с екрана в текстов режим.

  • Printer – осъществява работа с принтера.

  • Overlay – възможност за работа с овърлеи.

  • Graph – работа с екрана в графичен режим.

  • Turbo3 и Graph3 – за съвместимост с версия 3.0.



Видимост на имената


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

<име на модул>.<променлива>

<име на програмата>.<променлива>
или чрез синтактична диаграма, уточнителят изглежда така:


Пример:

Файл abc.pas

Файл MyUnit.pas

Program abc;

Uses MyUnit;

Var


Temp:Integer;

Begin



Temp:=MyUnit.Temp;

End.



Unit MyUnit;

Interface

Var

Temp:Integer;



Implementation

End.





Рекурсия между модулите


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

  • чрез внимателен анализ се отделят компонентите на модула В, които се използват от модула А и компонентите от А, които се ползват от В. Всички заедно се прехвърлят в модул С като модулите А и В ще имат в началото си uses C;

Пример: Да се реализира модул стек за работа с цели данни.

Ще реализираме стека за тип данни Integer и със статично заделена памет – масив.

Unit StackInt;

Interface

Procedure Push (el:integer);

Function Pop:integer;

Function Empty:Boolean;

Function Full:Boolean;

Implementation

Const


MAX=100;

Var


Stack:array [1..MAX] of integer;

Top:integer;

Procedure Push (el:integer);

Begin


If Top>MAX then Exit;

Stack[top]:=el;

Inc (top);

End;


Function Pop:integer;

Begin


Pop:=0;

If top=1 then exit;

Dec (top);

Pop:=Stack[top];

End;

Function Empty:Boolean;



Begin

Empty:= top=1;

End;

Function Full:Boolean;



Begin

Full:= top>MAX;

End;

Begin


Top:=1;

End.







База данных защищена авторским правом ©obuch.info 2016
отнасят до администрацията

    Начална страница