Программирование на языке Турбо Паскаль
Наиболее распространённым в настоящее время является текстовый режим 80x25 при 16 возможных цветах текста и фона. Многие графические адаптеры позволяют использовать другие режимы, например: 40x25, 80x43, 80x50 и т. д.
В управлении текстовым экраном важную роль играет курсор. Вывод символов на экран (т.е. write и writeln) осуществляется начиная с позиции курсора, когда все символы выведены, курсор останавливается в следующей позиции после последнего символа. Ввод также будет производиться начиная с позиции курсора.
Ниже приведены основные процедуры и функции для управления экраном в текстовом режиме.
|
Название |
Назначение |
|
InsLine |
Вставить строку в том месте где находится курсор, все строки ниже курсора сдвигаются вниз на одну позицию. Курсор остаётся на том же месте. |
|
DelLine |
Удалить строку в позиции курсора. Курсор остаётся на том же месте. |
|
GotoXY(x,y: byte) |
Переместить курсор в позицию (x,y); x — номер строки, y — номер столбца. |
|
ClrEOL |
Очистить строку от курсора и до правого края экрана. Курсор остаётся на прежнем месте |
|
HighVideo |
Устанавливает повышенную яркость для вывода текста |
|
LowVideo |
Пониженная яркость |
|
NormVideo |
Нормальная яркость |
|
TextColor(color: byte) |
Устанавливает цвет для вывода текста. Значения цветов — обычно числа от 0 до 15. Вместо этих чисел можно указывать и существующие константы (black, white, red, green, blue, magenta, cyan, brown, lightgray и т. п.). При необходимости можно заставить текст мерцать прибавляя к номеру цвета число 128 или константу Blink. |
|
TextBackGround(color: byte) |
Устанавливает цвет для фона. |
|
ClrScr |
Очистить экран и поместить курсор в левый верхний угол, т.е. в позицию (1,1) — 1-я строка, 1-й столбец. При очистке экран заполняется цветом фона (см. TextBackground) |
|
WhereX: byte |
Эта функция возвращает номер строки, в которой находится курсор. |
|
WhereY: byte |
Номер столбца, в котором находится курсор |
2. Работа с клавиатурой
При работе с клавиатурой компьютер помещает всю информацию о нажатии клавиш в очередь до тех пор, пока эта информация не потребуется программе (например, для вывода на экран, для движения объектов в играх и т.п.). Для работы с клавиатурой важны 2 функции:
KeyPressed: boolean — возвращает true, если очередь клавиатуры не пуста (то есть была нажата). Простейший пример использования — повторять какие либо действия, пока не нажата клавиша: repeat ... until KeyPressed;.
ReadKey: char — возвращает символ, соответствующий нажатой клавише (из очереди клавиатуры). Если пользователь нажал клавишу, для которой имеется код ASCII, то в очередь будет положен один соответствующий символ, а если это специальная клавиша (F1, F2, ... F12, клавиши управления курсором, Ins, Del, Home, End, PgUp, PgDn), то сначала в очередь будет положен символ с кодом 0, а затем дополнительный символ. Если очередь клавиатуры пуста, то Readkey будет ждать, пока пользователь не нажмёт какую-либо клавишу.
Для демонстрации работы ReadKey можно написать такую программу:
uses Crt;
var c: char;
begin
repeat
c:=ReadKey;
writeln(ord(c));
until c=#27 {клавиша Escape};
end.
При нажатии вышеперечисленных специальных клавиш эта программа будет выводить по два кода сразу.
3. Другие возможности
При необходимости организации задержек в программе можно использовать процедуру Delay(time: word). Параметр time — время в миллисекундах, на которое нужно приостановить программу.
Ещё одна возможность модуля CRT — работа с системным динамиком. Для включения звука нужна процедура Sound(f: word) (f — частота в герцах). После включения требуется задержка (Delay) на необходимое время звучания, затем — выключение с помощью NoSound. Если не воспользоваться NoSound, то звук будет слышен даже после выхода из программы на Паскале.
Лекция 11. Графика в Турбо Паскале
В отличие от уже знакомого текстового режима, экран в графическом режиме разбит на большое количество точек, каждая из которых может иметь определённый цвет. Точки считаются одинаковыми и прямоугольными, все они плотно «уложены» на экране, то есть для любой точки можно указать, в какой строке и в каком столбце она находится. Номера строк и столбцов в графическом режиме используются как координаты точки, следовательно, координаты всегда целочисленные. В графическом режиме начало координат находится в левом верхнем углу экрана, ось x направлена вправо, ось y направлена вниз.
Заметим, что существуют разные графические режимы, они отличаются количеством точек по горизонтали и вертикали (разрешением), а также количеством возможных цветов, например: 320x200x16, 640x480x16, 640x200x16, 800x600x256 и т. п.
Все средства для работы с графикой содержаться в стандартном модуле Graph, поэтому его нужно будет упоминать после слова uses.
1. Включение и выключение графического режима.
Для включения графического режима используется процедура InitGraph(driver,mode,path) опишем назначение её параметров:
driver – переменная типа integer, в котором задаётся тип видеоадаптера, установленного в компьютере. В модуле определены константы для различных адаптеров, которые избавляют нас от необходимости запоминать числа. Имеются такие константы: CGA, EGA, EGA64, EGAMono, VGA, MCGA, IBM8514 и т. п. Для нас наиболее важной будет константа detect, при указании которой InitGraph сама подыщет наиболее мощный тип адаптера, совместимый с тем адаптером, который установлен на компьютере.
mode – также переменная типа integer, задаёт режим, в котором работает выбранный видеоадаптер (здесь также определены константы). Почти каждый видеоадаптер может работать в нескольких режимах, например, у VGA есть 640x200x16 (VGALo), 640x350x16 (VGAMed), 640x480x16 (VGAHi). Если в первом параметре было указано значение detect, то InitGraph не обращает внимания на mode, а устанавливает наилучший, на её взгляд, режим.
path – строковый параметр. Для каждого видеоадаптера (или для группы сходных видеоадаптеров) существует программа-драйвер, с помощью которой модуль Graph общается с видеоадаптером. Такие драйверы хранятся в файлах с расширением «bgi». В параметре path указывается каталог, в котором хранятся драйверы. Если они находятся в текущем каталоге, то этот параметр равен пустой строке.
Обычно для включения графики мы будем использовать InitGraph в таком виде:
const gpath = ‘Y:WIN_APPSBPBGI’
var gd,gm: integer;
...
begin
...
gd:=Detect;
InitGraph(gd,gm,gpath);
...
Для завершения работы с графикой и выхода в текстовый режим используется процедура CloseGraph.
2. Построение элементарных изображений
Система координат при работе с графикой имеет начало (точку (0,0)) в левом верхнем углу экрана. Ось x направлена вправо, ось y – вниз. Очевидно, что все точки экрана имеют целочисленные координаты.
При построении простейших элементов изображений используются следующие процедуры и функции:
|
Название |
Назначение |
|
PutPixel(x,y: integer; c: word); |
Поставить точку (x,y), используя цвет c. Значение цвета обычно меняется от 0 до 15, вместо номера цвета можно употреблять цветовые константы модуля Graph. |
|
SetColor(c: word); |
Установить текущий цвет для рисования отрезков, окружностей и т. п. Все линии после употребления этого оператора будут рисоваться установленным цветом. |
|
SetBkColor(c: word); |
Установить текущий цвет для фона (то есть цвет всего экрана). |
|
GetMaxX; GetMaxY; |
Эти функции возвращают максимальные допустимые значения координат x и y, соответственно. |
|
Line(x1,y1,x2,y2: integer); |
Рисовать отрезок из (x1,y1) в (x2,y2) текущим цветом. |
|
Rectangle(x1,y1,x2,y2: integer); |
Рисует текущим цветом прямоугольник, левый угол которого – (x1,y1), а правый нижний – (x2,y2). |
|
Circle(x,y: integer; r: word); |
Рисует текущим цветом окружность с центром в точке (x,y) радиуса r. |
|
Arc (x,y: integer; a1,a2,r: word); |
Рисует дугу окружности. a1 и a2 – начальный и конечный углы (в градусах), соответственно. Угол отсчитывается традиционно, против часовой стрелки, угол величиной 0° соответствует лучу y=0, x>0. |
|
Ellipse(x,y: integer; a1,a2,xr,yr: word); |
Рисует дугу эллипса с полуосями xr и yr от угла a1 до a2. |
|
DrawPoly(n: word; P); |
Рисует многоугольник, количество сторон в котором – n, а информация о вершинах хранится в нетипизированном параметре P. В качестве P удобнее всего использовать массив из записей, каждая из которых содержит поля x,y: integer; |
|
MoveTo(x,y: integer); |
Эта процедура опирается на понятие текущей позиции. Она «запоминает» позицию (x,y) на экране, а в дальнейшем из этой позиции можно рисовать отрезки. |
|
LineTo(x,y: integer); |
Рисует отрезок из текущей позиции в точку (x,y). При этом текущая позиция перемещается в конец нарисованного отрезка. |
|
MoveRel(dx,dy: integer); |
Перемещает текущий указатель из прежнего положения (x,y) в точку (x+dx,y+dy). |
|
LineRel(dx,dy: integer); |
То же, что и предыдущая процедура, но при перемещении рисует отрезок от (x,y) до (x+dx,y+dy). |
|
GetX; GetY; |
Возвращают координаты текущего указателя (по отдельности). |
|
ClearDevice; |
Очищает экран. |
Все приведённые выше процедуры для рисования выполняют только контурные рисунки (не закрашивая прямоугольник, окружность или эллипс внутри). По умолчанию рисование происходит с использованием тонкой сплошной линии, однако толщину и вид линии можно менять с помощью процедуры SetLineStyle(style,pattern,width: word). Рассмотрим назначение параметров этой процедуры.
style – вид линии. Здесь удобно задавать не конкретные числа, а константы: SolidLn, DottedLn, CenterLn, DashedLn, UserBitLn. Первая обозначает сплошную линию, следующие три – разные виды прерывистых линий, последняя – линию, вид которой определяется пользователем (см. ниже).
pattern – образец для вида линии, определяемого пользователем. Этот параметр вступает в действие лишь тогда, когда в предыдущем указано UserBitLn. Образец – это фрагмент линии, заданный в виде числа. Переход от конкретного фрагмента к числу выполняется, например, так:

