- •1. Структура (состав) языка
- •2. Алфавит
- •3. Лексическая структура языка
- •4. Структура программной единицы
- •5. Стиль записи программ на языке Паскаль
- •6. Типы данных в Паскале
- •6.3 Классификация типов данных в Турбо Паскале
- •6.4 Порядковые типы
- •6.4.2 Булевский (логический) тип
- •Repeat тело_цикла until (логическое_выражение);
- •6.4.3 Целые типы Выделяют целые типы ------------- со знаком – shortint, integer, longint)
- •1 Группа функций:
- •2 Группа функций:
- •3 Группа функций:
- •6.4.4 Перечисляемый тип.
- •6.4.6 Символьный тип
- •6.5 Вещественные типы.
- •7. Выражения в языке Паскаль.
- •10. Вычисление по формулам.
- •10.1 Оператор присваивания .
- •10.2 Характер использования переменных в математике и в программах.
- •10.3 Бесконечности
- •10.4 Нестандартные операции
- •6.6 Строки
- •1) Операции присваивания и сравнения.
- •3) Заполнение строки одним символом
- •4) Стандартные функции и процедуры для работы со строками:
- •5) Подпрограммы преобразования из строкового представления в числовое и наоборот:
- •8. Совместимость и преобразование типов.
- •Совместимость типов
- •8.2 Тип результата арифметических выражений.
- •8.3 Преобразование (приведение) типов и значений.
- •8.3.1 Явное преобразование (приведение) типов.
- •8.3.2 Неявное преобразование или приведение типов.
- •9. Простейший ввод-вывод на Паскале
- •Стандартные файлы Input и Output
- •9.2 Процедуры ввода информации (с клавиатуры.
- •9.3 Процедуры вывода в тр.
- •10. Вычисление по формулам (продолжение)
- •10.6. Уточнение многоместных (n - арных) операций
- •11. Средства языка Паскаль для циклов с известным числом повторений.
- •12. Табулирование функций
- •13. Разветвляющиеся алгоритмы
- •13.1 Таблица ситуаций и команда выбора.
- •13.2 Средства языка Паскаль для программирования разветствляющихся алгоритмов
- •13.4 Описание ситуаций
- •13.5 Запись команды выбора (case) (уточнение таблицы ситуаций) с помощью набора команд ветвления
- •13.6 Запись последовательных команд ветвления в случае, когда соседние зависимые ситуации имеют общие признаки.
- •13.6.1 Восходящий подход
- •13.6.2 Нисходящий подход
- •14. Циклы с неизвестным числом повторений
- •15. Структурированные типы данных. Массивы
- •15.1 Классификация (особенности) структурированных типов данных
- •15. 2. Определение массива
- •15.3 Объявление массива на Турбо Паскале
- •15.4 Хранение элементов массива. Доступ к элементам и частям массива
- •15.5 Уточнение команд обработки массива
- •16. Правила разработки цикла
- •15. 6 Действия над массивами
- •17. Множества.
- •17.1 Множества в Паскале и в математике. Сходства и различия между ними.
- •17.2 Объявление множества на Паскале
- •17.3 Присваивание значений множествам. Конструктор множества
- •17.4 Операции над множествами.
- •17.5 Сравнение множеств.
- •17.6 Применение множеств.
- •18. Вспомогательные алгоритмы (подпрограммы).
- •18.1 Три способа записи повторяющихся команд
- •18.2 Понятие блока
- •18.3 Объекты подпрограммы (то, над чем выполняются действия).
- •18.4 Свойства локальных и глобальных объектов
- •Свойства глобальных объектов:
- •18.5 Выделение памяти под локальные и глобальные переменные
- •18.6 Передача параметров в подпрограммы.
- •Фактические параметры
- •18.7 Подпрограммы, возвращающие значение (функции)
- •18.8 Особенности использования процедур и функций в Турбо Паскале
- •18.9. Побочный эффект (side effect)
- •18.10 Опережающее определение процедур и функций.
- •18.11 Рекурсия и итерация.
- •18.12 Процедуры и функции как параметры.
- •18.13 Директивы подпрограмм
- •Директива forward
- •Директивы far и near
- •Директива external
- •Директива assembler
- •Директива inline
- •Директива interrupt
- •Отладка и тестирование программ, содержащих подпрограммы
- •18.14.1 Нисходящее тестирование и подпрограммы-заглушки
- •18.14.2 Восходящее тестирование и программы-тестеры
- •18.14.3 Рекомендации по отладке программ, содержащих подпрограммы
- •18.14.4 Использование отладчика для трассировки процедур
- •18.14.5 Область действия идентификаторов и переменные в окне Watch
- •18.15. Получение доступа а параметрам командной строки, запуск внешних программ.
- •19. Записи.
- •19.1 Понятие записи. Объявление записи в программе.
- •19.2 Доступ к полям записи.
- •19.3 Оператор with
- •19.4 Действия над записями
- •19.5 Записи с вариантами
- •Замечание1:Порядок частей – именно такой, как показано: фиксированная часть всегда первая (или единственная)
- •19.6 Типизированные константы - записи
- •20. Модули (Unit)
- •20.1 Что такое модуль?
- •20.2 Зачем нужны модули и какие есть средства, аналогтчные (в какой-то мере) модулям
- •Интерфейсная секция
- •Секция реализации
- •Секция инициализации
- •Подключение других модулей к данному (модулю)
- •20.4 Ссылки на описания модуля
- •Пример создания модуля
- •Использование модулей. Режимы Compile, Build и Make при компиляции модулей
- •Косвенные и перекрестные ссылки на модули
- •Пример модуля (стек)
- •Модули и большие программы
Пример модуля (стек)
Рассмотрим пример построения модуля, объединяющего в себе средства работы со структурой данных "стек". В общем случае стек (магазин) работает по принципу "первым пришел - последним ушел" (LIFO), причем доступ к элементам стека возможен только через одно место - через т.н. голову стека, которая изменяет свое положение после каждой записи/чтения в/из стек/стека. В зависимости от реализации стек м.б. бесконечным (при реализации в виде динамической связанной структуры, где память выделяется и освобождается динамически - при выполнении программы/модуля) и конечным (при реализации в виде статической структуры - массива, для которой память выделяется только один раз - при компиляции программы).
Чаще всего стек используется в 2 случаях:
При интерпретации выражений, где до определенного момента операнды заталкиваются в стек.
При работе в таких ситуациях, где надо одновременно держать в памяти несколько поколений какого-то объекта, при этом доступен будет лишь самый «молодой» потомок. Пример – текстовые окна.
Пусть в стек надо записать последовательность символов a,b,c,.......
Обобщенный вид стека при выполнении действий:
Исходное состояние |
После записи а |
После записи b |
После записи с |
После чтения с |
||||||||||
голова |
|
голова |
a |
голова |
b |
голова |
c |
голова |
b |
|
||||
|
|
|
|
|
a |
|
b |
|
a |
|
||||
|
|
|
|
|
|
|
a |
|
|
|
||||
Реализация стека в виде динамически связанной структуры:
Голова Голова Голова
inf=a |
|
|
|
inf=a |
|
|
|
|
|
inf=a) |
link=nil |
|
link |
|
link=nil |
|
link |
|
link |
|
link=nil |
После записи a После записи b После записи c
Реализация в виде массива из 3-х элементов:
|
|
|
|
|
||||||||||
1 |
|
1 |
a |
1 |
b |
1 |
c |
1 |
b |
|
||||
2 |
|
2 |
|
2 |
a |
2 |
b |
2 |
a |
|
||||
|
|
3 |
|
3 |
|
3 |
a |
3 |
|
|
||||
Исходное состояние После записи a После записи b После записи c После чтения c
Мы будем в нашем примере реализовывать стек с помощью массива (массив, как известный Паскалю тип данных будет использован в качестве носителя для значений неизвестного Паскалю типа данных). При этом способ реализации скроем в секции реализации, так что в программе, использующей наш модуль, ничего не изменится при изменении реализации стека.
Замечания:
Голова стека будет указывать на ту ячейку, в которую должна выполняться текущая запись.
Условимся, что голова стека не может перескакивать за границу массива, т.е. значение головы стека должно быть не больше числа элементов массива.
Итак, модель стека пусть имеет следующий вид:
|
j – указатель на голову |
||
|
При записи (push) j:= j+1
|
При чтении (pop) j:= j-1 |
|
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
Const
n=10; {размер стека}
Var
j:byte; {голова стека}
s:array[1..10] of byte; {носитель}
FULL : boolean;{стек полон}
EMPTY: boolean; {стек пуст }
elem : byte; { то, что помещается в стек при Записи }
Исходное состояние (надо уставливать в секции инициализ.):
EMPTY:=true; FULL:=false; j:=1;
NB: Во всех случаях кроме того, когда стек полностью заполнен, j указывает на ячейку, в которую должна быть выполнена текущаязапись. Номер этой ячейки на единицу больше номера ячейки, из которой надо выполнять очередное считывание.
Запись |
Чтение |
то Записать_в_стек иначе writeln('Стек полон'); всё |
Если стек_не_пуст то Прочитать_из_стека иначе writeln ('Стек пуст'); всё |
s[j] := elem; {теперь стек не пуст} EMPTY:=false Если j < n то j := j+1; иначе FULL := true; {стек теперь полон} все
|
Если стек_не_полон то begin j := j-1 если j = 1 то EMPTY := t rue все end все {Чтение из j-й ячейки } elem := s[j]; {стек теперь не полон} FULL := false; |
т.к. характеристики
носителя и действия с ним скрыты в
секции реализации, то за пределами
модуля не будет видно, как мы реализовали
стек (как массив или как динамическую
структуру)
В секцию реализации
В основную программу
Unit stack;
Interface
Var elem:byte; {то, что считывается и записывается в стек}
Procedure push(elem:byte); Procedure pop(var elem:byte); |
Implementation
Const
Заголовок приведен без
списка параметров, потому что полный
заголовок приведён в интерфейсной
части Var j:byte; {голова стека} s:array[1..10] of byte; FULL : boolean;{стек полон} EMPTY: boolean; {стек пуст } Procedure push; Procedure push;{помещение эл-та в вершину стека. } begin if (not FULL) then {запись в стек}
begin s[j] := elem; EMPTY := false; if j < n then j := j+1 else
FULL
:= true; end
else Writeln(‘Стек полон’); end; Procedure pop(var elem:byte); {Чтение эл-та из стека} begin if not EMPTY then
begin if
(not FULL) then
j:=j-1; if
(j>1) then begin j:=j-1; if
j = 1 then
EMPTY := true; end; elem
:= s[j]; FULL
:= false; end
else Writeln(‘Стек пуст); end; |
begin { Инициализация }
j := 1; EMPTY := true; FULL := false; |
end.
Приведем программу, которая использует этот модуль. Она добавляет в стек три числа, потом одно удаляет и выводит на экран:
Program P;
uses
stack;
begin
push(1);
push(2);
push(3);
pop(elem);
writeln('Считанный элемент = ', elem);
end.

inf=b
inf=с
inf=b
Голова
Голова
Голова
Голова
Голова
3
Если
стек_ не_полон
{Запись
в j-ю ячейку}