Geum.ru

Программа на Turbo-Pascal состоит из: заголовка программы; блока; знака (. ). Заголовок программ

Вид материалаПрограмма

Содержание


Исполняемая часть.
Инициирующая часть.
Компиляция модулей.
Interface interface interface
П4. unit fiext
Главная часть программы
Связные списки.
Dispose (yknew)
Рекурсивные подпрограммы (рекурсия)
Подобный материал:
1   2   3   4   5

Исполняемая часть.

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

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


Инициирующая часть.

Завершает модуль и содержится между ключевыми словами begin и end, может быть пустой. В инициирующую часть помещаются исполняемые операторы, содержащие некоторые фрагменты программы. Эти операторы исполняются до передачи управления основной программе и обычно используются для подготовки ее к работе, открывая нужные файлы, устанавливая связь с другими программами (см.прил.4).


Компиляция модулей.


При компиляции модуля (Alt + F9) или основной программы в режиме compile, все модули uses должны быть предварительно откомпилированы, и результаты их компиляции должны быть помещены в одноименные файлы с расширением tpu.

Имя .EXE

Прог исх.мод. объектный модуль исп. модуль

имя pas. абсол. модуль

Модуль исх.мод.объект.мод.

Global.pas Global.TPU

Если в модуле имеется предложение uses Global, то на диске в каталоге, объявленном опцией UNIT DIRECTORIES, должен находиться файл Global.TPU (файл, созданный в результате трансляции, объектный модуль).

В режиме MAKE (F9) компилятор проверяет наличие TPU -файлов для каждого подключаемого модуля. Если TPU-файлов не будет, то система отыскивает PAS-файлы с исх. текстом модулей, и если найдет, то приступит в совместной компиляции, создав абсолютный модуль с расширением EXE. EXE-файл способен выполнять задачи программы без помощи транслятора. EXE -файлы всегда хранятся на внешних носителях.

Режим BUILD отыскивает только pas-файлы для каждого объявления модуля uses и компилирует их совместно с главной программой.

Недопустимы следующие объявления:

UNIT A; UNIT B; UNIT C;

INTERFACE INTERFACE INTERFACE

uses B; uses A; uses C;

............ .............. ...............

end. End. End.

П2. UNIT Global;

INTERFACE

tupe complex = record

re, in:real; end;

Procedure Addc (x,y:complex; var z:complex);

Procedure Mulc (x,y:complex; var z:complex);

IMPLEMENTATION

Procedure Addc ;

begin z.re:=x.re+y.re;

z.im:=x.im+y.im;

end;{Addc}

Procedure Mulc ;

begin z.re:=x.re-y.re;

z.im:=x.im-y.im;

end;{Mulc}

begin ..........end. Cохранить в файле Global.pas.

Program proba;

uses Global;

var a,b,c:complex;

begin

a.re:=1; a.im:=1;

b.re:=1; b.im:=2;

ADDC (a,b,c);

writeln (’Сложение’:c.re:5:1,c/im:5:1);

Mulc (a,b,c);

writeln (’Разность’,c.re:5:1,c.im:5:1);

end.

П4. UNIT FIEXT;

INTERFACE

var f:text;

const name=’out,txt’;

Procedure print (s:string);

Implementation

Procedure print;

begin writeln (f,s); close (f); end;

{инициирующая часть}

begin assign (f, name);

rewrite (f); end.

Максимальный размер модуля не превышает 64 кБайта, количество модулей не ограничено, что позволяет заполнить всю оперативную память. Однако, и этот объем памяти может быть недостаточен, поэтому Turbo Pascal предоставляет возможность писать большие программы, занимающие небольшой объем оперативной памяти под модули. Этот механизм называется оверлея.

Оверлея.-

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

Главная часть программы.

Главная программа Main - LM длина;

модуль А - LA;

модуль В - LB;

длина не оверлейной программы равна LM+LA+LB;

длина оверлейной программы равна LM + длина наибольшего модуля;

|______|_______|_______|_______|

LM LA

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

Выигрыш оверлейной программы - объем занимаемой оперативной памяти.

Недостаток - требуется дополнительное время на подкачивание модулей.

Работа оверлейных программ обеспечивается с помощью процедур и функций библиотечного модуля OVERLAY, входящего в библиотечный файл TURBO.TPU.

Чтобы программа поняла, что этот модуль оверлейный, его надо пометить.

Оверлейные программы создаются в последовательности:

П.

P1,P2: integer; С. Д. Кучи

New (p1); p1 [___][_7_]

P1: =7; 4б 2б

По адресу p1

New(p2); p2 [___][_9_]

P2: =9; 4б 2б

P1: =p2; тогда p1[___][_9_]

4б 2б.

P1: =p2; p1[___][_9_]

4б 2б.

p1[___][_9_]

4б 2б.

X: integer;

P1:=&x; p1:=АДД(x);

Принимает адрес х p1:=Nil; тo p1[___][_9_]

4б 2б.

Статическая переменная имеет структуру

ZAP= record