Удобнее всего переводить полученное число в шестнадцатеричный вид, в нашем примере получится $999C. При изображении линии закодированный нами фрагмент будет повторяться столько раз, сколько нужно.
width – толщина линии. Можно использовать числа, однако определены 2 константы: NormWidth и ThickWidth (нормальная и толстая линии).
Перейдём теперь к рисованию закрашенных фигур. По умолчанию внутренняя область фигуры будет закрашиваться белым цветом, причём закраска будет сплошной. Для управления цветом и видом закраски используется процедура SetFillStyle(style, color: word); Также как и для стиля линии, для style предусмотрены константы: EmptyFill, SolidFill, LineFill, LtSlashFill, SlashFill, BkSlashFill, LtBkSlashFill, HatchFill, XHatchFill, InterleaveFill, WideDotFill, CloseDotFill, UserFill. Первая обозначает отсутствие закраски, вторая – сплошную, последующие – различные специфические виды закраски, самая последняя – закраску, задаваемую пользователем. Чтобы задать пользовательский образец закраски, нужно использовать процедуру SetFillPattern(Pattern: FillPatternType; Color: Word); FillPatternType определяется как array[1..8] of byte, каждый элемент массива кодирует одну строчку образца закраски (как и для линий), а всего таких строчек 8. В результате закраска выполняется с помощью одинаковых квадратиков 8x8.
Ниже приводятся процедуры рисования закрашенных фигур.
|
Название |
Назначение |
|
Bar(x1,y1,x2,y2: integer); |
Рисует закрашенный прямоугольник. |
|
FillEllipse(x,y: integer; xr,yr: word); |
Закрашенный эллипс. |
|
FillPoly(n: word; P); |
Закрашенный многоугольник. |
|
PieSlice(x,y: integer; a1,a2,r: word); |
Закрашенный круговой сектор. |
|
Sector (x,y: integer; a1,a2,xr,yr: word); |
Закрашивает эллиптический сектор. |
|
FloodFill(x,y: integer; Cborder: word); |
Выливает краску в точку (x,y), откуда она растекается во все стороны, пока не достигнет границы цвета Cborder. Если такой границы нет или она незамкнута, то краска может залить весь экран. |
3. Вывод текстовой информации.
Для вывода текста на экран используются две процедуры:
OutText(s: string). Эта процедура выводит строку s начиная с текущей позиции, то есть левый верхний угол выводимой строки находится в текущей позиции (по умолчанию это так). Текущая позиция задаётся, например, с помощью MoveTo.
OutTextXY(x,y: integer; s: string). Используется для вывода строки в конкретной позиции.
Если требуется вывести какие либо числа, то предварительно требуется преобразовать их в строку, например, с помощью процедуры Str.
Пример:
var r: integer;
s: string;
...............
Str(r,s);
OutTextXY(100,200,’Результат=’+s);
Турбо Паскаль позволяет использовать несколько различных шрифтов для вывода текста. Кроме того, можно менять направление вывода текста, а также размер символов. В этих целях используется процедура SetTextStyle(Font, Direction, CharSize : word). Перечислим возможные константы и значения для параметров этой процедуры.
Font (шрифт):
DefaultFont – шрифт 8x8 (по умолчанию)
TriplexFont – полужирный шрифт
SmallFont – тонкий шрифт
SansSerifFont – шрифт без засечек
GothicFont – готический шрифт.
Direction (ориентация и направление вывода символов):
0 – привычный вывод слева направо
1 – снизу вверх (надпись «положена на бок»)
2 – слева направо, но «лежачими» буквами.
Size – размер шрифта (целые числа от 0 до 10).
Другая возможность при работе с текстом – это выравнивание его относительно задаваемых координат вывода. Для этого используется процедура SetTextJustify(horiz,wert: word). Horiz указывет как текст расположен относительно заданной позиции по горизонтали, а vert – по вертикали. Возможные константы:
для horiz:
LeftText – указанная позиция является левым краем строки
CenterText – позиция является серединой выводимой строки
RightText – правым краем строки;
для vert:
BottomText – позиция находится на нижнем крае изображения
CenterText – по центру
TopText – позиция является верхним краем изображения.
Лекция 12. Текстовые файлы
Ниже будут обсуждаться способы взаимодействия программы на Паскале с текстовыми файлами, записанными на каком-либо диске. Примерами текстовых файлов могут служить тексты программ на Паскале, простые текстовые документы и т.п.
Любой текст в файле хранится в виде последовательности символов (char), для разбиения текста на строки используются невидимые при просмотре символы конца строки.
1. Объявление файловой переменной и привязка к файлу на диске
Для того чтобы программа могла работать с текстовым файлом, нам потребуется переменная специального файлового типа text:
var f: text;
Эта переменная не содержит в себе весь текст из файла, она служит для чтения данных из файла и для записи новых данных в него.
Прежде чем работать с конкретным файлом на диске, файловую переменную следует связать с этим файлом, используя такую процедуру:
assign(TxtFile: text, name: string);
Первый параметр (TxtFile) — файловая переменная, второй — строка, содержащая имя файла на диске. Если файл лежит в текущем каталоге, то достаточно указать только его имя и расширение, если в каком-либо другом, то потребуется указывать путь к этому файлу, например:
assign(f,'Z:SCHOOLtext1.txt');
2. Чтение данных из файла
Перед тем как рассматривать процедуры чтения, заметим что файл можно обходить только последовательно. Хорошей аналогией файла может послужить магнитная лента, с которой головка может читать информацию только по порядку, а для возврата к началу блока данных требуется дополнительное усилие (перемотка).
Чтобы открыть для чтения файл, который был указан при вызове assign, нужно использовать процедуру
reset(TxtFile: text);
После такого действия «читающая головка» будет установлена на начало файла. Разумеется, указанный файл должен существовать на диске, в противном случае в программе возникнет ошибка.
После открытия файла можно начинать чтение данных. Для этого используются процедуры read и readln, которые используются в следующем формате:
read(TxtFile: text, v1: type1, v2: type2, ... vN: typeN);
readln(TxtFile: text, v1: type1, v2: type2, ... vN: typeN);
Первая процедура читает последовательно из файла значения и помещает их в переменные v1, v2, ... vN. После каждого прочитанного значения указатель файла («читающая головка») смещается к началу следующего значения. Процедура readln делает то же самое, после чего перемещает указатель на начало следующей строки; readln с одним лишь первым параметром переводит указатель на начало новой строки. В качестве параметров для процедур read и readln можно использовать переменные следующих типов:
целые: integer, byte, shortint, word, longint;
вещественные: real, single, double, extended, comp;
строковые (string);
символьные (char).
При чтении строковых значений из файла берётся вся последовательность символов от позиции указателя до конца строки. Если после этого попытаться вновь прочитать строку, то результат будет пустой строкой ( ' ' ). Если попытаться прочитать число, когда указатель файла стоит в конце строки, то будет прочитан 0.
При чтении чисел read и readln работают так: сначала указатель пропускает все пробелы и символы табуляции, а затем, найдя первый значащий символ, пытается прочитать число. Если это невозможно (встретилась буква или число записано неверно), то произойдёт ошибка.
Пример использования процедуры чтения:
var f: text; s: string; n: integer;
...
readln(f,n,s);
Необходимо помнить, что если файл не был открыт для чтения с помощью reset, то любая попытка прочитать из него данные приведёт к ошибке.
Довольно часто в программе бывает необходимо определить, дошёл ли указатель файла до конца строки или до конца файла. В этом случае полезно использовать такие функции:
eoln(TxtFile: text): boolean;
eof(TxtFile: text): boolean;
Первая принимает значение true (истина), если указатель стоит на конце строки, вторая — то же самое для конца файла.
После того как все операции чтения закончены, файл необходимо закрыть с помощью процедуры
close(TxtFile: text);
если этого не сделать, то содержимое файла может оказаться испорченным после выполнения нашей программы.
Пример 1 (процедуры чтения). Пусть имеется текстовый файл, например программа на Паскале. Требуется распечатать его содержимое на экране:
program ShowFile;
var f: text;
c: char;
begin
assign(f,'showfile.pas');
reset(f);
whilenot eof(f) do begin
while not eoln(f) do begin read(f,c); write(c); end;
readln(f);
writeln;
end;
close(f);
readln;
end.
3. Запись данных в файл
А теперь перейдём к процедурам записи в файл. Перед тем как что-либо записывать, нужно создать новый (пустой) файл или стереть содержимое существующего. Для этого используется процедура
rewrite(TxtFile: text);
До её вызова файловая должна быть привязана к имени файла на диске с помощью assign. Если файл не существовал, то rewrite создаст его, если существовал, то содержимое будет стёрто. В любом случае файл будет пустым, а указатель записи стоит на начале файла.
Для записи используются процедуры
write(TxtFile: text, p1: type1, p2: type2, ... pN: typeN);
writeln(TxtFile: text, p1: type1, p2: type2, ... pN: typeN);
Здесь в качестве параметров p1, p2, ... pN можно использовать не только переменные, но и выражения: числовых типов, строковые, символьные и логические (boolean). В отличие от write, writeln после записи в файл значений p1, p2, ... pN переводит указатель записи на начало новой строки; writeln с одним параметром (текстовый файл) лишь переводит указатель на новую строку.
Так же как и в случае с чтением из файла, после того как все данные записаны файл нужно закрыть с помощью close.
Пример 2 (запись в файл). Пусть дан произвольный текстовый файл, требуется получить другой файл, в каждой строке которого записана длина соответствующей строки исходного файла:
program WriteLength;
var f1,f2: text;
s: string;
begin
assign(f1,'writelen.pas'); reset(f1);
assign(f2,'result.txt'); rewrite(f2);
whilenot eof(f1) dobegin
readln(f1,s);
writeln(f2,length(s));
end;
close(f1); close(f2);
end.
Ещё один способ записи — это открытие для добавления информации в конец файла. Для этого используется процедура
append(TxtFile: text);
Если файл открыт с помощью append, то всё его содержимое сохраняется. При завершении дописывания в конец файла его также следует закрыть с помощью close.
Лекция 13. Двоичные файлы
Двоичный файл представляет собой последовательность одинаковых элементов, записанных на диске. В отличие от текстовых файлов, в двоичных нет разбиения на строки, файл напоминает массив, с той лишь разницей, что доступ к элементам может быть только последовательным. Для того, чтобы определить, достигнут ли конец файла, по-прежнему используется функция eof. Функция eoln, очевидно, здесь неприменима.
Для всех обсуждаемых ниже файлов можно выполнять те же процедуры открытия, закрытия и привязки, что и для текстовых: Append, Assign, Close, Reset, Rewrite. Кроме того, появляется процедура Truncate(var f: file), которая уничтожает всё содержимое файла, находящееся после текущего указателя чтения.
Двоичные файлы будем делить на типизированные и нетипизированные.
1. Типизированные файлы
Файлы этого вида состоят из элементов одинакового типа, то есть в них нельзя записывать (или читать) значения переменных разных типов, в отличие от текстовых файлов.
Объявляются типизированные файлы так:
var f: file of тип_элемента;
В качестве типа элемента можно использовать как простые типы, так и структурированные (массивы, записи и т.п.).
2. Нетипизированные файлы
Нетипизированный файл, в отличие от типизированного, используется для хранения разнородной информации, а не одинаковых элементов. В него можно записывать (а также читать) значения переменных практически любого типа (простых типов, массивов, записей, и т. п.). Описываются переменные, соответствующие нетипизированным файлам, следующим образом:
var f: file;
Для чтения и записи процедуры read и write не подходят. Используются такие процедуры:
BlockRead(var f: file; var buf; count: word [; var result: word]); – читает в переменную Buf count записей из файла, переменная result показывает сколько записей было скопировано в действительности. Под записью понимается «кусок» файла в несколько байт, размер записи можно установить при открытии файла, например: reset(f,1).
BlockWrite(var f: file; var buf; count: word [; var result: word]); – записывает указанное количество записей в файл. Если для открытия используется rewrite, то во втором её параметре также можно указать размер записи.
Лекция 14. Модули в Турбо Паскале
В Турбо Паскале допускается разбивать программы на части и хранить эти части в отдельных файлах на диске. Кроме основной программы появляются так называемые модули, которые предоставляют основной программе или другим модулям свои переменные, константы, типы, процедуры, функции и т. п. Чтобы использовать модуль в программе, нужно указать его имя после uses.
При написании модуля сначала описывается то, что он предоставляет для общего пользования (секция интерфейса), а затем – как он устроен (секция реализации). Иногда существует секция инициализации, где записаны действия, которые выполняются при подключении этого модуля. Записывается это всё следующим образом:
unit MyUnit;
interface
(*Интерфейсная секция*)
uses ...;
const ...;
type ...;
procedure ...; {Только
function ...; заголовки}
implementation
(*Секция реализации*)
uses ...;
const ...;
type ...;
procedure ...; {Реализация всех описанных
begin процедур и функций}
...
end;
function ...;
begin
...
end;
[begin]
(*Секция инициализации*)
end.
Рассмотрим части модуля подробнее. Uses в интерфейсной секции может быть нужен, если в ней используются какие-либо ресурсы из других модулей. Процедуры и функции здесь только описываются, но не реализуются, то есть не записываются тела процедур и функций (begin ... end;). В секции реализации можно также подключать другие модули; создавать переменные, константы, типы, процедуры и функции, которые «видны» только внутри этого модуля, никакой другой модуль или программа на может ими пользоваться. Здесь же обязательно должны быть записаны все процедуры и функции (полностью). Параметры (в скобках) после имени процедуры и функции в секции реализации можно не указывать.
Секция инициализации содержит те действия, которые должны выполняться когда наш модуль подключается к программе, то есть до того как начнёт работать сама программа. Модуль graph, например устанавливает в секции инициализации значения по умолчанию цвета линий и фона, стиль линий, стиль заливки т.п.
При сохранении модуля ему нужно дать такое же имя, как и после unit в тексте модуля. Имена файлов, содержащих модули, должны иметь расширение «pas», также как и программы.
Рассмотрим пример. Наш модуль предназначается для операций с трехмерными векторами:
unit Vectors;
interface
type tVec3D = record
x,y,z: real;
end;
procedure VecAdd(a,b: tVec3D; var c: tVec3D);
procedure VecSub(a,b: tVec3D; var c: tVec3D);
procedure VecMultNum(k: real; a: tVec3D; var b: tVec3D);
function ScalarProduct(a,b: tVec3D): real;
implementation
procedure VecAdd(a,b: tVec3D; var c: tVec3D);
begin
c.x:=a.x+b.x;
c.y:=a.y+b.y;
c.z:=a.z+b.z;
end;
procedure VecSub(a,b: tVec3D; var c: tVec3D);
begin
c.x:=a.x-b.x;
c.y:=a.y-b.y;
c.z:=a.z-b.z;
end;
procedure VecMultNum(k: real; a: tVec3D; var b: tVec3D);
begin
b.x:=k*a.x;
b.y:=k*a.y;
b.z:=k*a.z;
end;
function ScalarProduct(a,b: tVec3D): real;
begin
ScalarProduct:=a.x*b.x+a.y*b.y+a.z*b.z;
end;
end.
В программе наш модуль можно использовать, например, так:
program xxx;
uses Vectors;
var v1,v2,res: tVec3D;
...
begin
...
VecMultNum(0.2,v1,res);
VecSub(v2,res,res);
{в результате res = v2-0.2Чv1}
...
end.
В случаях, когда несколько модулей содержат объекты с одинаковыми именами, обращаться к ним нужно с указанием имени модуля: <имя модуля>.<имя объекта> . Пусть, например, модули unit1 и unit2 содержат процедуры с одинаковыми именами proc1, тогда обращаться к ним следует так: unit1.proc1; и unit2.proc2; .
Преимущества модулей:
Средства, взятые из модулей позволяют не повторять в программах одни и те же фрагменты.
Переменные, процедуры и другие объекты можно скрыть в секции реализации, если их необдуманное выполнение может испортить программу.
Модули компилируются отдельно от главной программы, поэтому при компиляции всей программы обрабатывается только главная программа (меньшие затраты времени при отладке программ). Это особенно важно для больших программ.
Большая программа становится более понятной, если разные её части расположить в разных модулях, в соответствии с их назначением.
Лекция 15. Динамические переменные
Все известные нам на данный момент переменные являются статическими, это означает, что память под них выделяется один раз при запуске программы, и в течение всего времени её работы переменные занимают отведённые им участки. Иногда такой подход может оказаться невыгодным. Например, при хранении табличных данных в виде массива, приходится заводить массив большого размера, поскольку заранее неизвестно, сколько строк содержится в таблице. В результате часть памяти, занятая под массив, не используется. В подобных задачах хотелось бы использовать столько памяти, сколько необходимо в каждый конкретный момент времени, то есть распределять память динамически.
В Турбо Паскале есть возможность создания динамических переменных (то есть таких, которые можно заводить и уничтожать во время работы программы по мере необходимости). Для этого в программе объявляют не саму переменную нужного нам типа, а указатель на эту переменную, например:
var p: ^real;
здесь p – имя переменной-указателя; знак "^" показывает, что p является не обычной переменной, а указателем; real