Turbo Pascal

3. Вывод  текстовой информации

Для вывода текста на экран  используются две процедуры:

1. OutText(s: string). Эта процедура  выводит строку s начиная с текущей  позиции, то есть левый верхний  угол выводимой строки находится в текущей позиции (по умолчанию это так). Текущая позиция задаётся, например, с помощью MoveTo.

2. 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 - позиция является верхним краем изображения.

 

 

 

 

 

 

 

9. Текстовые файлы

Ниже будут обсуждаться способы взаимодействия программы на Паскале с текстовыми файлами, записанными на каком-либо диске. Примерами текстовых файлов могут служить тексты программ на Паскале, простые текстовые документы и т.п.

Любой текст в файле  хранится в виде последовательности символов (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); если этого не сделать, то содержимое файла может оказаться испорченным после выполнения нашей программы.

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.

Ещё один способ записи —  это открытие для добавления информации в конец файла. Для этого используется процедура append(TxtFile: text);

Если файл открыт с  помощью append, то всё его содержимое сохраняется. 
При завершении дописывания в конец файла его также следует закрыть с помощью close.

 

 

 

 

 

 

 

 

10. Двоичные файлы

Двоичный файл представляет собой последовательность одинаковых элементов, записанных на диске. В отличие  от текстовых файлов, в двоичных нет разбиения на строки, файл напоминает массив, с той лишь разницей, что доступ к элементам может быть только последовательным. Для того, чтобы определить, достигнут ли конец файла, по-прежнему используется функция eof. 
Функция eoln, очевидно, здесь неприменима.

Для всех обсуждаемых  ниже файлов можно выполнять те же процедуры открытия, закрытия и привязки, что и для текстовых: Append, Assign, Close, 
Reset, Rewrite. Кроме того, появляется процедура Truncate(var f: file), которая уничтожает всё содержимое файла, находящееся после текущего указателя чтения.

Двоичные файлы будем  делить на типизированные и нетипизированные.

1. Типизированные  файлы

Файлы этого вида состоят  из элементов одинакового типа, то есть в них нельзя записывать (или  читать) значения переменных разных типов, в отличие от текстовых файлов.

Объявляются типизированные файлы так: var f: file of тип_элемента;

В качестве типа элемента можно использовать как простые  типы, так и структурированные (массивы, записи и т.п.).

2. Нетипизированные  файлы

Нетипизированный файл, в отличие от типизированного, используется для хранения разнородной информации, а не одинаковых элементов. В него можно записывать (а также читать) значения переменных практически любого типа (простых типов, массивов, записей, и т. п.). Описываются переменные, соответствующие нетипизированным файлам, следующим образом: var f: file;

Для чтения и записи процедуры read и write не подходят. Используются такие  процедуры:

1. BlockRead(var f: file; var buf; count: word [; var result: word]); - читает в переменную Buf count записей из файла, переменная result показывает сколько записей было скопировано в действительности. Под записью понимается «кусок» файла в несколько байт, размер записи можно установить при открытии файла, например: reset(f,1).

2. BlockWrite(var f: file; var buf; count: word [; var result: word]); - записывает указанное количество записей в файл. Если для открытия используется rewrite, то во втором её параметре также можно указать размер записи.

 

 

 

 

 

 

 

 

 

11. Модули в Турбо Паскале

В Турбо Паскале допускается  разбивать программы на части  и хранить эти части в отдельных  файлах на диске. Кроме основной программы  появляются так называемые модули, которые предоставляют основной программе или другим модулям  свои переменные, константы, типы, процедуры, функции и т. п. Чтобы использовать модуль в программе, нужно указать его имя после uses.

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

Рассмотрим части модуля подробнее. Uses в интерфейсной секции может быть нужен, если в ней используются какие-либо ресурсы из других модулей. 
Процедуры и функции здесь только описываются, но не реализуются, то есть не записываются тела процедур и функций (begin ... end;). В секции реализации можно также подключать другие модули; создавать переменные, константы, типы, процедуры и функции, которые «видны» только внутри этого модуля, никакой другой модуль или программа на может ими пользоваться. Здесь же обязательно должны быть записаны все процедуры и функции (полностью). Параметры (в скобках) после имени процедуры и функции в секции реализации можно не указывать.

Секция инициализации  содержит те действия, которые должны выполняться когда наш модуль подключается к программе, то есть до того как начнёт работать сама программа. Модуль graph, например устанавливает  в секции инициализации значения по умолчанию цвета линий и фона, стиль линий, стиль заливки т.п.

При сохранении модуля ему  нужно дать такое же имя, как и  после unit в тексте модуля. Имена файлов, содержащих модули, должны иметь расширение 
«pas», также как и программы.

В случаях, когда несколько модулей содержат объекты с одинаковыми именами, обращаться к ним нужно с указанием имени модуля. Пусть, например, модули unit1 и unit2 содержат процедуры с одинаковыми именами proc1, тогда обращаться к ним следует так: unit1.proc1; и unit2.proc2; .

Преимущества  модулей:

1. Средства, взятые из  модулей позволяют не повторять  в программах одни и те же  фрагменты.

2. Переменные, процедуры  и другие объекты можно скрыть  в секции реализации, если их  необдуманное выполнение может  испортить программу.

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

(меньшие затраты времени  при отладке программ). Это особенно  важно для больших программ.

4. Большая программа  становится более понятной, если разные её части расположить в разных модулях, в соответствии с их назначением.

 

 

 

 

12. Динамические переменные

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

В Турбо Паскале есть возможность создания динамических переменных (то есть таких, которые  можно заводить и уничтожать во время  работы программы по мере необходимости). Для этого в программе объявляют  не саму переменную нужного нам типа, а указатель на эту переменную, например: var p: ^real; здесь p - имя переменной-указателя; знак "^" показывает, что p является не обычной переменной, а указателем; real - тип той переменной, на которую указывает p. Переменная p представляет собой не что иное как адрес того места в памяти, где будет храниться сама динамическая переменная (в нашем случае число типа real).