Информация { type Tyk=tzap

Тип действий

Ук.{ TZAP=record

End.

Информационное поле {

Ук. УК: Тук;

End.

[___|_] например создадим ряд указаний

инф.ук. var yk end, yk new;

ykfirst:tyk

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

ykEnd[адрес на]Tzap

4б.

Связные списки.

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

New(yk new); Yk end:=yk end

[____|_][yknew][____] [yknew][____|_]

инф ук инф. ук.

[yknew][____]

По адресу, на который указывает Ук end в поле ук new

ykEND. Yk:=Yknew;

[ykend][_____|_] [yknew][___|_]

инф. Ук. Ук

УКnew.УК:=Nil;

Ykfirst:=УКend;

{создает вершину списка}

ykEND. Yk:=Yknew;

{продвинуть по списку}

[ykend][_____|_] [ykend][_____|_] [ykend][_____|_]

[ykend][_____|_]

Пример. Распознать файл, организовать связной список.

Program proba;

Type Tzap=record;

{создает тип записи из файла}

fio:string;

zk:word, {структура записи файла}

end;

TYK=Tzapyk;

Создает тип указателя, базовый тип который

Tzapyk=record;

INFO:Tzap;

Информационнный кусок.

YK:TYK;

End;

Var

YKnew, ykend, ykfirst: Tyk;

Fp: file of Tzapf;

If: string[30]; i: byte;


При работе с файлом мы должны: 1. Знать имя файла write (‘введите имя файла’); read (if);

2. ассигнуем (fp связывает с именем файла if).


Assign (fp.if);

{$I-} reset (fp); {$I-}

if IORESULT<>0 then halt;

можно дать пояснения

{Дальше работает, если файл благополучно откроется}

{обрабатывает первую запись для того чтобы создать вершину списка}

new(yknew)

read(fp,yknew);

по адресу, на который указывает YKnew

или read(fp, yknew. INFO);

YKfirst:=yknew;

{указатель на вершину получает адрес этого элемента}

YkEND:= YKNEW;

YKNEW.YK:=Nil;

{предполагает, что он единственный}

while not EOP (fp) do Begin

new(yk new);

read(fp, YKnew. INFO);

YKEND.YK:=yknew;

По адресу в поле указателей

YKEND:=YKnew;

Yknew.YK:=Nil; end;

[yknew][_____|_] [yknew][_____|_]

new

Разлагает файл.

{Нужно встать на начало списка}

yknew:= ykfirst;

while yknew<>nil do begin

write(yknew.INFO.fro); и так по всем полям.

YKNEW:= yknew.yk; end.

Указатель следующего элемента

[___|_][___|_][___|nil]

Резервируем место под динамическую переменную через new, тогда освобождаем это место через DISPOSE

DISPOSE(<указатель>);

Пример Удалить первые элементы списка.

Yknew:=ykfirst;

Ykfirst 

Yknew  |_________|__| |__________|___|

Ykfirst:=ykfirst.yk {Заполним адрес второго элемента}

DISPOSE (YKNEW);

Ykn|____|__||_____|___| Удалить пятый элемент

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

Yknew:=ykfirst;

For i:=1 to 3 do {т.к. предыдущий элемент берет указатель последующей записи}

Yknew:=yknew.YK; {адрес 5 записи}

Ykend/yk;

Yknew.yk:=ykend.yk;

DISPOSE (ykend);

Рекурсивные подпрограммы (рекурсия)

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

Программа, которая вызывает саму себя называется рекурсивной, а стоящие за этим понятием процессы – рекурсами.

Рекурсия может быть выражена “явным” и “неявным” образом. Подпрограмма А вызывает подпрограмму В, а та, в свою очередь, вызывает подпрограмму А, тем самым образуя рекурсивную цепочку.

Многие математические функции и алгоритмы наиболее естественно выражаются в рекурсивной форме. Рекурсию продемонстрируем на примере функции вычисления факториала.

N!=n (n-1)!

П. Рассмотрим процесс n=5.

5!=5*4!=5*4*3*2*1=2*1!=2*1 рекурсивный процесс

4!=4*3!=4*3*2*1=1!=1 якорь

3!=3*2!=3*2*1.

Обязательным элементом в описании рекурсивного процесса является утверждение, определяющее условие завершения рекурсии, его называют опорным условием или якорем.(1!=1)

Таким образом, Y рекурсивное определение какого-либо понятия или процесса должно иметь два элемента:

- условие завершения

- способ выражения одного шага решения посредством другого, более простого шага.

Program proba;

Var a:integer;

Function fact (n:integer):real;

Begin

If n=1 then fact:=1

Else

Fact:=fact (n-1)*n;

End;

Begin

Write (’Введите исходное значение’); read (a);

Write (’факториал от’,a,’=’fact (а):5:2);

End.

________________

|5*______________

|4* ____________

|3* __________

|2* ________

|1

Рекурсия, вычисляющая n член.

Фибоначчи

1-й=1

2-й=1

Каждый последующий равен сумме 2 предыдущих.

3-й=1-й+2-й

П. N=6

Fib (n)=fib (n-1)+ fib (n-2); последовательность

If (n=1) or (g=2) then fib:=1

Якорь

Function fib (n:integer):integer;

Begin

If (n=1) or (n=2)then fib:=1

Else

Fib:=fib (n-1) + fib (n-2): =8

Fib (4) + fib (3)

Fib (3) + fib (2)

Fib (2) + fib (1)

1+1

П. Перевернуть текст.

Function rew (str:string):string;

Var firstchar:char; {под 1-й символ}

Ostatok:string;

Begin

If length (str)=1 then rew:=str

Esse begin {1}

First:char:=str [1] {примет 1-ю литеру}

Delete (str,1,1); {из стринга удалим 1-ю литеру}

Ostatok:=rew (str);

Rew:=(concat (ostatok + firstchar)) их столько же, сколько литеров в слове.

End;