Реферат: Основы программирования в паскале

Модуль CRT содержит подпрограммы управления текстовым выводом на экран дисплея, звуковым генератором и чтения с клавиатуры.

В режиме текстового вывода координаты экрана следующие: верхний левый угол <1,1>, нижний правый <WindMax>, причем горизонтальная координата возрастает слева направо, а вертикальная - сверху вниз. Если на экране активизировано окно, то все координаты определяются относительно границ окна, за исключением процедуры Window (здесь координаты всегда задаются относительно границ экрана).

Для чтения с клавиатуры используются две функции: KeyPressed и ReadKey. Функция KeyPressed определяет факт нажатия на любую клавишу и не приостанавливает дальнейшее исполнение программы. Функция ReadKey читает расширенный код нажатой клавиши и ожидает действий пользователя.

Управление звуковым генератором строится по схеме Sound - Delay - NoSound. Первая процедура включает генератор и генерирует звук нужного тона. Вторая - приостанавливает работу программы на заданное число миллисекунд реального времени. Третья - отключает звуковой генератор.

Black = 0; {черный}

Blue = 1; {голубой}

Green = 2; {зеленый}

Cyan = 3; {бирюзовый}

Red = 4; {красный}

Magenta = 5; {малиновый}

Brown = 6; {коричневый}

LightGray = 7; {светло-серый}

DarkGray = 8; {темно-серый}

LightBlue = 9; {светло-голубой}

LightGreen = 10; {светло-зеленый}

LightCyan = 11; {светло-бирюзовый}

LightRed = 12; {светло-красный}

LightMagenta = 13; {светло-малиновый}

Yellow = 14; {желтый}

White = 15; {белый}

Blink = 128; {бит мерцания}

CheckBreak: Boolean; { Реакция на Ctrl-Break }

CheckEOF: Boolean; { Реакция на Ctrl-Z - end of file}

DirectVideo: Boolean; { Разрешение/запрещение прямой работы с видеопамятью }

CheckSnow: Boolean; { Реакция на "снег" монитора }

LastMode: Word; { Хранение последнего текстового режима}

TextAttr: Byte; { Текущий текстовый атрибут}

WindMin: Word; { Координаты <X,Y> верхнего левого угла текущего окна }

WindMax: Word; { Координаты <X,Y> нижнего правого угла текущего окна }

procedure AssignCrt(var F: Text);

связывает с файловой переменной устройство ввода/вывода CRT.

function KeyPressed: Boolean;

возвращает значение True, если на клавиатуре была нажата любая клавиша.

function ReadKey: Char;

читает символ с клавиатуры без эхо повтора и приостанавливает исполнение программы до нажатия на любую клавишу, кроме Shift, Ctrl, Alt, CapsLock, NumLock, ScrollLock.

procedure TextMode(Mode: Integer);

устанавливает нужный текстовый режим.

procedure Window(X1,Y1,X2,Y2: Byte);

открывает текстовое окно на экране с абсолютными координатами <X1,Y2>, <X2,Y2>.

procedure GotoXY(X,Y: Byte);

перемещает курсор в нужное место <X,Y> активного окна.

function WhereX: Byte;

возвращает горизонтальную координату X текущего положения курсора в активном окне.

function WhereY: Byte;

то же для вертикальной координаты Y.

procedure ClrScr;

очищает окно и помещает курсор в левый верхний угол <1,1>.

procedure ClrEol;

удаляет все символы от текущей позиции курсора до конца строки без перемещения курсора.

procedure InsLine;

вставляет пустую строку в позицию курсора.

procedure DelLine;

удаляет строку, на которой находится курсор, и перемещает все строки, расположенные ниже нее, на строку вверх.

procedure TextColor(Color: Byte);

устанавливает цвет символов.

procedure TextBackground(Color: Byte);

устанавливает цвет фона.

procedure LowVideo;

устанавливает низкую яркость символов.

procedure HighVideo;

устанавливает высокую яркость символов.

procedure NormVideo;

устанавливает нормальную яркость символов.

procedure Delay(MS: Word);

приостанавливает работу программы на указанное число миллисекунд MS.

procedure Sound(Hz: Word);

включает звуковой генератор с указанной звуковой частотой Hz.

procedure NoSound;

выключает звуковой генератор.

87

  В кратком изложении история языков программирования такова: изначально вычислительные машины программировались в машинном коде. Тоесть в их оперативную память напрямую вводили последовательность чисел, являющиеся кодами команд, которые процессор может выполнить. При этом программа составлялась с периодическим заглядыванием в таблицу кодов команд процессора и была отнюдь не наглядной. Затем появилась идея обозначить коды какими-то короткими, но осмысленными, и потому легко запоминаемыми словами – мнемониками, и создать программу, которая бы, руководствуясь таблицей команд, переводила последовательность мнемоник – мнемокод в последовательность машинных кодов. Такую программу называют ассемблером (assembler - сборочное устройство, транслятор, ассемблер). Программы стали гораздо нагляднее, но решение практических задач требовало написания очень длинных программ (например, файловый менеджер Volkov Commander имеет размер около 64000 байт). Тогда появились языки программирования высокого уровня. При их создании использовали то обстоятельство, что в программе часто встречаются участки одинакового кода, выполняющие какое либо одно действие: вывод строки, запись в файл, вычисление математической функции и т.д. В языках высокого уровня таким последовательностям кода присвоены имена, и программа составляется на условном языке, каждое, из слов которого заменяет десятки, ато и сотни команд процессора. Таким образом, программа становится еще нагляднее и короче. Существует множество условных языков высокого уровня, для каждого из них написано немало вариантов пограммы, переводящей условный код в последовательность машинных команд. Один из таких языков – Паскаль.
  Язык программирования Pascal был разработан в 1968-1971 гг. Никлаусом Виртом в Цюрихском Институте информатики (Швейцария), и назван вчесть Блеза Паскаля – выдающегося математика, философа и физика 17-го века. Первоначальная цель разработки языка диктовалась необходимостью создания инструмента "для обучения программированию как систематической дисциплине". Однако очень скоро обнаружилась чрезвычайная эффективность языка Pascal в самых разнообразных приложениях, от решения небольших задач численного характера до разработки сложных программных систем - компиляторов, баз данных, операционных систем и т.п. К настоящему времени Pascal принадлежит к группе наиболее распространенных и популярных в мире языков программирования:

  существуют многочисленные реализации языка практически для всех машинных архитектур;

  разработаны десятки диалектов и проблемно-ориентированных расширений языка Pascal;

  обучение программированию и научно-технические публикации в значительной степени базируются на этом языке.

  Существует ряд объективных причин, обусловивших выдающийся успех языка Pascal. Среди них в первую очередь необходимо указать следующие:

  Язык в естественной и элегантной форме отразил важнейшие современные концепции технологии разработки программ:

развитая система типов,

ориентация на принципы структурного программирования,

поддержка процесса пошаговой разработки.

  Благодаря своей компактности, концептуальной целостности и ортогональности понятий, а также удачному первоначальному описанию, предложенному автором языка, Pascal оказался весьма легок для изучения и освоения. В противоположность громоздким многотомным описаниям таких языков, как PL/l, Cobol, FORTRAN, достаточно полное описание языка Pascal занимает около 30 страниц текста, а его синтаксические правила можно разместить на одной странице.

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

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

  Язык Pascal стандартизован во многих странах. В 1983 году был принят международный стандарт (ISO 7185:1983)

  Pascal является традиционным алгоритмическим языком программирования, продолжающим линию Algol-60. Это означает, что программа на языке Pascal представляет собой специально организованную последовательность шагов по преобразованию данных, приводящую к решению некоторой задачи. Это отличает Pascal от так называемых непроцедурных языков типа Prolog, по существу, представляющих собой формализмы для записи начальных условий некоторой задачи и синтезирующих решение посредством встроенных механизмов логического вывода.

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

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

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

  Паскаль – компилятор, тоесть, прежде чем начать испоолнение программы, Паскаль полностью прочитывает исходный текст, написанный программистом, и составляет последовательность машинных кодов, выполняющую те действия, которые описал программист в hqundmnl тексте. Эта последовательность сохраняется в файл с расширением “.EXE” и является самостоятельным исполняемым файлом, который может быть запущен сам по себе, уже без участия Паскаля и, даже, на другом компъютере, на котором Паскаль может быть не установлен.

  Прошло много времени с момента появления Паскаля на рынке программных продуктов, прежде чем он получил всеобщее признание. Признание программистов и простых пользователей пришло вследствие появления языка программирования Турбо Паскаль (ТП) -диалекта языка, созданного американской фирмой Борланд. Эта фирма объединила очень быстрый компилятор с редактором текста и добавила к стандартному Паскалю мощное расширение, что способствовало успеху первой версии этого языка.
  В 1985 году на рынке ПЭВМ появился язык программирования Турбо Паскаль (версия 3.0) с компилятором стандартного Паскаля. С тех пор Паскаль стал применяться в общеобразовательных, профессионально-технических школах и в сфере высшего образования в качестве "первого" языка программирования. Благодаря простоте использования язык Турбо Паскаль получил широкое распространение и в любительских кругах. Повышению популярности Турбо Паскаля способствовал набор небольших сопутствующих программ (т.н. Tools), позволяющих получать чрезвычайно компактную, быструю и легко читаемую программу.
  Эти качества Турбо Паскаля были высоко оценены и в среде профессиональных программистов. Встроенный редактор текста использует достаточно широко распространенную систему команд, берущую начало от пакета WordStar и хорошо знакомую каждому, кто интенсивно использует ПЭВМ.
  В появившемся со временем пакете Турбо Паскаль 4.0 было устранено большинство подвергавшихся критике ограничений компилятора и была повышена производительность системы. Кроме того, новый компилятор версии 4.0 имел существенные отличия от предыдущей версии. Наиболее важным нововведением была UNIT- концепция, заимствованная из языка Модула-2. Это дало возможность реализовать в рамках ТП разработку крупных программных продуктов.
  С выходом в свет версии 5.0 ТП получил еще большие шансы на благосклонную реакцию со стороны профессиональных пользователей благодаря встроенному в среду программирования интегрированному отладчику, который позволил повысить производительность труда.
  Существенно улучшила технические характеристики ТП реализация аппарата перекрытий (overlays), позволяющего строить мощные программные комплексы, рассчитанные на эксплуатацию в малых по объему областях памяти. Суть механизма перекрытий сводится к делению программы на части, поочередно загружаемые по мере необходимости с дискеты или магнитного диска (винчестера) в одну и ту же область памяти, заменяя при этом находившуюся там часть программы.
  Кроме того, в ТП 5.0 были расширены возможности отладки (debugging) программ и обеспечена возможность поддержки расширенной помята в стандарте Lotus-Intel-Microsoft (LIMS/EMS 4.0). Сокращение EMS обозначает Expanded Memory Specification (спецификация расширенной памяти). Нельзя путать этот вид дополнительной памяти с другим - Extended Memory (сокращенно - XMS). EMS имеется на обычных ПЭВМ класса ХТ, в то время как Extended Memory -только на машинах АТ-класса (с процессором 286, 386 и выше) при объеме памяти свыше 1 Мбайта.
  В этой версии были также исправлены и улучшены библиотеки графических процедур, поставляемые вместе с пакетом ТП. При этом обеспечивалась полная совместимость с графическими адаптерами класса VGA (Video Graphics Array).
  В рамках версии ТП 5.5 были осуществлены дальнейшие преобразования в направлении улучшения технических характеристик пакета. Наряду с внутренними улучшениями и новыми возможностями встроенной справочной системы Help и большим набором учебных примеров, важным нововведением явилась реализация в языке концепции объектно-ориентированного программирования (ООП).
  Через некоторое время на рынке появилась версия 6.0 ТП, в которой чисто теоретическая концепция объектно-ориентированного программирования была реализована практически с полным набором объектов, которые могли использоваться для решения прикладных задач пользователя. Кроме того, реализация системы меню приведена b соответствие со стандартом SAA (Turbo Vision). В качестве практического примера использования новых возможностей был реализован текстовый редактор, встроенный в IDE - Integrated Development Environment - интегрированную инструментальную оболочку. При этом сторонники программирования на ТП 6.0 получили возможность не только работать со встроенным многооконным текстовым редактором, но и использовать мышь, которая значительно облегчает работу пользователя.
  В 1992 году фирма Borland International представила пользователям очередную версию языка программирования Паскаль - Турбо Паскаль 7.0. Наряду со всеми преимуществами, которые ТП 7.0 унаследовал от предыдущей версии ТП (многооконный режим работы, возможность использования мыши, возможность использования при написании программ языка программирования низкого уровня Ассемблер или прямого ввода машинного кода, возможность создавать объектно- ориентированные программы), в нем были произведены изменения и улучшения:

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

  Язык программирования ТП 7.0 был расширен (появилась возможность использовать типизированный адресный оператор, открытые массивы и строки и т.д.), что предоставило пользователю дополнительные возможности при решении повседневных задач.

  Был улучшен компилятор, вследствие чего "коды программ" стали более эффективными.

  Был улучшен интерфейс пользователя. Кроме того, в ТП 7.0 расширены возможности объектно-ориентированного программирования (в частности, расширены и улучшены возможности Turbo Vision).

  Целью работы И. Вирта было создание языка, который

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

имел бы простой синтаксис,

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

  По природе своей компьютер может выполнять только простейшие операции, которые можно вводить одну за другой в его память прямо в машинных кодах. Изнурительная монотонность такой работы привела когда-то первых программистов к естественному решению - созданию Ассемблеров, т.е. средств, упрощающих подготовку машинных кодов программ пользователя за счет написания их в некоторых мнемонических обозначениях с последующим автоматическим переводом. Дальнейшее развитие этих идей привело к созданию языков программирования высокого уровня, в которых длинные и сложные, но часто применяемые последовательности машинных операций были заменены каждая одним-единственным обозначающими ее словом - оператором. В области малых ЭВМ среди языков программирования высокого уровня следует в первую очередь назвать БЕЙСИК. Программы, написанные на этом языке, к сожалению, часто содержат запутанные последовательности операторов, называемые иногда на жаргоне программистов блюдо спагетти.   Лингвистическая концепция Паскаля отрицает методы программирования, которые могут привести к подобным эффектам. В mei, напротив, пропагандируется системный подход, выражающийся, в частности, в расчленении крупных проблем на меньшие по сложности и размеру задачи, легче поддающиеся решению. Основные принципы Паскаля таковы:

  Структурное программирование. Суть его заключается в оформлении последовательностей команд как замкнутых функций или процедур и в объединении данных, связанных по смыслу, в сложные структуры данных. Благодаря этому повышается наглядность текста и упрощается его отладка.

  Проектирование сверху вниз. Программист разбивает свою задачу на несколько более простых, после чего каждая из задач решается по отдельности. Затем компонуются результаты проектирования простых задач и решается задача проектирования сверху вниз в целом.

  Объектно-ориентированное программирование делает следующий шаг от ремесла к науке программирования. Данные объединяются со свойственными им операциями обработки в некоторые объекты (Инкапсулирование). Например, данным "Человек" присуща операция "Идти". При этом свойства одних объектов могут передаваться другим, переноситься на другие классы объектов (Наследование). С другой стороны, в объектно-ориентированном программировании существует явление полиморфизма: часы тоже могут "Идти", но не ногами.

  Влияние Паскаля ощущается в настоящее время в разных языках программирования. Так, среди новых диалектов Бейсика есть Паскаль с символикой Бейсика. Даже в язык С встраивается все больше элементов, порожденных Паскаль-концепцией. Необходимо отметить, что все эти явления находятся в русле характерной для современных языков программирования тенденции к конвергенции.   Набор операторов стандартного Паскаля относительно мал и легко изучаем. Но это порождает проблему расширения языка в приложениях. В ТП эта проблема решается за счет поставок большого количества библиотек разнообразных процедур, готовых к употреблению в прикладных программах. Широкое распространение Паскаля привело к появлению на рынке программного обеспечения большого числа инструментальных и прикладных программ. Подобные программы разработаны для многих проблемных областей, однако задача их настройки в соответствии с требованиями пользователей продолжает оставаться достаточно важной.

  Язык программирования ТП 7.0, как и любой другой, имеет свой алфавит. Как правило, алфавитом языка программирования называют набор символов, разрешенный к использованию и воспринимаемый компилятором, с помощью которого могут быть образованы величины, выражения и операторы данного языка. Алфавит языка ТП 7.0 включает в себя все символы, представленные в кодировочной таблице, которая в настоящий момент загружена в оперативную память или хранится в ПЗУ Вашего компьютера. Каждому символу алфавита соответствует индивидуальный числовой код от 0 до 255.
  Примечание:
  Символы с кодами от 0 до 127 представляют собой так называемую основную таблицу кодов ASCII. Их состав и порядок определены американским стандартом на коды обмена информацией. Часть кодировочной таблицы с кодами от 0 до 127, т.е. "Основная таблица кодов ASCII, идентична на всех IBM-совместимых компьютерах.
Алфавит языка ТП 7.0 составляют:

Символы, используемые для составления идентификаторов:

латинские строчные и прописные буквы,

арабские цифры от 0 до 9 (в идентификаторах цифры могут использоваться наряду с буквами, начиная со второй позиции),

символ подчеркивания (ASCII, код 95).

Символы-разделители:

Символ пробела (ASCII, код 32). Как уже отмечалось, символ пробела является разделителем в языке ТП 7.0. Основное назначение этого символа - разделение ключевых слов и имен.

Управляющие символы (имеют ASCII-коды от 0 до 31). Эти символы могут применяться при описании строчных и символьных констант. Управляющие символы с ASCII-кодом 9 (табуляция), а также 10 и 13 (замыкающее строку) используются в качестве разделителей при написании программ на ТП 7.0.

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

A:=B+C-D;Write(A);

А := В + С - D; Write (A);

A:=

В+С

- в ; Write (А);

  Специальные символы - символы, выполняющие определенные функции при построении различных конструкций языка:
+ - * / { } [ ] ( ) < > . , ' : ; ^ @ # $

  Составные символы - группа символов, которые воспринимаются компилятором как единое целое:
<= => := (* *) (. .) ..

  "Неиспользуемые" символы.
Символы так называемой расширенной таблицы ASCII, т.е. символы, имеющие коды от 128 до 255 (в этой области находятся символы алфавита русского языка и символы псевдографики на IBM-совместимых компьютерах), а также некоторые символы из основной таблицы ASCII (например: (&), (!), (%), (-), (") и некоторые другие) не входят в алфавит языка, т.е. эти символы не используются в идентификаторах. Тем не менее, их можно использовать в тексте комментариев, а также в виде значений констант строк или констант символов.

  Зарезервированные слова.
ТП 7.0, как и его предшественники, включает в себя так называемые ключевые или зарезервированные слова (BEGIN, END, PROGRAM). В качестве имен идентификаторов в программе зарезервированные слова использоваться не могут. Если Вы будете использовать зарезервированные слова не по назначению, это вызовет ошибку при попытке откомпилировать программу.

  Программа на Паскале состоит из последовательности лексических единиц - лексем.
  Лексема - минимальная единица языка, имеющая самостоятельный смысл.
  В Паскале лексемы условно делятся на несколько классов:

идентификаторы;

числа без знака;

специальные знаки (слова-символы и специальные знаки);

символьные константы (строки),

директивы;

метки.

  Блок лексического анализа Паскаль-компилятора, рассматривая символы входного языка, должен определить, какому классу принадлежит лексема.   Между лексемами разрешено вставлять один и более разделителей. В качестве разделителей в стандарте Паскаля используются пробелы, комментарии, символы «конец строки». В Турбо-Паскале кроме этих в качестве разделителей разрешено использование и других символов.   Комментарии заключают в фигурные скобки. Вместо них также могут использоваться пары символов «b>(**)
  Примеры записи лексем:

12–А

12 - A+5

  В первом примере записаны три лексемы “12”, “-“, “А”, между которыми нет разделителей. Во втором примере между первой и второй лексемами, а также между второй и третьей использован разделитель пробел.

А{присвоить}:=1;

  Между лексемами “А” и “:=” в качестве разделителя использован комментарий.

А:{присвоить}=1

  Последний пример ошибочен, так как разделитель в виде комментария разрывает лексему ":=”.

  Идентификатор является именем, которое использует программист при обращении к какому-то значению. В качестве имен не могут быть использованы зарезервированные слова (слова-символы, например слово “PROGRAM”).   В стандартном Паскале идентификаторы используются для обозначения переменных, констант, типов, процедур и функций. Имена могут быть длинными, но при трансляции рассматривается ограниченное число символов (по стандарту Паскаля - первые восемь символов, тоесть идентификаторы “dlinniy_identifikator1” и “dlinniy_identifikator2” будут восприняты компилятором как одно и тоже слово).  В Турбо-Паскале идентификатор кроме символов букв и цифр может содержать символ “_” (подчеркивание). Подчеркивание полезно, когда имя состоит из нескольких осмысленных слов.   В общем случае следом за зарезервированным словом PROGRAM в программе стоит пробел, разделяющий в Паскале слова, и далее - имя, данное программе. Это имя представляет собой пример идентификатора. Идентификатор -имя, свободно избираемое программистом для элементов программы (процедур, функций, констант, переменных и типов данных). При обозначении какого-либо элемента программы с помощью идентификатора Вы должны руководствоваться следующими постулатами:

  Идентификатор должен начинаться буквой или символом подчеркивания “_”.

  ТП 7.0 не различает прописные и строчные буквы. Поэтому можно записать WriteLN, Writeln или даже wRITeLn, не опасаясь быть непонятым компилятором. Для него все три записи эквивалентны.

  Начиная со второй позиции, в идентификаторе можно применять наряду с буквами цифры

  Пробел в ТП 7.0 является разделителем и не может стоять внутри идентификатора. Для создания идентификаторов, состоящих из двух слов, можно воспользоваться большими буквами (например,

ReadText) или символом подчеркивания (Read_Text), но не пробелом (bRead Text – два отдельных слова).

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

  Зарезервированные слова (такие как BEGIN, END или PROGRAM) в качестве идентификаторов не используются.

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

  Кроме того, при написании программы рекомендуется следовать ряду правил хорошего тона, которые упрощают редактирование программы и повышают ее наглядность:

  Изобретая идентификаторы, старайтесь делать их "осмысленными", не экономьте на именах - имя ReadTest всегда лучше, чем RT. Не бойтесь потратить время на написание длинных идентификаторов. Встроенный в ИПО (Интегрированная Пользовательская Оболочка) редактор предоставляет возможность копировать и переносить фрагменты текста.

  Все структуры языка имеют англоязычные идентификаторы. Для своих элементов Вы можете изобрести русскоязычные идентификаторы (записанные латинскими литерами), например PROGRAM Privetstvie. Но для удобства, создавая идентификаторы, выполняйте не транслитерацию русских слов в английские, а перевод на английский язык (приветствие - welcome).

  В нашей учебной программе слово PROGRAM и последующий идентификатор представляют собой незаконченный оператор программы. Для правильного оформления его необходимо завершить символом точка с запятой (;). Таким образов завершается каждый оператор программы на языке Паскаль, за исключением последнего оператора END, после которого всегда ставится точка, тем самым информируя компилятор об окончании текста программы.

  Программы, написанные на языке программирования ТП 7.0, строятс в соответствии с правилами, представляющими собой несколько расширенные и "ослабленные" правила синтаксиса стандартного Паскаля. Но эти "ослабленные" правила (т.е. порядок размещения в тексте программы различных смысловых блоков) должны неукоснительно соблюдаться при написании программы.   Любую программу, написанную на ТП 7.0, можно условно разделить на три основные части:

раздел объявлений и соглашений (декларационная часть),

раздел текстов процедур и функций,

раздел основного блока (сама программа).

Раздел объявлений и соглашений.

PROGRAM Заголовок программы;

{$ ... } Глобальные директивы компилятора;

USES Подключаемые библиотеки;

LABEL Подраздел объявления глобальных меток;

CONST Подраздел объявления глобальных

констант;

TYPE Подраздел объявления глобальных типов;

VAR Подраздел объявления глобальных

переменных;

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

  В этом разделе записываются подпрограммы, осуществляющие сложные действия, которые необходимо произвести неоднократно на разных этапах выполнения программы. Подпограммы бывают двух типов: прjцедуры (PROCEDURE) и функции (FUNCTION). И те и другие пребставляют собой программы в миниатюре:

PROCEDURE (FUNCTION) Заголовок процедуры (функции);

LABEL Подраздел объявления локальных меток;

CONST Подраздел объявления локальных

констант;

TYPE Подраздел объявления локальных типов;

VAR Подраздел объявления локальных

переменных;

Раздел текстов подпрограмм.

BEGIN Основной блок процедуры или функции;

END;

Они могут иметь всетеже разделы, что и основная программа, в частности, раздел локальных процедур и функций, вызываемых только в педелах данной подпрограммы.

BEGIN {Основной блок программы}

{текст программы}

END.

  В этом разделе содержится смысловая часть программы.

  Со строкой заголовка Вы уже знакомы. Она состоит из зарезервированного слова PROGRAM и имени программы. В Турбо Паскале эта строка не обязательна, и ее можно без ущерба исключить. Но правила хорошего тона в программировании требуют задания некоторого имени программы, чтобы уже при первом знакомстве можно было получить хоть какую-нибудь информацию об ее назначении. Однако не стремитесь привести здесь всю известную Вам информацию о программе - для этих целей можно воспользоваться дополнительными комментариями. Обычно в заголовке достаточно указать имя и версию программы.   Следующее за оператором PROGRAM имя является идентификатором и обладает всеми его свойствами. В частности, внутри тела программы не могут быть объявлены объекты, имя которых совпадает с именем программы.

Глобальные директивы компилятора

  В этом разделе программы компилятору можно дать указания, определяющие режимы его работы при трансляции последующей программы. Эти указания оформляются в тексте программы как комментарии, начинающиеся парой символов “{$” и заканчивающиеся символом “}”. Такие указания могут содержать указания на включение в текст программы фрагментов других программ (из соответствующих файлов), информацию для отладчика или сведения о необходимости использования арифметического сопроцессора.
Оператор USES

  Оператор USES играет важную роль в подключении к тексту программы системных модулей из библиотек. В этом операторе Вы указываете компилятору, из какой библиотеки использует модули данная программа, чтобы компилятор выбрал соответствующие модули из этой библиотеки и включил их в текст программы. Понятия "библиотека", "модуль", "блок" составляют основу терминологии программирования на Паскале. Библиотека включает набор модулей, каждый из которых замкнут, имеет свое имя, компилируется отдельно и к нашей программе подключается уже как "черный ящик" с известным интерфейсом. Каждый модуль (блок (UNIT), как его называют на Паскале) представляет собой программу, включающую декларации типов и переменных, процедуры и функции.
  Оператор USES может быть использован в программе только один раз, при этом у него есть свое четко определенное место, (он предваряет все прочие операторы и разделы). Названия библиотек, подключаемых к программе с помощью оператора USES, должны разделяться запятой. Например:
  USES Crt, Graph, String, Overlay;
Объявления глобальных меток, констант, типов и переменных

  Следом за строкой, содержащей оператор USES, идут строки объявляющие:

  метки (LABEL) (хотя их использование противоречит классической технике программирования на Паскале, дающей превосходную стройность и однозначность понимания кода программы);

  константы (CONST);

  определенные пользователем типы данных (TYPE);

  переменные (VAR).

  В Турбо Паскале жесткое соблюдение именно такого порядка объявлений не требуется. В этом отношении данный диалект весьма "либерален". На практике в большинстве программ часть, заключающая в себе объявления глобальных объектов, непосредственно предшествует основному блоку программы.
  В разделе описания меток LABEL содержатся перечисленные через запятую имена меток переходов. Следует помнить, что имена меток переходов не должны дублировать друг друга. Имя метки перехода может представлять собой целое число (от 0 до 9999), строку символов или символьно-цифровую конструкцию. Например:
LABEL, 1, 5, 9999, h2, 4t32e, metka_l;

В разделе CONST содержатся определения констант, используемых в программе. Например:

CONST

Year=1995;

Month='Июль';

Day='Понедельник';

Примечание:

  Заметьте, что при присвоении значений константам вместо оператора присвоения “:=” используется просто знак равенства “=”. Тип константы определяется автоматически по виду значения, присваемового константе и не может быть сложным.
  Раздел описания типов TYPE позволяет программисту определить новый тип в программе. В данном разделе могут быть использованы ранее определенные в разделе CONST константы.
  В разделе описания глобальных переменных VAR содержится список переменных, используемых в программе, и определяется их тип. Например:

VAR

А, В, С: INTEGER; {Переменным А, В и С присваивается тип INTEGER}

DDT: REAL; {Переменной DDT присваивается тип REAL }

Примечание:

  Разделы LABEL, CONST, TYPE и VAR могут располагаться в произвольном месте программы. При этом каждый из этих разделов может встречаться в программе несколько раз или вообще не встречаться в ней.

  Непосредственно за заголовком программы следует основной блок программы, ограниченный операторами BEGIN и END.. Как уже говорилось, оператор END. указывает компилятору, что программа закончена, в отличие от операторов END;, которые завершают блоки, процедуры, модули и т.п.
  Текст, следующий за оператором END., игнорируется транслятором.

  Объем основного блока программы, написанной нами, невелик:

writeLn (' привет. Ваня !' );

writeLn;

Wlitelin(' Я надеюсь, что мы отлично');

WrlteLn (' сработаемся !');

  Оператор WriteLn (Write Line - записать строку) - представляет собой стандартную процедуру, с помощью которой можно вывести на экран или на другие носители и средства отображения информации текст и числа. Подробное истолкование применения этой процедуры в первом операторе программы может быть, например, таким: "Вывести (Write) строку символов (String) "Привет, Ваня!" на экран и перевести курсор на начало следующей строки (Line) экрана". Перевод курсора на начало следующей строки вызван окончанием Ln в имени процедуры. Существует также стандартная процедура Write для вывода информации на экран без перевода курсора. После выполнения оператора WriteLn последующий вывод приведет к выдаче информации в следующую строку экрана, а после оператора Write - в ту же строку, следом за уже выведенным текстом, пока хватит места, а затем вывод продолжится уже на следующей строке экрана. Оператор WriteLn; без параметров просто переведет курсор на начало следующей строки. Операторы WriteLn и Write присутствуют практически в каждой Паскаль-программе. Скобки, следующие за оператором, необходимы для задания параметров процедуры. Причем, компилятор не рассматривает слова "Привет" и "Ваня" как идентификаторы для каких-либо переменных, т.к. они стоят внутри фрагмента текста, ограниченного апострофами. Заканчивается этот оператор, как и любой другой, точкой с запятой.
  Еще одна характерная особенность Паскаль-программ - ступенчатая форма записи. Строки, относящиеся к одной конструкции или связанные по смыслу, записываются с одной и той же позиции. Строки, относящиеся к подчиненной конструкции, записываются правее ("глубже"), например, на две позиции, благодаря чему наглядно представляется структура программы. В длинных программах этот подход позволяет фиксировать соответствие пар операторов BEGIN - END. Редактор текста в ИПО поддерживает такую технологию оформления текстов программ: после нажатия клавиши [Enter] курсор переходит на следующую строку в ту позицию, с которой начинается текст в предыдущей, а клавиша [Backsрасе] из этого положения переводит курсор на конец предыдущей строки.
Примечание:

  Ступенчатое оформление программы преследует только "эстетические" цели и не влияет на эффективность работы компилятора или программы. Компилятор обрабатывает Паскаль- программы с любым расположением операторов: как разделенные построчно нажатием клавиши [Enter] при подготовке текста программы, так и записанные подряд в одну строку.

Например:

program hello; begin writeln('Привет, Ваня!'); writeln;

writeln('Я надеюсь, что мы отлично'); writeln ('

сработаемся!'); end.

  Однако "воспитанные" программисты не могут себе позволить оформлять программы подобным образом, ведь таже программа, записанная с табуляцией, читается гараздо легче:

program hello; {заголовок программы}

begin {начало сегмента команд программы}

writeln('Привет, Ваня!'); {вывод строки}

writeln; {перевод позиции курсора на строку ниже}

writeln('Я надеюсь, что мы отлично'); {вывод строки}

writeln('сработаемся!'); {вывод строки}

end. {конец программы}

  Вернемся еще раз к символу точка с запятой, завершающему каждый оператор. Наличие точки с запятой обязательно, т.к. этот символ показывает Паскаль-компилятору, где заканчивается один оператор и начинается следующий. Благодаря тому, что Паскаль - язык со "свободной формой записи", можно без опасений "растянуть" оператор на несколько строк. С помощью символа точка с запятой Вы сообщаете Паскаль-компилятору, какую часть текста программы следует рассматривать как цельный, неделимый фрагмент. Зарезервированное слово BEGIN, с которого начинаются блоки программы, не требует после себя символа точка с запятой.

  Тип переменной задает вид того значения, которое ей присваивается и правила, по которым операторы языка действуют с переменной, например:
 Если переменные A и B целочисленного типа, то программа:

A:=3.14;

B:=2.71;

WRITELN(A,’ ‘,B,’ ‘,A+B);

  Выведет на экран строку: “3.14 2.71 5.85”
  Если же они строкового типа, то программа:

A:=’3.14’;

B:=’2.71’;

WRITELN(A,’ ‘,B,’ ‘,A+B);

  Выведет: “3.14 2.71 3.142.71”, так как оператор сложения просто добавит строку B в конец строки A.
 В Паскале предопределены следующие простейшие типы переменных:

Тип константы определяется способом записи ее значения:

Const

C1=17;

C2=3.14;

C3='A';

C4=False;

C5=C2+C1;

Можно использовать выражения. Выражения должны в качестве операторов содержать только константы, в том числе ранее объявленные, а так же знаки математических операций, скобки и стандартные функции.

BYTE – целое число от 0 до 255, занимает одну ячейку памяти (байт).

BOOLEAN – логическое значение (байт, заполненный единицами, или нулями), true, или false.

WORD – целое число от 0 до 65535, занимает два байта.

INTEGER – целое число от –32768 до 32767, занимает два байта.

LONGINT – целое число от –2147483648 до 2147483647, занимает четыре байта.

REAL – число с дробной частью от 2.9*10-39.до 1.7*1038, может принимать и отрицательные значения, на экран выводится с точностью до 12-го знака после запятой, если результат какой либо операции с REAL меньше, чем 2.9*10-39, он трактуется как ноль. Переменная типа REAL занимает шесть байт.

DOUBLE - число с дробной частью от 5.0*10-324.до.1.7*10308, может принимать и отрицательные значения, на экран выводится с точностью до 16-го знака после запятой ,если результат какой либо операции с DOUBLE меньше, чем 5.0*10-324, он трактуется как ноль. Переменная типа DOUBLE занимает восемь байт.

CHAR – символ, буква, при отображении на экран выводится тот символ, код которого хранится в выводимой переменной типа CHAR, переменная занимает один байт.

STRING – строка символов, на экран выводится как строка символов, коды которых хранятся в последовательности байт, занимаемой выводимой переменной типа STRING; в памяти занимает от 1 до 256 байт – по количеству символов в строке, плюс один байт, в котором хранится длина самой строки. При обьявлении переменной строкового типа можно заранее указать ее длину в байтах – X:
  MyString:STRING[X];

При присвоении этой переменной строки длиннее X, присваиваемая строка будет обрезана с конца после X-того символа.
  Размер переменной типа STRING в памяти можно узнать следующим способом:
  Size:=SizeOf(MyString);

Функция SizeOf() возвращает размер, занимаемый переменной, служащей параметром. Параметром может служить и тип переменной; строка:
 Writeln(SizeOf(STRING));

Выведет на экран число 256, так как по умолчанию под все строки отводится по 256 байт.

  Кроме того, можно узнать, сколько символов в строке (индекс последнего непустого символа в строке):
 Size:=Ord(MyString[0]);

Используется ибращение к нулевому элементу (символу) строки, в котором хранится ее длина, но MyString[0] – значение типа CHAR, тоесть символ, код которого равен длине строки, нужный нам код – число возвращает функция Ord()Таким же образом можно обратиться к любому N – тому элементу строки:

MyChar:=MyString[N]; {MyChar:CHAR}

ARRAY[a..b,c..d,….] OF “тип элемента”; - массив некоторой размерности, содержащий элементы указанного типа. Диапазоны индексов для каждого измерения указываются парами чисел или констант, разделенных двумя точками, через запятую (a..b,c..d). После OF записывается тип элементов массива. В памяти массив занимает место, равное: (b-a)*(d-c)*..* SizeOf(“тип элемента”). Размер массива не может превосходить 65536 байт. Обращение к элементам массива происходит следующим образом:
X:=MyArray[a,b,c,..];
При этом переменная X должна быть того же типа, что и элементы массива или приводимого типа. Число индексов (a,b,c,..) должно быть равно числу обьявленных при описании измерений массива.

  В паскале существуют ограничения на присвоение значений одних переменных другим. Если переменные которую и которой присваивают одного типа, то никаких проблем не возникнет. Но если они разных типов, присвоение не всегда может быть произведено. Это связано стем, что при таком присвоении необходимо отсечь часть информации, а какую – компьютер “не знает”. Проблема возникает при следующих присвоениях:

I:=J; {I:INTEGER; J:REAL}

A:=B; {A:CHAR; B:STRING}

  В то же время, такие присвоения будут выполнены вполне корректно:

J:=I;

B:=A;

  При этом переменная J примет значение с нулевой дробной частью, а B – станет строкой, содержащей один символ – из A. В первом же случае, можно поизвести следующие операции:

I:=Trunc(J); {функция trunc() возвращает целую часть аргумента}

I:=Round(J); {round() – округляет аргумент стандартным способом}

  Кроме рассмотренного случая может существовать множество других, все не описать, но наиболее общее правило таково: следить за однозначностью присвоения с потерями информации и не удивляться, а экспериментировать переделывать программу, если компилятор выдает сообщение о невозможности присвоения.

  Составной оператор - это последовательность произвольных операторов программы, заключенная в операторные скобки.
  Турбо-Паскаль допускает произвольную глубину вложенности:

Begin

...

Begin

...

Begin

...

End;

End;

End;

Наличие ; перед End - пустой оператор.

IF <условие> THEN <оператор1> [ELSE <оператор2>]
  Условие – значение типа BOOLEAN или логическая операция. Если условие верно, выполняется оператор, или блок операторов, следующий за THEN, в противном случае выполняется блок операторов после ELSE, если он есть.
  Условия могут быть вложенными и в таком случае, любая встретившаяся часть ELSE соответствует ближайшей к ней "сверху" части THEN.
Пример:

Var

A, B, C, D: Integer;

begin

A:=1;

B:=2;

C:=3;

D:=4;

If A > B Then

If C < в Then

If C < 0 Then

C:=0 {обратите внимание, что перед Else пустой оператор ";"не ставится}

Else

A:=B;

end.

а могло быть и так:

If A > B Then

If C < в Then

If C < 0 Then

C:=0

Else

Else

Else A:=B

  Рассмотрим программу, которая вводит произвольное целое число от 0 до 15 и выводит его в шестнадцатеричной системе:

Program Hex;

Var

Ch: Char;

N: Integer;

Begin

Write ('N = ');

Readln(N);

If (N >= 0) And (N <= 15) Then

Begin

If N < 10 Then

Ch:= Chr(Ord('0')+N)

Else

Ch:=Chr(Ord('A')+N-10);

End

Else

Writeln('Ошибка');

End.

For <переменная цикла>:=<начальное значение> To(DownTo) <конечное значение> Do <блок операторов>

  Переменная должна быть целого или перечислимого типа. При исполнении цикла переменная цикла изменяется от начального до конечного значения с шагом 1. Если стоит to, то переменная увеличивается, если downto – уменьшается.
  Условия выполнения цикла проверяются перед выполнением блока операторов. Если условие не выполнено, цикл For не выполняется.   Следующая программа подсчитывает сумму чисел от 1 до введенного:

Program Summa;

Var

I, N, S: Integer;

Begin

Write('N = ');

Readln(N);

S:=0;

For I:=1 To N Do

S:=S + I;

Writeln ('Cумма = ', S)

End.

While <условие> Do <блок операторов>

  Блок операторов будет исполняться, пока условие имеет значение true. Необходимо, чтобы значение условия имело возможность изменения при исполнении блока операторов, иначе исполнение цикла не закончится никогда (в DOS это приведет к зависанию компыютера). Если условие зарание ложно, блок операторов не исполнится ни разу.
  Найдем машинное "эпсилон" для переменной типа Real:

Program Epsilondetect;

Var

Epsilon: Real;

Begin

Epsilon:=1;

While Epsilon + 1 > 1 Do

Epsilon: = Epsilon/2;

Writeln ('Эпсилон = ', Epsilon);

End.

Repeat <тело цикла> Until <условие>

  Блок операторов независимо от значения условия будет выполнен хотябы один раз. Цикл заканчивается, если после очередного исполнения блока операторов условие имеет значение true.
  Пример: программа запрашивает ввод одного символа и выводит его ASCII - код, пока не будет введен пустой символ:

Program Code;

Const

Cr = 13;

Var

Ch:Char;

Begin

Repeat

Readln (Ch);

Writeln (Ch,' = ', Ord (Ch));

Until Ord (Ch) = Cr

End.

Case <ключ выбора> Of <список выбора> Else <оператор> End;
 <ключ выбора> - выражение любого перечислимого типа,
 <список выбора> - одна или более конструкций вида <значение ключа>:<блок операторов>.

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

2 2

*

  Признаком конца работы служит ввод любого символа, отличного от +, -, /, *.
  Программа:

Program Calc;

Var

Operation: Char; {Знак Операции}

X, Y, Z: Real;

Stop: Boolean;

Begin

Stop:= False;

repeat

Writeln; {Пустая Строка - Разделитель}

Write ('X, Y = ');

Readln (X,Y);

Write ('Операция: ');

Readln (Operation);

Case Operation Of

'+': Z: = X+Y;

'-': Z: = X-Y;

'*': Z: = X*Y;

'/': Z: = X/Y;

Else

Stop:= True;

End;

If Not Stop Then

Writeln('Z = ',Z);

Until Stop;

End.

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

Goto <метка>

  Метка, должна быть описана в разделе описаний. Метка, описанная в процедуре (функции) локализуется в ней, поэтому передача управления извне процедуры (функции) на метку внутри нее невозможна.

  Ранее рассматривались простые стандартные типы данных (Integer, Boolean,Char ...) - порядковые типы то есть к переменным этих типов применимы Succ и Pred. Real - не порядковый тип.

  В Паскале разрешено введение новых типов. Секция Type располагается между секцией констант и секцией переменных. Введение своих типов повышает "читабельность" программ.
Например: Месяцы.

Type

Month = (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);

Var

M: Month;

  Максимальная мощность перечисляемого типа - 256 значений, поэтому перечисляемый тип фактически задаёт подмножество типа Byte.
  В Паскале отсутствуют средства, которые бы позволяли осуществить непосредственный ввод - вывод переменных перечисляемого типа, однако можно вывести код: Write(Ord(M)).
  Кроме того применимы операции сравнения:

If (M > FEB) And (M < JUN) Then

Write ('Весенний месяц');

 Следует иметь ввиду, что упорядоченность элементов перечисляемого типа определяется порядком их следования. Самый левый элемент имеет минимальное значение, правый - максимальное.
  Пример:

  процедура, в которой переменной перечисляемого типа присваивается значение, в зависимости от введенного дня недели; если введённые символы ошибочны, возвращается соответствующее сообщение.

Program DAY (Input, Output);

Type

DayOfWeek = (Sun, Mon, Tue, Wen, Thu, Fri, Sat);

Var

D: DayOfWeek;

Well: Boolean;

Procedure Read_WD (Var I: DayOfWeek;Well: Boolean;);

Var

C: Char;

Begin

Read(C);

Well:= False;

Case C Of

"S": Begin

Readln(C);

Case C Of

"U": Begin

I:= Sun;

Well:= True;

End;

"A": Begin

I:= Sat;

Well:= True;

End;

End;{Of Case}

"M": Begin

Well:= True;

I:= Mon;

End;

"T": Begin Readln(C);

Case C Of

. . . . . . . . .

End;

"W": Begin

Well:= True;

I:= Wen;

End;

"F": Begin

Well:= True;

I:= Fri;

End;

End;

End;

Begin

Read_WD(D, Well);

If Not Well Then

Writeln ('Ошибка');

End.

  Кроме перечисленного типа можно вводить ограниченные или интервальные типы.
  Пример:

Type

Year = 1900..2000;

Letter = "A".."Z";

  Левая и правая константы задают диапазон значений и их называют соответственно верхней и нижней границей ограниченного типа.
  Константы в определении ограниченного типа должны относиться к одному и тому же базовому типу (целому, символьному, порядковому). Базовый тип констант определяет допустимость операций над данными ограниченного типа.
  Пример:

Type

Days = (Mo, Tu, We, Th, Fr, Sa, Su);

WeekEnd = Sa..Su;

Var

W: WeekEnd;

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

Begin

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

W:= Sa;

. . . . . . . . . . . ,

  Так как тип-диапазон наследует все свойства базового типа, но с ограничениями, связанными с его меньшей мощностью, то Ord(W) вернёт значения S , в то время как Pred(W) приведёт к ошибке.
  И перечисляемый и ограниченный типы относят к простому типу.
  Простой тип - это такой тип, который в некоторый момент времени хранит только одно значение.
 Структурированные типы данных - совокупность связанных данных и множество правил, определяющих, как их организацию так и способ доступа к элементам данных.
  Массив - это упорядоченный набор переменных одного типа.
  Массив содержит фиксированное число компонент, которое задаётся при определении переменных типа массива. Тип компоненты массива может быть любым. Каждый элемент масива имеет свой индекс. Тип индекса - простой, поэтому все элементы массива могут быть перебраны при помощи операторов цикла.
  Описание массивов:

Var

Mas: Array [1..15] Of Real.

Work: Array [(Mon, Tue, Wed)] Of Integer.

B: Array ['A'..'Z'] Of Boolean.

C: Array [1..3, 1..5] Of Real.

D: Array [(Black, White)] Of 11..20.

 В Паскале многомерный массив можно описать как одномерный:

Type

Mas = Array [1..3] Of Array [1..5] Of Integer;

Var

A, B: Mas;

C: Array [1..3, 1..5] Of Integer; {такая же структура но определена как двумерный массив}

 Ссылка на элемент матрицы А, лежащий на пересечении I-той строки и J-ого столбца выглядит следующим образом A [I] [J]; законно и такое обращение A[2]:= B[1], для массива такая запись не верна. Все элементы структурированных типов допускают A:= B (исключение - переменные файлового типа).
 Можно использовать комформант - массивы. Массивы с переменными границами в Турбо-Паскале использовать нельзя. Нельзя, также и сравнивать массивы:
If A = B Then ...
 В Турбо-Паскале предварительно определены два массива Mem и Port.

  Переменную типа Packed Array [0..N] of Char принято называть символьной строкой.
 Строка - это упакованный массив, компоненты которого имеют тип Char и тип индекса имеет нижнюю границу равную одному. К строкам применимы все 6 операций отношений, но строки при этом должны иметь равную длину.
 В Турбо-Паскале введён тип данных String вместо описанного Packed Array of Char.
 Операции с Char:

'5' < '25' {ошибка, так как разные длины строк}

'Var' = 'Var' {верно}

Var

Age: String [3];

Begin

Age:="тринадцать"; {Лишние символы после "и" усекаются}

  Паскаль позволяет оперировать с множествами как с типами данных.
Пример:

Type

Symbolset = Set Of ' ' .. '_';

Color = (White, Blue, Red);

Colorset = Set Of Color;

T1= Set Of 0..9;

Var

C: Color;

Colset: Colorset;

T: Integer;

Tset: T1;

  Множества - наборы однотипных объектов, каким-либо образом связанных между собой. Характер связей лишь подразумевается программистом и никак не контролируется Турбо-Паскалем. Максимальное количество элементов множества - 256.
  Два множества считаются эквивалентными тогда и только тогда, когда все элементы их одинаковы, причём порядок следования элементов безразличен.
Описание:
<имя типа> = Set Of <базовый тип>, где <базовый тип> есть любой порядковый тип кроме Word, Integer, Longint. Для задания множества используется конструктор множества (((: : =))). Список спецификаций элементов множества, отделяемых друг от друга запятыми; список обрамляется [ ]. Спецификациями элементов могут быть константы или выражения базового типа, а так же тип - диапазон того же базового типа:

Type

Digitchar = Set Of '0'..'9';

Digit =Set Of 0..9;

Var

S1, S2, S3: Digitchar;

S4, S5, S6: Digit;

begin

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

S1 : = ['1', '2', '3'];

S2 : = ['3', '2', '1'];

S3 : = ['2', '3'];

S4 : = [0..3, 6];

S5 : = [4, 5];

S6 : = [3..9];

Операции над множествами:
* - пересечение (S4*S6 = [3,6]; S4*S5 = [4])
+ - объединение (S4+S5 = [0, 1, 2, 3, 4, 5, 6])
- -разность, содержит элементы из 1-го, которые не принадлежат второму (S6-S5 = [3, 6, 7, 8, 9])
= - проверка эквивалентности (S4=S4 = true; S5=S4 = false)
<> - проверка неэквивалентности (S4<>S4 = false; S5<>S4 = true)
<= - проверка вхождения (True если 1-е содержится во втором).
>= - (наоборот).
in - проверка принадлежности.
 Пример:
Алгоритм получение простых чисел.

Const

N = 100;

Type

Set_Of_Num = Set Of 1..N;

Var

N1, Next, I: Word;

Begset, Primerset: Set_Of_Num;

Begin

Begset:= [2..N];

Primerset:= [1];

Next:=2;

While Begset <> [ ] Do

Begin

N1:= Next;

While N1 <= N Do

Begin

Begset:= Begset - [N1];

N1:= N1 + Next;

End;

Primerset:= Primerset + [Next];

Repeat

Inc(Next);

Until (Next In Begset) Or (Next > N);

End;

For I:=1 To N Do

If I In Primerset Then

Write(I: 8);

Writeln;

End.

 Итак, над множествами допустимы четыре операции:

объединение (+)

пересечение (*)

разность (-) (содержит элементы из 1-го, которых нет во 2-ом).

операция in - позволяет определить, принадлежит элемент множеству или нет.

  В программе множество задаётся в виде списка элементов, заключённого в квадратные скобки:

Colset:= [White, Red];

Colset:= [ ];

Tset:= [1, 7, 5];

Tset:= [0 ... 3, 6, 9];

Tset:= [8 Mod4, 15 Div 5];

 Можно использовать операции сравнения.
 Пример: из файла вводится текст, содержащий символы от "+" до "[". Требуется рассчитать символы текста в порядке кода ASCII (из повторно встречающихся выводить только один):

Program Sort

Var

S: Char;

Sets: Set Of '+'..'[';

I: '+'..'[';

Begin

Sets:= [ ];

Read(S);

While Not Eof Do

Begin

While Not Eof Do

Begin

Sets: = Seets + [S];

Read(S);

End;

End;

Writeln;

For I: ='+' To '[' Do

If I In Sets Then

Write (I);

Writeln;

End.

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

Type

Date = Record

Year: Integer;

Month: 1..12;

Day: 1..31;

End;

Book = Record

Title: String [40];

Author: String [50];

Entry: Date;

End;

Var

D1: Date;

B: Book;

 В Паскале разрешено использовать массивы записей. Записи также можно использовать в качестве компонент файлов. Однако поля записи не могут быть файлового типа. Чтобы обратиться к отдельной компоненте записи необходимо задать имя записи, за ним точку и сразу за точкой написать название нужного поля.
Пример1:
  D1.Day:=25;
  B.Author:= "Levy";
  B.Entry.Year:= 1980;
а можно и
  B. Entry: = 1980; так как Year первое поле Date.
Пример2: В памяти находится массив из 1000 элементов, каждый из которых имеет тип записи Book. Определить количество книг, год издания которых меньше или равен 1600 году. Для каждого из таких элементов массива распечатать название книги, имя автора, год издания:

Program Rarity;

Type

Date = Record

. . . . . . . . . . .

End;

Book = Record

. . . . . . . . . . .

End;

Var

S, I: Integer;

Mas: Array[1..1000] Of Book;

Begin

S:= 0;

For I:= 1 To 1000 Do

If Mas[I].Entry.Year <= 1600 Then

Begin

Write (Mas[I].Title,' , ',Mas[I].Author,',' , ',Mas[I].Entry.Year: 6);

S:= S+1;

End;

Writeln ('Число Книг' , S: 4);

End.

Оператор присоединения With.

 Можно сократить длинные обозначения элементов записи:
With имя записи Do оператор.
 Оператор With открывает область действия, содержащую имена полей указанной переменной типа записи так, что эти имена фигурируют в качестве имён переменных. Кроме экономии места при написании программ, оператор With экономит так же время при выполнении программы, так как ссылка на запись подготавливается только один раз.
Пример:

With B Do

Begin

Title: = ' ... ';

Author:= ' ... ';

End;

эквивалентно

B.Title: = ' ... ';

B.Author:= ' ... ';

  Вариантная часть начинается со слова Case. Это означает, что в записях можно задавать тип, содержащий определения нескольких вариантов структуры. Различие может касаться как числа компонент, так и их типов. Запись может содержать только одну вариантную часть (экономия памяти). Вариантная часть сама может содержать варианты (вложения).
Пример:

Type

N = String [20];

Status = (Женат, Вдов, Разведён, Холост);

Date = Record

Mo: 1..12;

Day: 1..31;

Year: Integer;

End;

Person = Record

Name: N;

Sex: (Муж, Жена);

Birth: Date;

Case Ms: Status Of

Женат, Вдов: (MDate: Date);

Разведён: (Date: Date; First: Boolean);

Холост: (Indept: Boolean);

End.

  Замечательная особенность - наложение в памяти вариантных полей, то есть дополнительная возможность преобразования типов:

Var

M = Record

Case Byte Of

0: (By: Array[0..3] Of Byte);

1: (Wo: Array[0..3] Of Word);

2: (Lo: Longint);

End;

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

With M Do

Begin

Lo: . . . . . .;

If By [3] = 2 Then ... ;

 Case Of, открывающее вариантную часть не имеет ничего общего с ветвлением Case Of; в данном случае это директива компилятору, сигнализирующая о том, что последующие поля нужно разместить начиная с одной и той же ячейки памяти, поэтому, если изменяется одно из полей - вариантов, изменяются и все остальные. Поле выбора должно быть порядкового типа.
  В Турбо-Паскале, в отличие от классики, переменной, описанной в поле ключа выбора, можно присваивать значения, но это ни как не влияет на выбор поля. Значения констант выбора могут быть произвольными и даже повторяющимися. Вместо поля выбора можно иставить лишь идентификатор какого - либо типа, но в таком случае в программе невозможно будет узнать, каким из альтернативных полей используется память, а значит и то, значение какого типа там лежит, но это не всегда и нужно.
Пример:

Type

Rec1 = Record

A: Byte;

B: Word;

End;

Rec2 = Record

C: Longint;

Case X: Byte Of

1: (D: Word);

2: (E: Record);

Case Boolean Of

3: (F: Rec1);

3: (G: Single);

'3': (C: Word);

End;

End;

Var

2: Rec2

. . . . . . . . . .

R.X: = 255;

If R.E.G = 0 Then

Writeln (0K)

Else

Writeln (R.E.G);

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

  Турбо-Паскаль - типизированный язык, следовательно, все применяемые операции определены только над операндами совместимых типов.
  Два типа считаются совместимыми, если

оба они есть один и тотже тип.

один тип есть тип-диапазон второго типа.

оба они являются типами-диапазонами одного и того же базового типа.

один тип есть строка, а другой - строка или символ.

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

  В Турбо-Паскалевской программе данные одного типа могут преобразовываться в данные другого, явным или неявным образом.
  При явном преобразовании используются специальные функции Ord, Trunc, Round, Chr, Ptr (преобразует четырёхбайтный целочисленный аргумент к типу-указателю).
  Преобразование может достигаться применением идентификатора (имени) стандартного типа, или определённого пользователем типа, в качестве идентификатора функции преобразования к выражению преобразуемого типа (так называемое автоопределённое преобразование типов). Например, допустимы следующие вызовы функций:

Type Mytype = (A, B, C, D);

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

Mytype (2);

Integer (D);

Pointer (Longint (A) + $FF);

Char (127 Mod C);

Byte (K);

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

Type

Byt = Array [1..2] Of Byte;

Int = Array [1..2] Of Integer;

Rec = Record

X: Integer;

Y: Integer;

End;

Var

VByt: Byt;

VInt: Int;

VRec: Rec;

Begin

Byt (VInt[1])[2]:= 0;

Int (VRec)[1]:= 256;

End.

  Неявное преобразование типов возможно только в двух случаях:

выражение из целых и вещественных приводится к вещественным

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

  Совмещение данных может произойти при использовании записей с вариантами, типизированных указателей, содержащих одинаковый адрес, а также при явном размещении данных разного типа в одной области памяти (используется Absolute - за ним помещается либо абсолютный адрес, либо идентификатор ранее определённой переменной).
  Абсолютный адрес - пара чисел, разделённых двоеточием - первое - сегмент, второе - смещение.
Пример:
  B: Byte Absolute $0000:$0055;
  W: Longint Absolute 128:0;
  Если за Absolute указан идентификатор переменной, то происходит совмещение в памяти данных разного типа, причём первые байты внутреннего представления данных будут располагаться по одному и тому же абсолютному адресу:

Var

X: Real;

Y: Array [1..3] Of Integer Absolute X;

 Описываются в разделе констант:
  <идентификатор> : <тип> = < значение >
  В ходе выполнения программы можно присваивать другие значения. При повторном входе в блок (процедуру или функцию), в котором объявлена типизированная константа, переинициализации не происходит и она сохраняет то значение, которое имела при выходе из блока. Могут быть любого типа, кроме файлов. Нельзя так же объявить типизированную константу-запись, если хотя бы одно её поле файлового типа. Нельзя использовать в качестве значения при объявлении других констант или границ типа-диапазона.
Примеры:

Типизированные константы простых типов и типа String:

Type

Colors = (White, Red, Black);

Const

{Правильные объявления}

Cyrrcol: Colrs = Red;

Name: String = 'Ку-Ку';

Year: Word = 1989;

X: Real = 0.1;

Min: Integer = 0;

Max: Integer = 10;

Days: 1..31 = 1;

Answer: Char = 'Y';

{Неправильные объявления}

Mars: Arrray [Min..Max] Of Real;

A,B,C: Byte = 0;

X: Real = Pi;

Var

Namef: String [22] = 'Prog.Pas';

Типизированные константы-массивы
  В качестве начального значения используется список констант, отделённых друг от друга запятыми, список заключается в круглые скобки:

Type

Colors = (White, Red, Black);

Const

Colstr: Arrray [Colors] Of String [5] = ('White', 'Red', 'Black');

Vector: Array [1..5] Of Byte = (0, 0, 0, 0, 0);

  При объявлении массива символов можно использовать то обстоятельство, что все символьные массивы и строки в Турбо- Паскале хранятся в упакованном формате,.поэтому в качестве значения массива-константы типа Char допускается указывать символьную строку:

Const

Digit: Array [0..9] Of Char = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9');

Digchr: Aray [0..9] Of Char = ('0123456789');

  При объявлении многомерных - множество констант, соответствующее каждому измерению заключается в дополнительные круглые скобки и отделяется от соседей множества запятыми.
  Множество констант с максимальной глубиной вложения связывается с изменением самого правого индекса массива.
  Пример - вывести на экран три строки с монотонно увеличивающимися целыми числами:

Var

I, J, K, L: Integer;

Const

Matr: Array [1..3, 1..5] Of Byte = ((0, 1, 2, 3, 4), (5, 6, 7, 8, 9), (10, 11, 12, 13, 14));

Cube: Array [0..1, 0..1. 0..2] Of Integer = (((0, 1, 2),(3, 4, 5)), ((6, 7, 8),(9, 10, 11)));

Mas4: Array [0..1, 0..1, 0..1, 0..1] Of Word = ((((0, 1), (2, 3)), ((4, 5), (6, 7))), (((8, 9), (10, 11)), ((12, 13), (14, 15))));

Begin

{Циклы и Writeln}

End.

  Количество переменных в списке констант должно строго соответствовать объявленной длине массива по каждому измерению.

  Типизированные константы-записи.
  <идентификатор>:<тип> = (<список значений полей>)
  <тип> - предварительно объявленный тип записи.
  <список значений полей > - список из последовательностей следующего вида: имя поля, двоеточие и константа; элементы списка отделятся друг от друга точкой с запятой.
Пример:

Type

Point = Record

X,Y: Real;

End;

Vect = Array [0..1] Of Point;

Month = (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);

Date = Record

D: 1..31;

M: Month;

Y: 1900..1999;

End;

Const

Orign: Point = (X: 0; Y: -1);

Line: Vector = ((X: -3.1; Y: 1.5), (X: 5.9; Y: 3.0));

Someday: Date = (D: 16; M: Mar; Y: 1989);

  Для записей с вариантными полями указывается только один из возможных вариантов констант:

Type

Forma = Record

Case Boolean Of

True:

(Place: String [40]);

False:

(Country: String [20];

Port: String [20];

Date: Array[1..3] Of Word;

Count: Word)

End;

Const

Con1: Forma = (Country: 'Россия';

Port: 'Москва';

Date: (16,3,89);

Count: 10);

Con2: Forma = (Place: 'Петрозаводск');

  Типизированные константы множества.
  Значение типизированной константы множества задаётся в виде правильного конструктора множества:

Type

Days = Set Of 1..31;

Dige = Set Of '0'..'9';

Error = Set Of 1..24;

Const

Workdays: Days = [1..5, 8..12, 15..19, 22..26, 29, 30];

Evendigits: Dige = ['0', '2', '4', '6', '8'];

Errorflag: Error = [ ];

Типизированные константы указатели.
  Единственным значением типизированной константы указателя может быть только Nil:

Const

Pr: ^Real = Nil;

P: POINTER = Nil;

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

  Структура подпрограммы в Турбо-Паскале почти буквально повторяет структуру всей программы, и в общем случае состоит из 3-х основных компонент:

  Интерфейс подпрограммы (информация, необходимая для её вызова). Сосредоточен в заголовке.

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

  Собственно действия, составляющие смысл подпрограммы (последовательность операторов и вызовов подпрограмм, тоесть программа на Паскале).

  Процедуры и функции различаются назначением и способом использования.
  Процедуры служат для задания совокупности действий, направленных на изменение внешней по отношению к ним программной обстановки. Или по-человечески, процедура, это подпрограмма, которая обрабатывает данные, принимает или выводит информацию, меняет или нет каким-либо образом глобальные и локальные переменные, вообще что-то делает.
  Смысл функций - определить алгоритм вычисления нового значения некоторого простого или ссылочного типа. Функция, это подпрограмма, которая, как и процедура, что-то делает, но, помимо этого, она обязательно возвращает значение, тип которого задается при описании заголовка процедуры. Вызов функции является одним из допустимых операндов выражения, обозначая в нём то значение, которое вычисляет функция, тоесть, если подпрограмма с идентификатором “Function1” – функция, то можно произвести следующие действия:
  X:=Function1(“параметры – аргументы функции”);
  X:=2*Function1(a,e,…,m,…)-1/Function1(c,f,…,k,…); и т.д.

  Имена объектов, описанных в некотором блоке, считаются известными в пределах данного блока, включая и все вложенные блоки.

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

  Если в некотором блоке описан объект, имя которого совпадает с именем объекта, описанного в объемлющем блоке, то последнее становится недоступным в данном блоке (экранировка).

Пример:

Program X;

Var

I,j:integer;

z:real;

Procedure x1(i:integer;);

Var

j:integer;

begin

End;

Begin

End;

Procedure x2;

Var

z:integer;

Procedure x3(z:string);

Begin

End;

Function y4(z:string):integer;

Begin

End;

Begin

End;

Begin

End.

  Приведенная ниже диаграмма показывает видимость идентификаторов в примере. Каждый идентификатор виден в пределах того прямоуголльника, в котором он описан и в прямоугольниках, содержащихся в данном. За пределами этого прямоугольника идентификатор либо неизвестен, либо имеет другое значение, тип. Так, например, функция y4 может быть вызвана лишь внутри процедур x2 и x3, аналогично и x3. Переменные z в теле пограммы и в каждой из x2, x3, y4 имеют абсолытно разные и независимые значения, а в x1 видима таже z, что и в теле программы.В тоже время переменные i и j перекрыты в x1 новыми определениями, а в x2, x3, y4, они те же, что и в основной программе.

  В заголовке подпрограммы может быть задан список формальных параметров. Каждый параметр, заданный в заголовке, считается локальным в данной подпрограмме.
  Идентификаторы формальных параметров можно считать условными обозначениями реальных (фактических) параметров, которые будут переданы в подпрограмму при её вызове.
Внимание:

  Типы формальных параметров должны обязательно обозначаться идентификаторами.

Недопустимо: Procedure InCorrect (Var A: Array [1..10] of Byte);

Нужно: Type

MyArray = Array [1..10] of Byte;

Procedure Correct (Var A: MyArray);

  Допустимы по крайней мере три способа задания формальных параметров:

  параметры, перед которыми отсутствует служебное слово Var и за которыми следует идентификатор типа;

параметр, перед которым Var и далее тип;

параметр со словом Var и не имеющие типа.

  Эти три способа задания формальных параметров отражают три различных способа передачи параметров a - по значению; b - по ссылке; c - передача нетипизированных параметров по ссылке (b, c - параметры-переменные).

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

  Передаются по ссылке. Способ используется, когда необходимо передать некоторое значение в точку вызова подпрограммы.
  В случае Var - формальные параметры считаются синонимами соответствующих фактических параметров.
  При этом фактические параметры должны быть переменными (не выражениями) того же типа, что и формальные параметры:

Procedure Swap (Var X,Y: Real);

Var

T: Real;

Begin

T:= X;

X:= Y;

Y:= T;

End;

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

  Var Ident, где Ident - идентификатор формального параметра.
  Фактический параметр, соответствующий формальному нетипизированному, должен представлять собой переменную любого типа (но не выражение).
  Единственным способом использования таких параметров является “наделение” их определённым типом.
Существуют два способа:

Применить операцию приведения типа.

Описать в подпрограмме локальную переменную определённого типа с совмещением её в памяти с нетипизированным параметром.

  Пример1: функция для сравнения значений двух переменных любых типов и, соответственно, любых размеров:

Function Equal (Var Source, Dest; Size: Word): Boolean;

Type

Bytes = Array [0..MaxInt] of Byte;

Var

N: Integer;

Begin

N:= 0;

While (N < Size) and (Bytes(Dest)[N] - Bytes(Source)[N]) do

N:=N+1;

Equal:= (N = Size);

End;

{Имеются описания:}

Type

Vector = Array [1..10] of Integer;

Point = Record

X,Y: Integer;

End;

Var

Vec1, Vec2: Vector;

N: Integer;

P: Pointer;

Begin

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

Equal(Vec1, Vec2, SizeOf(Vector)); {сравниваются все элементы Vec1 c Vec2}

Equal(Vec1, Vec2, SizeOf(Integer)*N); {сравниваются N первых элементов Vec1 и Vec2}

Equal(Vec1[1], Vec2[6], SizeOf(Integer)*5); {сравниваются 5 первых элементов Vec1 c пятью последними Vec2}

Equal(Vec1[1], P, 4); {сравнивает Vec1[1] c P.x и Vec2 с P.y}

  Пример2: задание различных действий в зависимости от размера переданного нетипизированногопараметра:

Procedure Size (Var X);

Var

V1: Byte absolute X;

V2: Word absolute X;

V3: LongInt absolute X;

Begin

Case SizeOf(X) of

SizeOf(Byte):

Begin

. . V1 . .

End;

SizeOf(Word):

Begin

. . V2 . .

End;

SizeOf(LongInt):

Begin

. . V3 . .

End;

End;

End;

  Смысл функции заключается в задании алгоритма вычисления некоторого значения и организации возврата этого значения в точку вызова.
  В теле функции должен присутствовать оператор присваивания специального вида, в левой части которого должен быть указан идентификатор, совпадающий с именем функции, а в правой части - выражение, вычисляющее возвращаемое значение. Таких операторов может быть несколько, важно чтобы хотя бы один всегда срабатывал в процессе выполнения тела функции. Если в процессе выполнения функции не было выполнено ни одного присваивания, то результат функции считается неопределённым.
  Функция может возвращать в качестве результата значения только простого, строкового или ссылочного типа.
  Работа процедуры или функции по определению завершится после выполнения последнего оператора её тела. Однако Турбо-Паскаль имеет оператор Exit, возвращающий программу в точку вызова. Перед выполнением Exit в теле функции должен выполнится оператор присваивания имени функции значения.

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

  Две подпрограммы, описанные на одном уровне, содержат взаимные вызовы друг друга.

Procedure A(X,Y: Real);

Begin

. . . . . .

B (2, 2);

. . . . . .

End;

Procedure B (A,B: Integer);

Begin

. . . . . .

A (1.5, 2.8);

. . . . . .

End;

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

Procedure A(X,Y: Real): Forward;

Procedure B(A,B: Integer): Forward;

. . . . . . . . .

Procedure A;

Begin

. . . . . . . .

End;

Procedure B;

Begin

. . . . . . . .

End;

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

  Подпрограмма или группа подпрограмм разработана вне системы Турбо-Паскаля, на другом языке, и необходимо использовать её в данной Pascal-программе.
  Внешнее описание. Объектный код подпрограммы содержится в OBJ- файле.
  В Pascal-программе необходимо описать заголовок подключаемой подпрограммы, после которого должно идти слово external, и указать имя файла, содержащего подпрограмму: {$L <имя .OBJ-файла>}

{$L ABC.OBJ}

Procedure A(C,D,E: Real); External;

Procedure B(I,F,J: Integer); Extenal

  Для обеспечения корректности такого подключения необходимо соблюдать определённые межъязыковые соглашения о связях принятые в Турбо-Паскале.

  Описание тела подпрограммы в машинных кодах - используется специальная конструкция со словом inline или серия ассемблерных инструкций с использованием слова asm.
Следующие коды эквивалентны:

asm

mov cx,100

metka mov i,cx

. . . . . . . .

loop metka

end;

И:

for i:=100 downto 0 do

. . . . . . . . . .

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

  В описании процедуры перед блоком может указываться специальное слово interrupt, которое служит для определения процедур прерываний.

  Допускается указание “типа вызова” процедуры (Far, Near). Для функций не допускается interrupt, тоесть она не может быть обработчиком прерывания.

  В теле подпрограммы доступны все объекты, описанные в объемлющем блоке, в том числе и имя самой подпрограммы. Подпрограммы, вызывающие сами себя, называются рекурсивными.
Пример: алгоритм вычисления факториала: N! = (N-1)!*N

Fuction Fact(N: Word): LongInt;

Begin

If N = 1 then

Fact:= 1

else

Fact:= N * Fact(N-1);

End;

  В Турбо-Паскале нет никаких ограничений на рекурсивные вызовы подпрограмм, необходимо только помнить, что каждый очередной рекурсивный вызов приводит к образованию новой копии локальных объектов подпрограммы и все эти копии, соответствующие цепочке активизированных и незавершенных рекурсивных вызовов существуют независимо друг от друга.
  Может возникнуть ситуация, при которой значение выражения, использующего вызов такой функции, зависит от порядка следования операндов, что является источником трудноуловимых программных ошибок - побочный эффект. Например:

Program SideEffect;

Var

A,Z: Integer;

F: Text;

Function Change(X: Integer): Integer;

Begin

Z:= Z - X; { изменяем значение локальной переменной }

Change:= Sqr (X);

End;

Begin

Assign(F, ‘Prn’);

Rewrite (F);

Z:= 10;

A:= Change (Z);

WriteLn (F, A,’ ’,Z);

Z:= 10;

A:= Change (10) * Change (Z);

WriteLn (F,A,’ ‘,Z);

Z:= 10;

A:= Change (Z) * Change (10);

WriteLn (F,A,’ ‘,Z);

End;

Результаты:

100 0

10000 -10

0 0

  Память под глобальные и типизированные константы выделяется при запуске программы в одном сегменте (65520 байт - сегмент данных программы).
  Локальные переменные динамически размещаются в том же сегменте при активизации подпрограммы.
  При рекурсии или просто вызове подпрограммы используется стек. Через стек передаются параметры подпрограмм, в стеке сохраняются переменные, вышедшие за область видимости при передаче управления в подпрограмму. Причем дописывание информации в стек происходит при каждом рекуррентном вызове , поэтому нужно следить за глубиной рекурсии, иначе слишком длинная, или бесконечная рекурсия забьет все стековое пространство и программа не сможет выполняться дальше, произойдет ошибка времени исполнения. Максимальный объём стековой памяти в Турбо-Паскале - 1 сегмент (65520 байт). Можно устанавливать размер стека и контроль за переполнением стека - $M и $S (тоесть, компилятор может включить в программу код, следящий за переполнением стека и выдающий вовремя сообщение о переполнении стека, вместо зависания программы, обычно этот ключ установлен по умолчанию). Но не следует всегда выставлять непременно максимальный обьем стека, так как ето приводит к увеличению размера памяти, занимаемой программой при исполнении.

  Турбо-Паскаль позволяет вводить переменные специального типа, значениями которых могут служить подпрограммы. Можно интерпретировать подпрограмму как значения, которые можно присваивать переменным и передавать их в качестве параметров (речь идёт о подпрограммах как о целостных объектах, а не о значениях, возникающих в процессе их выполнения).

{$F+}

Var

P: Procedure;

  Значениями Р могут быть любые процедуры без параметров. В более общем случае:

Type

Func = Function(X,Y: Integer): Integer;

Var

F1,F2: Func;

Например, если есть функция:

Function Add(A,B: Integer): Integer;

Begin

Add:= A + B;

End;

  то допустимо F1:= Add, в этом случае переменной F1 присваивается функция Add как таковая, но её исполнения не происходит.Теперь можно:
Write (Add (1,2)) или Write (F1 (1,2));.
  Следует обратить внимание на строку {$F+} – она существенна, это ключ компилятора, и если он выключен, при присвоении переменным процедурного типа значений конкретных подпрограмм, возникнет ошибка присвоения типа.
  Имена формальных параметров, указываемые в процедурных типах, играют часто иллюстративную роль и на смысл определений никакого влияния не оказывают. Необходимыми являются только идентификаторы типов параметров и результатов (для функций).
  Процедурные типы допускают также присвоение вида F1:= F2;
  Такие переменные можно использовать для вызова подпрограмм, которые присвоены этим переменным.
Пример:

Var

Oper: Function(X, Y: Real): Real;

Function Add(A,B: Real): Real;

Begin

Add:= A + B;

End;

Function Sub (A,B: Real): Real;

Begin

Sub:= A - B;

End;

тогда в основной программе можно использовать:

If <условие> then

Oper:= Add

else

Oper:= Sub;

Write (Oper(2.5, X+Y));

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

Type

Proc = Procedure(T: Real);

Notice = Record

Next: Integer;

Time: Real;

Action: Proc;

End;

Var

New_Notices: Array[1..10] of Proc;

Notices: Notice;

  Подпрограмма, присваиваемая процедурной переменной должна быть странслирована в режиме “дальнего вызова”.

  Подпрограмма, присваиваемая процедурной переменной, не должна быть стандартной процедурой или функцией. Это ограничение легко обойти:

Var

Func: Function(R: Real): Real;

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

Function MyExp(R: Real): Real

Begin

MyExp:= Exp (R);

End;

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

Begin

Func:= MyExp;

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

  Подпрограмма, присваиваемая процедурной переменной, не может быть подпрограммой специального вида (interrupt или inline).

  Процедурная переменная занимает в памяти 4 байта (2 слова). В первом хранится смещение, во втором - сегмент (т.е. указатель на код подпрограммы).
  Можно описывать процедуры и функции, параметрами которых являются процедурные переменные.
  Таким образом, можно организовать подпрограмму, которая будет выполнять некоторое общее действие для различных подпрограмм - периметров.
  В общем случае использование процедурных переменных в операторе или выражении означает вызов присвоенной данной переменной процедуры или функции.
  Необходимо помнить, что если в левой части оператора стоит процедурная переменная, правая часть его должна представлять идентификатор другой процедурной переменной или идентификатор подпрограммы.
  К сожалению есть неопределённость для компилятора, например в таком случае:

Type

Func = Function: Real;

Var

F: Func;

Function FFF: Real;

Begin

FFF:= 1.25;

End;

Function FF: Real;

Begin

FF:= 2.10;

End;

. . . . . . . . . .

F:= FF;

If F = FFF then . . . .

  В подобных случаях неочевидно, должен ли компилятор сравнивать значение процедуры F с FFF или нужно вызвать процедуру F и FFF и сравнить их значения.
 Принято, что такое вхождение идентификатора подпрограммы означает вызов функции.
  Чтобы сравнить значение переменной F со значением (адресом) подпрограммы FFF нужно использовать следующую конструкцию:
If @F = @FFF then . . . .
  Чтобы получить адрес самой процедурной переменной нужно написать:
@@F

  Определены следующие типы и переменные:

Type

Func:= Function(X: Integer): Integer;

Function MyFunc(X: Integer): Integer;

Begin

MyFunc:= X;

End;

Var

F: Func;

P: Pointer;

N: Integer;

Можно построить следующие присваивания:

F:= MyFunc {переменной F присваивается функция MyFunc}

N:= F(N) {функция MyFunc вызывается через переменную F}

P:= @F {P получает указатель на функцию MyFunc}

N:= Func (P)(N) {функция MyFunc вызывается через указатель P}

F:= Func (P) {присвоить значение подпрограммы в P переменной F}

Func(P):= F {присвоить значение подпрограммы в F указателю P}

@F:= P {присвоить значение указателя в P переменной F}

  Все глобальные переменные и типизированные константы размещаются в одной непрерывной области оперативной памяти, которая называется сегментом данных. Длина сегмента определяется архитектурой процессора 8086 и составляет 64 Килобайта (65536 байт), что может вызвать определённые трудности при описании и обработке больших массивов данных.
  С другой стороны объём стандартной памяти - 640 Килобайт. Выход - использовать динамическую память.
  Динамическая память - это оперативная память ЭВМ, предоставляемая Турбо-Паскалевой программе при её работе, за вычетом сегмента данных (64 К), стека (обычно 16 К) и собственно тела программы.
  По умолчанию размер динамической памяти определяется всей доступной памятью ЭВМ и, как правило, составляет не менее 200 - 300 Кбайт.
  Динамическую память обычно используют при:

обработке больших массивов данных;

разработке САПР;

временном запоминании данных при работе с графическими и звуковыми средствами ЭВМ.

  Размещение статических переменных в памяти осуществляется компилятором в процессе компиляции.
  Динамические переменные - размещаются в памяти непосредственно в процессе работы программы.
  При динамическом размещении заранее неизвестны ни тип, ни количество размещаемых данных, к ним нельзя обращаться по именам, как к статическим переменным.   Турбо-Паскаль представляет средство управления динамической памятью: указатели.
  Указатель - это переменная, которая в хранит качестве своего значения адрес байта памяти.
  В 8086 адреса задаются совокупностью двух шестнадцатиразрядных слов - сегмента и смещения. Сегмент - участок памяти, имеющий максимальную длину 64 К и начинающийся к физического адреса, кратного 16 (то есть 0, 16, 32, 48 и т.д.). Смещение - указывает, сколько байт от начала сегмента нужно пропустить, чтобы обратиться по нужному адресу. Фрагмент памяти в 16 байт называется параграфом. Сегмент адресует память с точностью до параграфа, а смещение - с точностью до байта.
  Каждому сегменту соответствует непрерывная и отдельно адресуемая область памяти. Сегменты могут следовать в памяти один за другим, или с некоторыми интервалами, или, наконец, перекрывать друг друга.
  Таким образом любой указатель по своей внутренней структуре представляет собой совокупность двух слов (типа Word), трактуемых как сегмент и смещение. Указатель адресует лишь первый байт типа данных.
Справка: процессор 8086.
8086 имеет 16 - битовые регистры, всего 14 штук, из них:

12 - регистры данных и адресов;

1 - указатель команд (регистр адреса команды);

1 - регистр состояния (регистр флагов).

  Регистры данных и адресов делятся на три группы:

регистр данных;

регистр указателей и индексов;

регистр сегментов.

  Процессор 8086 всегда генерирует 20-ти бытовые адреса за счёт добавления 16-ти битового смещения к содержимому регистра, умноженному на 16:
физический адрес = смещение + 16 * регистр сегмента.
  Вместо умножения на 16 содержимое регистра сегмента используется так, как если бы оно имело четыре дополнительных нулевых бита:

пусть:

смещение = 10H

регистр сегмента = 2000H

тогда:

0000 0000 0001 0000 (смещение)

0010 0000 0000 0000 (0000) (номер блока)

0010 0000 0000 0001 0000 (физический адрес)

физический адрес = 20010H

  У 8086 адрес ячейки задаётся номером блока и смещением, что обусловлено тем, что команды 8086 и её данные должны располагаться в разных частях памяти (в разных сегментах).
  Если требуется адресоваться к данным, то потребуется адресация блока памяти, с которого начинается сегмент данных (из регистра сегмента данных) и позиция желаемой ячейки в этом сегменте (смещение).
  В дополнение к области памяти 1 Мбайт, 8086 может адресоваться к внешним устройствам через 65536 (64 К) портов ввода-вывода. Имеются специальные команды ввода-вывода, позволяющие иметь непосредственный доступ к первым 256 (от 0 до 255) портам. Другие команды позволяют получить косвенный доступ к порту с помощью занесения идентифицирующего его номера (0 - 65535) в определенный регистр данных. Подобно ячейке памяти любой порт может быть 8 или 16- битовым.

16 - старших байт - команды начальной загрузки системы.

Первые 1024 ячейки - вектора прерываний.

  Существуют 2 вида прерываний - одни можно игнорировать, другие обязательно обслужить как можно скорее.
  8086 может распознать 256 различных прерываний, каждому из них однозначно соответствует код типа (целое число от 0 до 255). Код используется в качестве указателя ячейки в области памяти с младшими адресами (область векторов прерываний).

  Как правило, в Турбо-Паскале указатель связывается с некоторым типом данных (типизированные указатели).

Type

PerPnt = ^PerRec; {указатель на переменную типа PerRec}

PerRec = Record

Name: String;

Job: String;

Next: PerPnt;

End;

Var

P1: ^Integer;

P2: ^Real;

  Внимание! При объявлении типа PerPnt мы сослались на PerRec, который ещё не был объявлен, это связано с тем, что существует исключение из правил для указателей, которые содержат ссылку на ещё неописанный тип данных. Это исключение сделано не случайно, так как динамическая память позволяет использовать организацию данных в виде списков (каждый элемент имеет в своём составе ссылку на соседний элемент - обратите внимание на поле Next).
  В Турбо-Паскале можно объявлять указатель и не связывать его с конкретным типом данных:

Var

PP: Pointer;

Указатели такого рода называют нетипизированными. В них удобно размещать данные, структура которых меняется по ходу работы.
  В Турбо-Паскале можно передавать значения только между указателями, связанными с одним и тем же типом данных.

Var

P1,P2: ^Integer;

P3: ^Real;

PP:Pointer;

Begin

P1:= P2; {- верно}

P1:= P3; {- неверно}

но можно сделать так:
PP:= P3;
P1:= PP;
так как ограничение не распространяются на нетипизированные указатели. Но подобные операции часто путают программиста и чреваты смысловыми ошибками.

  Вся динамическая память – пространство ячеек, называемое кучей. Физически куча располагается в старших адресах, сразу за программой. Указатель на начало кучи храниться в предопределенной переменной HeapOrg, конец - FreePtr, текущую границу незанятой динамической памяти указывает указатель HeapPtr.
  Для выделения памяти под любую переменную используется процедура New. Единственным параметром является типизированный указатель:

Var

I,J: ^Integer;

R: ^Real;

Begin

New(I); {под I выделяется область памяти,}

{адрес первого байта этой области помещается в I}

End.

  После выполнения этого фрагмента указатель I приобретёт значение, которое перед этим имел указатель кучи HeapPtr, а HeapPtr увеличится на два (т.к. он типа Integer); New(R) - вызовет смещение указателя на 6 байт.
  После того как указатель приобрёл некоторое значение, то есть стал указывать на конкретный байт памяти, по этому адресу можно разместить значения соответствующего типа:
I^:= 2;
R^:= 2*Pi;
  Допустима запись: R^:= Sqr (R^) + I^ - 17;
  Но недопустима запись: R:= Sqr (R^) + I^ - 17; так как указателю R нельзя присвоить значение вещественного выражения.
  Возврат динамической памяти обратно в кучу осуществляется оператором Dispose:
Dispose(R);
Dispose(I); - вернут в кучу, ранее забранные 8 байт.
  Dispose(Ptr) не изменяет значения указателя Ptr, а лишь возвращает в кучу память, связанную с этим указателем. Однако повторное применение процедуры к “свободному” указателю приведет к возникновению ошибки времени исполнения. Чтобы указать, что указатель свободен, нужно использовать зарезервированное слово Nil.
  К указателям можно применять операции отношения, в том числе и сравнения с Nil:

Const

P:^Real = Nil;

. . . . . . . .

Begin

If P = Nil then

New (P);

. . . . . . . .

Dispose(P);

P:= Nil;

End.

  Использование указателей, которым не присвоено значение процедурой New или каким-либо другим способом, никак не контролируется системой и может привести к непредсказуемым результатам. Многократное чередование New и Dispose приводит к “ячеистой” структуре кучи. Дело в том, что все операции с кучей выполняется под управлением особой программы, которая ведёт учёт всех свободных фрагментов в куче. При выполнении оператора New( ) эта программа отыскивает минимальный свободный фрагмент, в котором может разместиться требуемая переменная. Адрес начала найденного фрагмента возвращается в указателе, а сам фрагмент или его часть нужной длины, помечаются как занятая часть кучи.
Можно освободить целый фрагмент кучи следующим образом:

Перед началом выделения динамической памяти значения указателя HeapPtr запоминается в переменной-указателе с помощью процедуры Mark.

Выполнение программы.

Освобождение фрагмента кучи от заполненного адреса до конца динамической памяти с использованием процедуры Release.

Var

P, P1, P2, P3, P4, P5: ^Integer;

Begin

New(P1);

New(P2);

New(P3);

New(P4);

New(P5);

Mark(P);

. . . . . . .

Release (P);

End.

  В этом примере процедурой Mark(P) в указатель P было помещено текущее значение HeapPtr, однако память под переменную не резервировалась.
  Вызов Release уничтожает список свободных фрагментов в куче, созданных Dispose, поэтому совместное применение этих процедур не рекомендуется.

  Для работы с нетипизированными указателями используются также процедуры GetMem(P, Size) и FreeMem(P, Size) - резервирование и освобождение памяти.
P - нетипизированный указатель, Size - размер.
  За одно обращение к куче процедурой GetMem можно зарезервировать до 65521 байт. Освобождать нужно ровно столько памяти, сколько было зарезервировано, и именно с того адреса, с которого память была зарезервирована, иначе программа не будет работать и завершаться корректно !!!
  Использование нетипизированных указателей даёт широкие возможности неявного преобразования типов:

Var

i,j: ^Integer;

r: ^Real;

Begin

New (i); { I:= HeapOrg; HeapPtr:= HeapOrg+2 }

j:= i; { J:= HeapOrg }

j^:=2;

Dispose (i); { HeapPtr:= HeapOrg }

New (r); { R:= HeapOrg; HeapPtr:= HeapOrg+6 }

r^:= Pi;

WriteLn (j^);

End.

Будет выведено: "8578" {здесь преобразование не имеет никакого смысла}

  Динамическая память - 200..300 Кбайт. Нужно разместить массив 100 * 200 типа Extended. Требуется 100 * 200 * 10 = 200000 байт. Пробуем:

Var

i,j: Integer;

PtrArr: Array[1..100, 1..200] of ^Extended.

Begin

. . . . . .

For i:= 1 to 100 do

For j:= 1 to 200 do

New (PtrArr [i,j]);

. . . . . .

End.

  Теперь к любому элементу можно обратиться: PtrArr[i,j]^:=...; Но длина внутреннего представления указателей 4 байта, поэтому потребуется ещё 100*200*4 = 80000 байт, что превышает размер сегмента (65536 байт), доступный для статического размещения данных.
  Можно было бы работать с адресной арифметикой (арифметикой над указателями), то есть не создавать массив указателей, а вычислять адрес элемента непосредственно перед обращением к нему. Однако в Турбо-Паскале над указателями не определены никакие операции, кроме присваивания и отношения. Но задачу решить можно:
 Seg(x) - возвращает сегментную часть адреса.
 Ofs(x) - возвращает смещение.
 x - любая переменная, в том числе и та, на которую указывает указатель.
  Далее с помощью Ptr(Seg, Ofs: Word): Pointer можно создать значение указателя, совместимое с указателем любого типа.
  Таким образом, сначала с помощью GetMem забираем из кучи несколько фрагментов подходящей длины (не более 65521). Удобно по строкам 200 * 100 = 20000 байт.
  Начало каждого фрагмента запоминается в массиве PtrStr из 100 указателей. Теперь для доступа к любому элементу строки нужно вычислить смещение этого элемента от начала строки и сформировать указатель.

Var

i,j: Integer;

PtrStr: Array [1..100] of Pointer;

Pr: ^Extended;

Const

SizeOfExt = 10;

Begin

For i:= 1 to 100 do

GetMem (PtrStr[i], SizeOfExt*200);

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

Pr:= Ptr(Seg(PtrStr[i]^), Ofs(PtrStr[i]^) + (j - 1) * SizeOfExt); {Обращение к элементу матрицы [i,j]}

End;

далее работаем с Pr^:=. . . и т.д.

  Полезно ввести две вспомогательных функции GetExt и PutExt. Каждая из них будет обращаться к функции вычисления адреса AddrE.

Program Demo;

Const

SizeOfExt = 10;

N = 100;

M = 200;

Type

ExtPoint = ^Extended;

Var

i,j: Integer;

PtrStr: Array[1..N] of Pointer;

S: Extended;

Function AddrE(i,j: Word): ExtPoint;

Begin

AddrE:= Ptr(Seg(PtrStr[i]^), Ofs(PtrStr[i]^) + (j - 1) * SizeOfExt);

End;

Function GetExt(i,j: Integer): Extended;

Begin

GetExt:= AddrE(i,j)^;

End;

Procedure PutExt(i,j: Integer; X: Extended);

Begin

AddrE(i,j)^:= X;

End;

Begin {main}

Randomize;

For i:=1 to N do

Begin

GetMem (PtrStr[i], M*SizeOfExt);

For i:= 1 to m do

PutExt(i, j, Random(255));

End;

S:= 0;

For i:= 1 to N do

For j:= 1 to M do

S:= S + GetExt(i,j);

WriteLn(S/(N*M));

End.

  Мы предполагали, что каждая строка размещается в куче с начала границы параграфа и смещение каждого указателя PtrStr ровно 0. В действительности при последовательных обращениях к GetMem начало очередного фрагмента следует за концом предыдущего и может не попасть на границу сегмента. В результате при размещении фрагментов максимальной длины (65521 байт) может возникнуть переполнение при вычислении смещения последнего байта.

Функция Addr - возвращает результат типа Pointer, в котором содержится адрес аргумента.

Addr(X), x - любой объект программы. Возвращаемый адрес совместим с указателем любого типа. Аналогично операции @.

Функция CSeg - возвращает значения хранящееся в регистре CS (в начале работы программы в CS содержится сегмент начала кода программы), результат CSeg - слово типа Word.

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

Функция DSeg - возвращает значение хранящиеся в регистре DS (в начале работы в DS - сегмент начала данных программы), результат - типа Word.

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

Процедура GetMem(P, Size) - резервирует память (за одно обращение не более 65521 байт), если нет свободной памяти - ошибка времени исполнения.

Процедура Mark(Ptr) запоминает текущее значение указателя кучи HeapPtr. Ptr - указатель любого типа, в нём будет возвращено HeapPtr. Используется совместно с Release для освобождения части кучи.

Функция MaxAvail - возвращает размер (в байтах) наибольшего непрерывного свободного участка кучи. Результат типа LongInt. За один вызов New или GetMem нельзя зарезервировать значение большее, чем возвращаемое этой функцией.

Процедура New(TP) - резервирует фрагмент кучи для размещения переменной. TP - типизированный указатель (за одно обращение не более 65521байт).

Функция MemAvail - возвращает размер (в байтах) общего свободного пространства кучи. Результат типа Longint.

Функция Ofs(X) - возвращает значение типа Word, содержащее смещение адреса указанного объекта. X - выражение любого типа или имя процедуры.

Функция Ptr(Seg, Ofs) - возвращает значение типа Pointer по заданному сегменту и смещению. Значение, возвращаемое функцией, совместимо с указателем любого типа.

Процедура Release(Ptr) - освобождает участок кучи. Рtr - указатель любого типа, в котором сохранено процедурой Mark значение указателя кучи. Освобожденный участок кучи - от адреса в Ptr до конца. Одновременно уничтожается список свободных фрагментов, созданных по Dispose и FreeMem.

Функция Seg(X) - возвращает значение типа Word, содержащее сегмент адреса указанного объекта.

Функция SizeOf(X) - возвращает длину (в байтах) внутреннего представления указанного объекта. X - имя переменной, функции или типа.

  Работа с динамическими переменными через указатели требует большой тщательности и аккуратности при проектировании программ. В частности, следует стремиться освобождать выделенные области сразу же после того, как необходимость в них отпадает, иначе “засорение” памяти ненужными динамическими переменными может привести к быстрому ее исчерпанию.
  Кроме того, необходимо учитывать еще одну проблему, связанную с противоречием между стековым принципом размещения статических переменных и произвольным характером создания и уничтожения динамических переменных. Рассмотрим следующий схематический пример программы:

Program LostReference;

Type

PPerson = ^Person;

Person = Record

. . . .

End;

Procedure GetPerson;

Var

Р: РРerson;

Begin

P:= New(PPerson);

End;

Begin

WriteLn(MemAvail);

GetPerson;

Writeln(MemAvail);

End.

Вызов New в процедуре GetPerson приводит к отведению памяти для динамической переменной типа Person. Указатель на эту переменную присваивается переменной Р. Рассмотрим ситуацию, возникающую после выхода из процедуры GetPerson. По правилам блочности все локальные переменные подпрограммы перестают существовать после ее завершения. В нашем случае исчезает локальная переменная Р. Но, с другой стороны, область памяти, отведенная в процессе работы GetPerson, продолжает существовать, так как освободить ее можно только явно, посредством процедуры Dispose. Таким образом, после выхода из GetPerson отсутствует какой бы то ни было доступ к динамической переменной, так как единственная "ниточка", связывавшая ее с программой - указатель Р - оказался потерянным при завершении GetPerson. Вывод на печать общего объема свободной памяти до и после работы GetPerson подтверждает потерю определенной области.
  При проектировании программ, интенсивно использующих динамическую память, следует с особой внимательностью относиться к данной проблеме, так как Turbo Pascal, как, впрочем, и многие другие языки программирования, не имеет встроенных средств борьбы с засорением памяти неиспользуемыми динамическими переменными. Во всяком случае нужно придерживаться правила, согласно которому при выходе из блока необходимо или освободить все созданные в нем динамические переменные, или сохранить каким-то образом ссылки на них (например, присвоив эти ссылки глобальным переменным).
  К описанной проблеме примыкает коллизия другого рода, заключающаяся в ситуации, когда некоторая область памяти освобождена, а в программе остался указатель на эту область. Рассмотрим следующий пример:

Var

P: Integer;

Procedure X1;

Var

i: Integer;

Begin

i:= 12345;

P:= @i;

WriteLn(P^); { напечатает 12345 }

End;

Procedure X2;

Var

j: Integer;

Begin

j:= 7777;

WriteLn(P^); { напечатает 7777, а не 12345 }

End;

Begin

X1;

X2;

End;

  В этом примере глобальная ссылочная переменная Р первоначально (в процедуре X1) устанавливается на локальную переменную i. После завершения процедуры X2 переменная i исчезает, указатель Р “повисает”. Вызов процедуры Х2 приводит к тому, что на место, локальной переменной i, будет помещена локальная переменная j, и указатель Р теперь ссылается на нее, что подтверждает результат второго вызова WriteLn.
  Таким образом, смысл указателя Р зависит в данном случае не от семантики решаемой задачи, a от системных особенностей ее функционирования, что может привести к неожиданным эффектам. Аналогичные ситуации возможны при повторном использовании областей динамической памяти: если на освобожденную область остался указатель, то он может быть (по ошибке) использован после повторного выделения этой памяти для другой переменной, что опять- таки не будет "замечено" системой, но может сделать поведение программы непредсказуемым.

  Стандартный Паскаль не предусматривает никаких механизмов раздельной компиляции частей программы с последующей их сборкой перед выполнением. Более того, последовательное проведение в жизнь принципа обязательного описания любого объекта перед его ис пользованием делает фактически невозможным разработку разнообразных библиотек прикладных программ. Точнее, такие библиотеки в рамках стандартного Паскаля могут существовать только в виде исходных текстов и программист должен сам включать в программу подчас весьма обширные тексты различных поддерживающих процедур, таких, как, например, процедуры матричной алгебры, численного интегрирования, математической статистики и т.п.
  Вполне понятно, поэтому стремление разработчиков коммерческих компиляторов Паскаля включать в язык средства, повышающие его модульность. Чаще всего таким средством является разрешение использовать внешние процедуры и функции, тела которых заменяются зарезервированным словом External.
  Разработчики Турбо-Паскаля пошли в этом направлении еще дальше, включив в язык механизм так называемых модулей. Модуль - это автономно компилируемая программная единица, включающая в себя различные компоненты раздела описаний (типы, константы, пе ременные, процедуры и функции) и, возможно, некоторые исполняемые операторы инициирующей части. По своей организации и характеру использования в программе модули Турбо-Паскаля близки к модулям- пакетам (Package) языка программирования Ада: в них также явным образом выделяется некоторая "видимая" интерфейсная часть, в которой сконцентрированы описания глобальных типов, констант и переменных, а кроме того, приводятся заголовки глобальных процедур и функций. Появление объектов в интерфейсной части делает их доступными для других модулей и основной программы. Тела процедур и функций располагаются в исполняемой части модуля, которая может быть скрыта от пользователя.
  Насколько сильно изменяются свойства языка Паскаль при введении механизма модулей, свидетельствует следующее замечание его автора Н.Вирта, сделанное им по поводу более позднего языка Модула-2: "Модули - самая важная черта, отличающая язык Модула-2 от его предшественника Паскаля". Кстати, из пяти основных отличий Модулы- 2 от Паскаля, сформулированных Н. Виртом, три: модули, средства программирования низшего уровня и процедурные типы - реализованы в Турбо-Паскале.
  Модули представляют собой прекрасный инструмент для разработки библиотек прикладных программ и мощное средство модульного программирования. Важной особенностью модулей является то обстоятельство, что компилятор Турбо-Паскаля размещает их про граммный код в отдельном сегменте памяти. Максимальная длина сегмента не может превышать 64 Кбайт, однако количество одновременно используемых модулей ограничивается лишь доступной памятью, что дает возможность создавать весьма крупные программы.

Модуль имеет следующую структуру:

Unit < имя >;

Interface

< интерфейсная часть >

Implementation

< исполняемая часть >

[ Begin < инициирующая часть > ]

End.

Здесь:
 Unit - кодовое слово (англ. модуль); начинающее заголовок модуля;
 <имя> - имя модуля (правильный идентификатор);
 Interface - кодовое слово, начинающее интерфейсную часть модуля;
 Implementation - кодовое слово (англ. реализация); начинает исполняемую часть;
 Begin - кодовое слово, начинающее инициирующую часть;
(часть модуля Begin < инициирующая часть > необязательна);
 End. - признак конца модуля.

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

  Заголовок модуля состоит из кодового слова Unit и следующего за ним имени модуля. Для правильной работы среды Турбо-Паскаля и возможности подключения средств, облегчающих разработку крупных программ, это имя должно совпадать, с именем дискового файла, в который помещается исходный текст модуля.
  Если, например, имеем заголовок Unit Global, то исходный текст соответствующего модуля должен размещаться в дисковом файле GLOBAL.PAS. Имя модуля служит для его связи с другими модулями и основной программой. Эта связь устанавливается специальным предложением
 Uses <список модулей>
  Здесь:
Uses - кодовое слово (англ. использует);
<список модулей> - список модулей, с которыми устанавливается связь; элементами списка являются имена модулей, отделяемые друг от друга запятыми, например:
Uses Crt, Graph, Global;
  Если предложение Uses... используется, оно должно открывать раздел описаний основной программы или следовать сразу за кодовым словом Interface в модуле.

  Интерфейсная часть открывается кодовым словом Interface. В этой части содержатся объявления всех глобальных объектов модуля (типов, констант, переменных и подпрограмм), которые должны стать доступными основной программе и/или другим модулям.
  При объявлении глобальных блоков в интерфейсной части пишется только их заголовок, например:

Unit Cmplx;

Interface

Type

Complex = Record

Re: Real;

Im: Real;

End;

Procedure AddC (X, У: Complex; Var R: Complex);

Procedure MulC (X, У: Complex; Var Z : Complex);

  Если теперь в основной программе написать предложение Uses Cmplx; то в программе станут доступными тип Complex и две процедуры - Addc и Mulc из модуля Cmplx.
  Следует учесть, что все константы и переменные, объявленные в интерфейсной части модуля, равно как и глобальные объекты основной программы, помещаются компилятором Турбо-Паскаля в обилии сегмент данных (максимальная длина сегмента 65521 байт).
  Порядок появления различных разделов объявлений и их количество могут быть произвольными.
  Если в интерфейсной части объявляются внешние блоки или блоки в машинных кодах, их тела (т.е. зарезервированное слово External в первом случае и машинные коды вместе со словом Inline во втором) должны следовать сразу за их заголовками.
  В интерфейсной части модулей нельзя использовать опережающее описание.

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

Unit Cmplx;

Interface

Type

Complex = Record

Re: Real;

Im: Real;

End;

Procedure AddC (X, У: Complex; Var Z : Complex);

Implementation

Procedure AddC;

Begin

Z.Re:= Х.Rе + Y.Re;

Z.Im:= X.Im + Y.Im;

End;

End.

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

  Инициирующая часть завершает модуль. Она может отсутствовать вместе с начинающим ее словом Begin или быть пустой - тогда за Begin сразу следует признак конца модуля (кодовое слово End и следующая за ним точка). В инициирующей части помещаются ис полняемые операторы, содержащие некоторый фрагмент программы. Эти операторы исполняются до передачи управления основной программе и обычно используются для подготовки ее работы. Например, в них могут инициироваться переменные, открываться нужные файлы, устанавливаться связь с другими ПЭВМ по коммуникационным каналам и т.п.:

Unit FileText;

Interface

Procedure Print(S: String);

Implementation

Var

F: Text;

Const Name = 'output.txt’;

Procedure Print;

Begin

WriteLn(F, S);

End;

{ Начало инициирующей части }

Begin

Assign(F, Name);

Rewrite(F);

{ Конец инициирующей части }

End.

  В среде Турбо-Паскаля имеются средства, управляющие способами компиляции модулей и облегчающие разработку крупных программных проектов. В частности, определены три режима компиляции: Compile, Make и Build, Режимы отличаются только способом связи компилируемого модуля или компилируемой основной программы с другими модулями, объявленными в предложении Uses.
  При компиляции модуля или основной программы в режиме Compile все упоминающиеся в предложении Uses модули должны быть предварительно откомпилированы и результаты их компиляции должны быть помещены в одноименные файлы с расширением .TPU. Например, если в программе (в модуле) имеется предложение Uses Global, то на диске в каталоге, объявленном опцией Unit directories, уже должен находиться файл GLOBAL.TPU. Файл с расширением .TPU (от англ. Turbo-Pascal Unit) создается в результате компиляции модуля.
  В режиме MAKE компилятор проверяет наличие TPU-файлов для каждого объявленного модуля. Если какой-либо из файлов не обнаружен, система пытается отыскать одноименный файл с расширением .PAS, т.е. файл с исходным текстом модуля, и, если PAS- файл найден, приступает к его компиляции. Кроме того, в этом случае система следит за возможными изменениями исходного текста любого используемого модуля. Если внесены какие-либо изменения в PAS-файл (исходный текст модуля), то независимо от того, есть ли уже в каталоге соответствующий TPU-файл или нет, система осуществляет его компиляцию перед компиляцией основной программы.
  Более того, если изменения внесены в интерфейсную часгь модуля, то будут перекомпилированы также и все другие модули, обращающиеся к нему. Режим Make, таким образом, существенно облегчает процесс разработки крупных программ с множеством модулей: программист избавляется от необходимости следить за соответствием существующих TPU-файлов и их исходного текста, так как система делает это автоматически.
  В режиме Build существующие TPU-файлы игнорируются, и система пытается отыскать (и компилировать) соответствующий PAS-файл для каждого объявленного в Uses модуля. После компиляции в режиме Build программист может быть уверен в том, что учтены все сделанные им изменения в любом из модулей.
  Подключение модулей к основной программе и их возможная компиляция осуществляется в порядке их объявления в предложении Uses. При переходе к очередному модулю система предварительно отыскивает все модули, на которые он ссылается. Ссылки модулей друг на друга могут образовывать древовидную структуру любой сложности, однако запрещается явное или косвенное обращение модуля к самому себе.

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

Unit Cmplx;

Interface

Type

Complex = Record

Re: Real;

Im: Real;

End;

Procedure AddC (X, У: Complex; Var Z ; Complex);

Procedure SubC (X, У: Complex; Var Z: Complex);

Procedure MulC (X, Y.: Complex; Var Z: Complex);

Procedure DivC (X, У: Complex; Var Z: Complex);

Const

С: Complex = (Re: 0.1; 1m: -1);

Implementation

Procedure Addc;

Begin

Z.Re:= X.Re + Y.Re;

Z.Im:= X.Im + Y.Im;

End {Addc};

Procedure Subc;

Begin

Z.Re:= X.Re - Y.Re;

Z.Im:= X.Im - Y.Im;

End {Subc};

Procedure Mulc;

Begin

Z.Re:= X.Re * Y.Re - X.Im * Y.Im;

Z.Im:= X.Re * Y.Im + X.Im * Y.Re;

End {Mulc};

Procedure DivC;

Var

ZZ: Real;

Begin

ZZ:= Sqr(Y.Re) + Sqr(Y.Im);

Z.Re:= (X.Re * Y.Re + X.Im * Y.Im) / ZZ;

Z.Im:= (X.Re * Y.Im - X.Im * Y.Re) / ZZ;

End;

End.

  Текст этого модуля нужно поместить в файл CMPLX.PAS. Теперь можно написать программу, приведенную в примере:

Program TestOfComplex;

Uses Cmplx;

Var

A, B, С: 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,’i’);

SubC (A, B, C);

WriteLn (‘Вычитание: ‘, C.Re:5:1, C.Im:5:1,’i’);

MulC (A, B, C);

WriteLn ('Умножение: ‘, C.Re:5:1, C.Im:5:1,’i’);

DivC (A, B, C);

WriteLn ('Деление: ', C.Re:5:1, C.Im:5:1,’i’);

End.

Как видим, программе стали доступны все объекты, объявленные в интерфейсной части. При необходимости мы можем переопределить любой из этих объектов, как это произошло, например, с объявленной в модуле типизированной константой С. Переопределение объекта означает, что вновь объявленный объект "закрывает" ранее определенный в блоке одноименный объект. При необходимости мы можем получить доступ к "закрытому" объекту. Для этого нужно перед именем объекта поставить имя модуля и точку. Так, оператор
  WriteLn(Cmplx.C.Re:5:1, Cmplx.C.Im:5:1,’i’);
выведет на экран содержимое "закрытой" типизированной константы из примера.

  В Турбо-Паскале имеется восемь стандартных модулей, в которых содержится большое число разнообразных типов, констант, процедур и функций. Этими модулями являются: System, Dos, Crt, Printer, Graph, Overlay, Turbo3 и Graph3.
  Модули Graph, Turbo3 и Graph3 содержатся в одноименных TPU-файлах, остальные входят в состав библиотечного файла TURBO.TPL. Лишь один модуль System подключается к любой Турбо-Паскалевой программе автоматически, все остальные становятся доступны только после указания их имен в списке, следующем за кодовым словом Uses.

  Ниже приводится краткая характеристика стандартных модулей.

  В модуль System входят все процедуры и функции стандартного Паскаля, а также встроенные процедуры и функции Турбо-Паскаля, которые не вошли в другие стандартные модули (например, Inc, Dec, Getdir и т.п.). Как уже говорилось, модуль System подключается к любой Турбо-Паскалевой программе независимо от, того, объявлен ли он в предложении Uses или нет.

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

USES

Printer;

Begin

WriteLn (Lst, ‘TEST’); {Выводит строку на принтер}

End.

  В модуле Crt сосредоточены процедуры и функции, обеспечивающие управление текстовым режимом работы экрана. С помощью входящих в модуль блоков можно перемещать курсор в произвольную позицию экрана, менять цвет выводимых символов и окружающего их фона, создавать окна. Кроме того, в модуль включены также процедуры "сле пого" чтения клавиатуры и управления звуком.

  Модуль Graph содержит обширный набор типов, констант, процедур и функций для управления графическим режимом работы экрана. С помощью блоков, входящих в модуль Graph, можно создавать самые разнообразные графические изображения и выводить на экран текстовые надписи стандартными или разработанными программистом шрифтами. Программы модуля Graph после соответствующей настройки могут поддержать любой тип аппаратных графических средств (CGA, EGA, VGA).
  Настройка на имеющиеся в распоряжении программиста технические средства графики осуществляется специальными программами-драйверами, которые не входят в библиотечный файл TURBO.TPL, но поставляются вместе с ним.

  В модуле Dos собраны процедуры и функции, открывающие доступ Турбо-Паскалевым программам ко всем средствам дисковой операционной системы PC DOS (MS DOS).
  Блоки модуля Overlay понадобятся при разработке громоздких программ с перекрытиями (позволяет хранить в памяти только нужные части программы, а не требующиеся на данный момент удалять из памяти, сохраняя на диск, либо возвращать в память при необходимости). Как уже говорилось, Турбо-Паскаль обеспечивает создание программ, длина которых ограничивается лишь доступной памятью. Для большинства отечественных IBM-совместимых ПЭВМ доступная программе память составляет около 550 Кбайт (без инстру ментальных оболочек типа Norton Commander и без самой системы Турбо-Паскаль). Память такого размера достаточна для большинства прикладных задач, тем не менее, использование программ с перекрытиями снимает и это ограничение.

  Два библиотечных модуля Turbo3 и Graph3 введены для совместимости с ранней версией 3.0 системы Турбо-Паскаль.

  Позволяют управлять процессами компиляции программы. Директива представляет собой комментарий со специальным синтаксисом: начинается с {$, далее пишется имя директивы (одна или несколько букв) и параметры.
  Турбо-Паскаль 7.0 допускает применение директив в любом месте программы, где допускается применение комментариев.

  В Турбо-Паскале 7.0 существует три основных вида директив:

  Директивы - переключатели.
С их помощью, указывая символ (+) или (-), можно разрешать или запрещать тот или иной режим.

  Директивы с параметрами.
Позволяют задавать компилятору параметры, такие как имена подключаемых файлов, размеры памяти, выделяемые под определённую задачу, и так далее.

  Условные директивы.
Позволяют организовывать так называемую "условную компиляцию" частей исходного текста, благодаря чему скомпоновать программу определённым образом.

  Все директивы, кроме директив-переключателей, должны иметь по крайней мере один пробел между именем директивы и параметром.
  Чтобы не прописывать директивы компилятора в тексте программы можно воспользоваться пунктом "Options" меню ИПО и далее подпунктом "Compiler". Но при этом все изменения будут иметь силу при всех последующих компиляциях других программ. Однако, если указать в исходном тексте какие-либо директивы, противоречащие установленным в ИПО, то последние будут проигнорированы. Это справедливо как для командно- строчного компилятора, так и для встроенного в ИПО.

  Различаются по диапазону своего действия на глобальные и локальные:

Глобальные - влияют на ход компиляции и выполнение всей программы,

локальные - только на определённую часть программы.

  Глобальные директивы могут быть объявлены в разделе объявлений и соглашений прежде, чем будет использовано хотя бы одно из следующих зарезервированных слов: Uses, Label, Const, Type, Procedure, Function, Begin, а Локальные директивы могут быть объявлены в любом месте программы или программного модуля.
  При необходимости можно сгруппировать комментарии из нескольких директив, разделённых запятой: {$A+, B-}.
Примечание: двойное нажатие комбинации Ctrl+O заставит редактор поместить в самое начало файла строки, содержащие текущую настройку среды в виде директив компилятора.

  Выравнивание данных - (Word Align Data)
{$A+}
  Тип глобальный. Делает возможным переключение между выравниванием на границу слова или байта. (Для 8086 выравнивание на границу слова игнорируется, однако для 80X86 выравнивание на границу слова означает более быстрое выполнение, поскольку адресация по всем элементам, имеющим размер в слово (чётная адресация) происходит за один цикл вместо двух. {$A+} не влияет:

на переменные размером в байт,

на поля структур или элементы массивов.

  Булевы вычисления (Complete Boolean Evaluation)
{$B+}
  Тип локальный Может быть осуществлено два различных вида генерации кода для And и Or .При {$B-} генерируется код вычисления выражения, по короткой схеме (вычисления прекращаются сразу, как станет очевидным результат вычисления всего выражения).
Пример:

Function Fun(X: Integer): Boolean;

Begin

X:= X + 1;

Fun:= X > 10;

End;

. . . . . . . . . . .

Begin

X:= 0;

If False And Fun(X) Then

X:= 10;

  Информация для отладки (Debug Information)
{$D+}
  Тип глобальный. Составляется таблица для отладчика, состоящая из N-строк для каждой процедуры, устанавливающая соответствующие адреса объектных кодов номерам строк исходного текста.
  Отладочная информация приводит к увеличению размера файла .TPU и требует дополнительного пространства при компиляции использующей модуль программы, но на размер и скорость не влияет.
  $D не будет работать в Турбо-Паскале 7.0 до тех пор пока не установить в меню или не задать параметр /V при запуске TPC.EXE .

  Эмуляция сопроцессора. (Emulation).
{$E+}
  Тип глобальный. В процессе генерации кода нет библиотеки, реализующей функции сопроцессора программы.

  Дальний тип вызова (Force Far Calls).
{$F-}
  Тип локальный, (Far) или (Near).

  Генерация кода для 80286 (286 Instruction).
{$G-}
  Тип локальный. При {$G-} генерируются инструкции 8086, такие программы могут работать на любой машине. Если {$G+}, то будут использоваться дополнительные инструкции 80286, которые позволяют генерировать более эффективный код, но не работают на 8086 и 8087. (Например команды Shr и Shl - расширенные).

  Проверка ошибок ввода-вывода (I/O checking).
{$I+}
  Тип локальный. Если {$I-}, то результат ввода-вывода может быть проанализирован с помощью функции IOResult.

  Информация о локальных идентификаторах. (Local Symbols)
{$L+}
  Тип глобальный. Используется в основном для модулей, дает возможность проверить и модифицировать локальные переменные модуля. Увеличивает размер .TPU, на размер и скорость работы выполняемой программы не влияет. В Турбо-Паскале 7.0 директива не будет работать до тех пор, пока в меню не будет Debuginfo или для TPC.EXE ключ /V.

  Использование математического сопроцессора (8087/80287).
{$N-}
  Тип глобальный. Позволяет осуществлять выбор генерируемых кодов для вычислений с плавающей запятой при “-“ реализуется программно, при ”+” - код для сопроцессора.
 Примечание: если отсутствует сопроцессор и возникла необходимость в использовании специальных вещественных типов, нужно использовать {$E+}.

  Использование оверлейных структур. (Overlays allowed).
{$O-}
  Тип глобальный. Разрешает или запрещает генерацию оверлейного кода, то есть Турбо-Паскаль 7.0 может использовать модуль в качестве оверлейного, если он был скомпилирован с {$O+}. Задание данного режима компиляции не обязывает использовать данный модуль в качестве оверлейного. Директиву {$O+} почти всегда используют с {$F+}.

  Использование в качестве параметров массивов открытого типа (Open parameters).
{$P-}
  Тип глобальный.

  Проверка переполнения при математических операциях (Overflow checking).
{$Q-}
  Тип глобальный.

  Проверка границ. (Range-Checking).
{$R-}
  Тип локальный. Рекомендуется использовать R+ при отладке, а затем отключать так как “+” увеличивает размер и замедляет работу программ. R+ осуществляет так же проверку виртуальных методов на состояние инициализации для экземпляра объекта, выполняющего вызов.

  Проверка переполнения стека (Stack Checking)
{$S+}
  Тип локальный. При “+” компилятор генерирует вначале каждой процедуры или функции код, который проверяет, достаточно ли в стеке выделено места для локальных переменных.

  Использование типизированного адресного оператора @ (Typed @ operator).
{$T-}
  Тип глобальный. Позволяет или запрещает использовать в тексте оператор @.

  Проверка параметров переменных строкового типа (Strict Var String).
{$V+}
  Тип локальный. Управляет проверкой типа при передачи строк в качестве параметров-переменных. В состоянии “+” выполняется строгая проверка типа. Требуется, чтобы формальный и фактический параметр имели идентичные строковые типы; при “-” длины могут не совпадать.

  Расширенный синтаксис. (Extended Syntax).
{$X-}
  Тип глобальный. При X+ вызов функции можно использовать как оператор, то есть результат функции может быть отброшен (функция может быть интерпретирована как процедура).

  Включение файла для компиляции (Include Directories).
{$I < имя файла >}
  Тип локальный. Сообщает компилятору о необходимости включить в компиляцию названный файл. Текст файла вставляется сразу за директивой. Расширение по умолчанию .PAS. Турбо-Паскаль допускает одновременно не более 15 входных файлов. Значит допускается вложенность до 15-ти уровней. Так же включаемый файл не может указываться в середине раздела операторов. Это означает, что все операторы между Begin и End раздела операторов должны быть в одном файле.

  Компоновка объектного файла. (Object Directories).
{$L < Имя-файла >}
  Тип локальный. Предписывает компилятору использовать указанный файл (.Obj) при компоновке компилируемой программы или модуля.
$nbsp Директива {$L} используется для компоновки кода Ассемблера для подпрограмм, описанных External.

  Размеры выделяемой памяти (Memory Sizes).
{$M < размер стека >, < размер динамической области >}.
  Тип глобальный. Размер-стека - целое число от 1024 до 65520. Для модуля размер- стека игнорируется (модуль использует стек основной программы). Размер динамической области - целое число от 0 до 65360. Директива {$M} при использовании в Unit не оказывает влияния на компиляцию.

  Компоновка оверлейного модуля.
{$O < Имя модуля >}
  Тип локальный. Можно преобразовать обычный модуль в оверлейный. Игнорируется при попытке объявить её в теле какого-либо модуля. Директива должна указываться в тексте программы после слова Uses. Любой модуль, который указывается в качестве параметра, должен быть откомпилирован с директивами {$O+} и {$F+}.

  Установить условие (Conditional Defines).
{$ Define < условие >}
  Определяет условия, которые можно использовать в операторах условной компиляции.

  Установить условие - значит с помощью данной директивы ввести некоторое слово, которое затем будет управлять компиляцией какого- либо фрагмента программы. За условием не должно следовать ничего кроме }.
Пример:

{$Define Debug}

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

{$Ifdef Debug}

Writeln(‘Отладка’);

{$Endif}

  Можно ввести несколько условий одновременно, причём условия должны отделяться друг от друга точкой с запятой (в меню).
  Допускается использование развёрнутой формы операторов условной компиляции.
Пример:

{$Ifdef Demo}

Code:= 1;

{$Else}

Code:= 2;

A:= ”Yes”;

{$EndIf}.

  Операторы условной компиляции могут быть вложенными, что позволяет контролировать несколько условий одновременно.
Пример:

{$Ifdef Var1}

{$Ifdef Var2}

A: = N;

{$Else}

A: = 0;

{$Endif}

{$Endif}.

  Файл - именованная область внешней памяти ПЭВМ (жесткого диска, гибкой дискеты, электронного "виртуального" диска), либо логическое устройство - потенциальный источник или приемник информации.

  Любой файл имеет три характерных особенности:

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

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

  В-третьих, длина вновь создаваемого файла никак не оговаривается при его объявлении и ограничивается только емкостью устройств внешней памяти.

  Файловый тип или переменную файлового типа можно задать одним из трех способов:

< имя > = FILE OF <тип>;

< имя > = ТЕХТ;

< имя > = FILE; .

  Здесь < имя > - имя файлового типа или файловой переменной,
  FILE, OF, TЕХТ - кодовые слова (англ.: файл, из, текст),
< тип > - любой тип Турбо-Паскаля, кроме файлов. Пример:

Type

Man=record

Name: string;

LastName: string;

End;

Men=file of Man;

Var

Staff: Men;

Numbers: file of real;

Book: Text;

A_File: File;

  В зависимости от способа объявления можно выделить три вида файлов:

типизированные (задаются предложением FILE OF ...),

текстовые (задаются предложением ТЕХТ),

нетипизированные (задаются предложением FILE).

  Вид файла, вообще говоря, определяет способ хранения информации в файле. Однако в Паскале нет средств контроля вида ранее созданных файлов. При объявлении уже существующих файлов программист должен сам следить за соответствием вида объявления характеру файла.

  Любой Турбо-Паскалевой программе доступны два предварительно объявленных файла со стандартными файловыми переменными: INPUT - для чтения данных с клавиатуры и OUTPUT - для вывода на экран. Стандартный Паскаль требует обязательного упоминания этих файлов в заголовке программы. В Турбо-Паскале это необязательно, вот почему заголовок программы можно опускать.
  Любые другие файлы, а также логические устройства становятся доступны программе только после выполнения особой процедуры открытия файла (логического устройства). Эта процедура заключается в связывании ранее объявленной файловой переменной с именем существующего или вновь создаваемого файла, а также в указании направления обмена информации: чтение из файла или запись в него.
  Связывание файловой переменной с именем файла осуществляется обращением к встроенной процедуре ASSIGN:
ASSIGN(< ф.п. >, < имя файла или л.у. >);
  Здесь < ф.п. > - файловая переменная (правильный идентификатор, объявленный в программе как переменная файлового типа);
  < имя файла или л.у. > - текстовое выражение, содержащее имя файла или логическое устройство. Пример:
Assign(Book,’PascalLecture.txt’);
  Если имя файла задается в виде пустой строки, например, ASSIGN(f, ‘’), то файловая переменная связывается со стандартным файлом INPUT или ОUТРUТ.

  Имя файла - это любое выражение строкового типа, которое строится по правилам определения имен в дисковой операционной ДОС) ПЭВМ:

  имя содержит до восьми разрещенных символов (разрешенные символы - это произвольные символы с кодами от 33 до 255, кроме символов пробел, точка, запятая, двоеточие, звездочка, знак вопроса, обратная косая черта, а также символ Забой - код 127 по стандарту АSCII);

  имя начинается с любого разрешенного символа;

  за именем может следовать расширение - последовательность до трех разрешенных символов; расширение, если оно есть, отделяется от имени точкой.

  Перед именем может ставиться так называемый путь к файлу - имя диска и/или имя текущего каталога и имена каталогов вышестоящих уровней.
  Имя диска содержит одну из латинских букв A..Z, после которой ставится двоеточие. Имена А: и В: относятся к дисковым накопителям на гибких дискетах, имена С:, D: и т.д.-к жестким дискам. Эти имена могут относиться также к одному или нескольким виртуальным дискам, созданным в операционной памяти ПЭВМ специальной командой RAMDRIVE в ходе выполнения файла автоустановки параметров ДОС СОNFIG.SYS.
  Если имя диска не указано, подразумевается устройство по умолчанию - то, которое было установлено в операционной системе перед началом работы программы.
  3а именем диска может указываться имя каталога, содержащего файл. Если имени каталога предшествует обратная косая черта, то путь к файлу начинается из корневого каталога, если черты нет - из текущего каталога, установленного в системе по умолчанию. За именем каталога может следовать одно или несколько имен каталогов нижнего уровня. Каждому из них должна предшествовать обратная косая черта. Весь путь к файлу отделяется от имени файла обратной косой чертой. Максимальная длина имени вместе с путем - 79 символов.
Пример: программа создает на диске C файл, содержащий возрастающие числа, закрывает файл, открывает его и полностью выводит его содержимое (в виде чисел).

Var

Num: file of Byte;

i:byte;

Begin

Assign(Num,'C:\Numbers.num');

Rewrite(Num);

For i:=0 to 255 do

Write(Num,i);

Close(Num);

Assign(Num,'C:\Numbers.num');

Reset(Num);

Repeat

Read(Num,i);

Writeln(i);

Until Eof(Num);

End.

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

  СОN означает консоль - клавиатуру или экран терминала. Турбо- Паскаль устанавливает различие между этими физическими устройствами по направлению передачи данных: чтение данных возможно только с клавиатуры, а запись данных - только на экран. Таким образом, с помощью логического устройства СОN нельзя, например, прочитать данные с экрана ПЭВМ, хотя такая аппаратная возможность существует.
  Ввод с клавиатуры буферируется: символы по мере нажатия на клавиши помещаются в специальный строковый буфер, который передается программе только после нажатия на клавишу "Ввод". Сам символ "Ввод" (код 13) в буфер не помещается и программе не передается. Буферизация ввода обеспечивает возможность редактирования вводимой строки стандартными средствами ДОС. При вводе символов осуществляется их эхо-повтор на экране ПЭВМ. В Турбо-Паскале можно прочитать любой символ клавиатуры, в том числе и "Ввод", сразу после нажатия на соответствующую клавишу без эхо- повтора.

  PRN - логическое имя принтера. Если к ПЭВМ подключено несколько принтеров, доступ к ним осуществляется по логическим именам LРТ1, LРТ2 и LРТЗ. Имена РRN и LРТ1 первоначально синонимы. Средствами ДОС можно переназначить имя РRN на любое другое логическое устройство, способное принимать информацию.
Стандартный библиотечный модуль PRINTER, входящий в библиотеку ТURВО.ТРL, объявляет имя файловой переменной LST и связывает его с логическим устройством LРТ1. Это дает возможность использовать простое обращение к принтеру.

  АUХ - логическое имя коммуникационного канала, который обычно используется для связи ПЭВМ с другими машинами. Коммуникационный канал может осуществлять и прием, и передачу данных, однако в Турбо-Паскалевой программе в каждый момент времени ему можно назначить только одну из этих функций. Как правило, в составе ПЭВМ имеются два коммуникационных канала, которым даются имена логических устройств СОМ1 и СОМ2. Первоначально имена АUХ и СОМ1 синонимы.

  NUL - логическое имя "пустого" устройства. Это устройство чаще всего используется в отладочном режиме и трактуется как устройство неограниченной емкости - приемник информации. При обращении к NUL как к источнику информации выдается признак конца файла ЕОF.
  Связывание логического устройства с файловой переменной осуществляется процедурой
ASSIGN(< файловая переменая >, '< имя файла >').
  Турбо-Паскаль никогда не связывает имена логических устройств с дисковыми файлами, и в этом смысле можно считать эти имена зарезервированными. Иными словами, нельзя, например, обратиться к дисковому файлу с именем РRN - Турбо-Паскаль всегда интерпретирует такой запрос как обращение к принтеру.

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

  Для чтения файл инициируется с помощью процедуры:
RESET (< ф.п. >);
  Здесь < ф.п. > - файловая переменная, связанная ранее процедурой ASSIGN() с уже существующим файлом или логическим устройством - источником информации.
  При выполнении этой процедуры дисковый файл или логическое устройство подготавливается к чтению информации. Внутренняя Турбо- Паскалевая переменная-указатель, связанная с этим файлом, указывает на начало файла, т.е. на компонент с порядковым номером 0.
  Если делается попытка инициировать чтение из несуществующего файла или логического устройства РRN, возникает ошибка периода исполнения, которая может быть сообщена программе с помощью встроенной функции IORESULT типа WORD, которая в этом случае имеет ненулевое значение. (Можно выяснить, существует ли требуемый файл на диске).
  Турбо-Паскаль допускает к типизированным файлам, открытым с помощью процедуры RESET (т.е. для чтения информации), обращаться с помощью процедуры WRITE (т.е. для записи информации). Такая возможность позволяет легко обновлять ранее созданные типизированные файлы и при необходимости расширять их.

  Встроенная процедура REWRITE(< ф.п. >) инициирует запись информации в файл или логическое устройство, связанное ранее с файловой переменной < ф.п. >. Процедурой REWRITE нельзя инициировать запись информации в ранее существовавший дисковый файл: при выполнении этой процедуры старый файл уничтожается и никаких сообщений об этом в программу не передается. Новый файл подготавливается к приему информации и его указатель устанавливается в нуль.

  Встроенная процедура АРРЕND(< ф.п. >) инициирует запись в ранее существовавший текстовый файл для его расширения - указатель файла устанавливается в его конец. Не следует забывать, что процедура АРРЕND применима только к текстовым файлам. Если текстовый файл ранее уже был открыт с помощью RESET или REWRITE, использование процедуры APPEND приведет к закрытию этого файла и открытию ею вновь, но уже для добавления записей.

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

  CLOSE(< ф.п. >)
Закрывает файл, однако связь файловой переменной с именем файла, установленная ранее процедурой АSSIGN(), сохраняется.
  Поскольку связь файла с файловой переменной сохраняется, файл можно повторно открыть без дополнительного использования процедуры ASSIGN.

  RENAME (< ф.п. >, < новое имя >)
Переименовывает файл < ф.п. >.
  Перед выполнением процедуры необходимо закрыть файл, если он ранее был открыт.

  ERASE(< ф.п. >).
Уничтожает файл < ф.п. >

  FLUSH(< ф.п. >).
Очищает внутренний буфер файла и, таким образом, гарантирует сохранение всех последних изменений файла на диске.
  Любое обращение к файлу в Турбо-Паскале осуществляется через некоторый внутренний буфер, что необходимо для согласования bmsrpemmecn представления файлового компонента - записи с принятым в ДОС форматом хранения данных на диске. В ходе выполнения процедуры FLUSH все новые записи будут действительно записаны на диск. Процедура игнорируется, если файл был инициирован для чтения процедурой RESET.

  Функция ЕОF(< ф.п. >): BOOLEAN.
Логическая функция, тестирующая конец файла. Возвращает ТRUE, если файловый указатель стоит в конце файа. При записи это означает, что очередной компонент будет добав лен в конец файла, при чтении - что файл исчерпан.

  MKDIR(< имя каталога >).
Создает новый каталог на указанном диске.
Имя уже существующего каталога не может быть последним именем в пути, т.е. именем вновь создаваемого каталога.

  С помощью внешних процедур (функций) можно вызывать из Турбо- Паскалевой программы процедуры или функции, написанные на языке ассемблера и других языках. Машинно-ориентированный язык ассемблера предоставляет квалифицированному программисту богатейшие возможности использования всех особенностей архитектуры ПЭВМ. Ассемблерные программы выполняются значительно быстрее и занимают меньший объем памяти, чем Турбо-Паскалевые программы, однако низкий уровень языка существенно снижает производительность труда программиста и резко усложняет отладку программ, Как правило, на языке ассемблера пишутся сравнительно небольшие фрагменты программ, учитывающие особенности архитектуры ПЭВМ, которые невозможно использовать в Турбо- Паскалевой программе.   Внешняя процедура (функция) в Турбо-Паскалевой программе объявляется заголовком, за которым следует зарезервированное слово ЕХТЕRNАL, например:

Function LoCase(ch: char): char; external;

Procedure Swapping(Var a, b; N: word); externa1;

  Как видим, тело внешней процедуры (функции) отсутствует его заменяет кодовое слово ЕХТЕRNАL. Для подключения ассемблерной программы необходимо предварительно ее откомпилировать и получить OBJ - файл с перемещаемым кодом программы. Непосредственно перед описанием внешней процедуры (функции) в основной программе вставляется директива компилятора {$L < имя файла >}, где < имя файла > - имя OBJ - файла. Диск и каталог, в котором следует искать этот файл, если он не обнаружен в текущем каталоге, указывается опцией "OPTIONS/DIRECTORIES/OBJECT DIRECTORIES" ИПО.

  Разумеется, в рамках этой книги совершенно невозможно рассмотреть методику разработки программ на языке ассемблера - это предмет самостоятельной книги. Тем не менее, следует дать один совет. Прежде чем браться за разработку ассемблерной процедуры, тщательно взвесьте специфические потребности разрабатываемой программы и возможности Турбо-Паскаля: может оказаться, что, оставаясь только в рамках Турбо-Паскаля, Вы решите задачу намного проще и быстрее, хотя, разумеется, Ваша программа и не будет оптимальной по скорости вычислений и расходуемой памяти. Замечено, что производительность труда программиста почти не зависит от языка и составляет 10...20 операторов отлаженной программы в день. Один оператор Турбо- Паскаля реализуется десятками машинных команд, вот почему использование языков высокого уровня, к которым относится Турбо- Паскаль, значительно ускоряет разработку программ.

  Перед передачей управления внешней процедуре (функции) Турбо- Паскалевая программа заталкивает параметры обращения в программный стек в том порядке, как они перечислены в заголовке процедуры (функции). Ассемблерная процедура должна сохранить регистры BP, SP, SS и DS центрального процессора в самом начале своей работы и восстановить содержимое этих регистров перед возвратом управления в Турбо-Паскалевую программу. Остальные регистры можно не сохранять и соответственно не восстанавливать.
Параметры могут передаваться по ссылке или по значению. Если параметр передается по ссылке, в стек заталкивается указатель, содержащий абсолютный адрес параметра; если по значению - в стек заталкивается сам параметр, точнее - его значение. Параметры, объявленные в заголовке с предшествующим словом VAR, всегда передаются по ссылке. Параметры- значения могут передаваться по ссылке или по значению, в зависимости от длины внутреннего представления соответствующею параметра. В общем случае используется следующее правило: если длина внутреннего представления параметра-значения составляет 1, 2 или 4 байта, само значение параметра заталкивается в стек. Точно так же через стек передаются и все вещественные данные длиной в 4, 6, 8 и 10 байт (в версии 4.0 эти данные передаются через стек сопроцессора 8087/80287, в версии 5.0 - через стек центрального процессора 8086/80286). Во всех остальных случаях, если длина внутреннего представления больше 4 байт, соответствующий параметр передается по ссылке.

  Ассемблерные функции должны возвращать результат с помощью регистров центрального процессора или сопроцессора в зависимости от длины внутреннего представления результата по следующим правилам:

длиной в 1 байт - в регистре АL;

длиной в 2 байта - в регистре АХ;

длиной в 4 байта - в регистрах DХ:АХ (старшее слово в DХ);

тип REAL (б байт) - в регистрах DХ:ВХ:АХ;

типы SINGLE, DOUBLE, EXTENDED и COMP - через стек сопроцессора 8087/80287;

указатели - в регистрах DХ:АХ (сегмент в DХ);

строки возвращаются по ссылке: адрес начала строки помещается в DХ:АХ (сегмент в DХ).

  Все ассемблерные процедуры должны размещаться в сегменте с именем СОDЕ, а имена процедур и функций должны быть объявлены директивой PUBLIC. Локальные переменные необходимо размещать в сегменте с именем DАТА. Все имена, объявленные в интерфейсной части модулей Турбо-Паскалевой программы, становятся доступны ассемблерной процедуре (функции) после их объявления директивой ЕХТRN.

  В Турбо-Паскале имеется возможность включения в программу фрагментов, написанных непосредственно в машинных кодах. Для этого используется зарезервированное слово INLINE, за которым в круглых скобках следует один или несколько элементов машинного кода, разделяемых косыми чертами. Элемент кода, в свою очередь, строится из одного или более элементов данных, разделенных знаками "+" или "-".
  В качестве элемента данных может использоваться целая константа, идентификатор (переменной, константы или функции) или ссылка на счетчик адреса "*". Каждый элемент данных вызывает генерацию 1 или 2 байт кода программы. Значение этого кода получается сложением или вычитанием элементов данных в соответствии с разделяющим их знаком. Значением идентификатора переменной, константы, функции является адрес соответствующего объекта, значением ссылки на счетчик адреса является тот адрес, по которому будет размещаться следующий байт кода.
  Элемент кода будет генерировать 1 байт кода, если этот элемент состоит только из целых констант и значение результата не превышает 1 байта, т.е. находится в диапазоне от 0 до 255. Если значение превышает 255 или элемент кода содержит ссылку на счетчик адреса, генерируются 2 байта. Знаки ">" и "<" могут использоваться для отмены автоматического выбора размера генерируемого кода. Если элемент кода начинается со знака "<", в код заносится только один младший байт, даже если само значение занимает 2 байта. Наоборот, если элемент начинается со знака ">", в код заносится 2 байта (старший байт может оказаться нулевым).
  Значением идентификатора, как уже говорилось, является смещение соответствующего объекта. Если переменная. глобальная, смещение задается относительно сегмента данных, хранящегося в регистре DS, если переменная локальная, - относительно сегмента стека (регистр SР). Базовым сегментом типизированной константы является сегмент кода (регистр СS).
  В следующем примере приводятся две короткие процедуры, с помощью которых можно вывести данные через любой порт ПЭВМ:

Function InPort(Port: Word): Word;

Var

pp: Word;

cc: Char;

Begin

pp:= port;

in1ine( {assembler code: }

$8b/$96/pp/ { MOV DX,pp[bp] }

$EC/ { IN AX,DX }

$88/$86/cc { MOV cc[bp],AX }

);

InPort:= ord(cc);

End;

Procedure OutPort(Port, Bt: Word);

Var

pp: Word;

cc: Char;

Begin

pp:=port;

cc:=chr(Bt);

in1ine(

$8a/$86/cc/ { MOV AX,cc[bp] }

$8b/$96/pp/ { MOV DX,pp[bp] }

$EE { OUT DX,AX }

);

END;

  Операторы INLINE могут произвольным образом смешиваться с другими операторами Турбо-Паскаля, однако при выходе из процедуры (функции) содержимое регистров BP, SP, DS и SS должно быть таким же, как и при входе в нее.

  Турбо - Паскаль предоставляет программисту практически неограниченные возможности использования любых функций стандартной операционной системы PC DOS (MS DOS). При внимательном анализе материала этой книги Вы, очевидно, заметите, что большую часть составляет описание многочисленных библиотечных процедур и функций. Собственно язык Паскаль весьма прост и лаконичен, что, по мнению многих специалистов, и послужило одной из причин его широкого распространения. Значительная же часть библиотечных процедур и функций является по существу своеобразным интерфейсом между языковыми средствами Турбо-Паскаля и функциями операционной системы. Разумеется, можно только приветствовать усилия разработчиков Турбо-Паскаля по созданию мощных библиотек TURBO.TPL и GRAPH.TPU, однако ясно что таким способом невозможно запрограммировать все допустимые обращения к средствам ДОС. Вот почему в Турбо-Паскаль включены две процедуры, с помощью которых программист может сам сформировать вызов той или иной функции ДОС.
  Следует учесть, что единственным механизмом обращения к функциям операционной системы является инициация программного прерывания. Прерывание - это особое состояние вычислительного процесса. В момент прерывания нарушается нормальный порядок выполнения команд программы, и управление передается специальной процедуре, которая входит в состав ДОС и называется процедурой обработки прерывания. Каждое прерывание характеризуется в рамках ДОС порядковым номером и связано со своей процедурой обработки. В архитектуре центрального процессора ПЭВМ предусмотрены прерывания двух типов: аппаратные и программные. Аппаратные прерывания создаются схемами контроля и управления ПЭВМ и сигнализируют операционной системе о переходе какого-либо устройства в новое состояние или о возникновении неисправности. Программные прерывания инициируются при выполнении одной из двух специальных команд (INТ или INТО) и служат для обращения к средствам ДОС.

  Всего в ДОС имеется около 40 программных прерываний, каждое из которых может активизировать одну или несколько функций ДОС. Одно из прерываний - с номером 33 ($21 - шестнадцатиричное число) обеспечивает доступ к 85 функциям, а всего в ДОС имеется более 200 разнообразных функций.

  Описываемые ниже процедуры входят в состав библиотечного модуля DOS и становятся доступными после объявления USES DOS. При возникновении программного прерывания в большинстве случаев необходимо передать процедуре обработки прерывания некоторые параметры, в которых конкретизируется запрос нужной функции. Эти параметры, а также выходная информация передаются от программы к процедуре и обратно через регистры центрального процессора. В модуле DOS для этих целей определен специальный тип:

Type

Registers = record

Case integer of

0:(AX, BX, CX, 0X, BP, SI, DI, DS, ES, Flags: word);

1:(AL, AH, BL, BH, CL, CH, DL, DH: byte)

end;

  Как видим, этот тип имитирует регистры центрального процессора и дает возможность обращаться к ним как к 16-битным или 8-битным регистрам.
  С помощью процедуры INTR инициируется программное прерывание с требуемым номером;
формат обращения: INTR(< N >, < регистры >)
Здесь < N > - выражение типа ВYТЕ, означающее номер прерывания;
< регистры > - переменная типа REGISTERS, в которой процедуре обработки прерывания передается содержимое регистров и возвращается выходная информация.

  Так, прерывание с номером 18 ($12) возвращает в регистре AX объем оперативной памяти ПЭВМ. Пример программы выводящей на экран сообщение об этом объеме:

Program IntrDem;

Uses DOS;

Var

r: registers;

Begin

Intr($12, r);

writeln('Объем памяти = ', r.АХ, ' Кбайт')

END.

  Инициирует прерывание с номером 33 ($21);
формат обращения: MSDOS(< регистры >);
Здесь < регистры > - переменная типа REGISTERS, содержащая значения регистров на входе и выходе процедуры обработки прерывания.

  Программное прерывание с номером 33 ($21) стоит особняком: как уже говорилось, оно дает доступ к большому количеству функций ДОС (этим прерыванием вызывается 85 функций). Рассматриваемая процедура полностью эквивалентна вызову процедуры INTR c номером прерывания 33. Программа примера выведет на экран версию операционной системы:

Program MsDosDemo;

Uses DOS;

Var

R: registers;

Begin

r.AH: = $30;

MsDos(r);

write1n ('Версия операционной системы: г.АL, '.', г.АН)

END.

  При написании процедур обработки прерываний существенными являются два обстоятельства. Во-первых, процедура обработки прерывания не должна искажать работу прерванной программы. Для этого необходимо сначала сохранить регистры центрального процессора, а перед выходом из процедуры - восстановить их. Во- вторых, процедура должна строиться по принципу реентерабельности (повторной входимости): ее работа может быть прервана в любой момент другими прерываниями и ДОС может обратиться к соответствующей функции до завершения обработки предыдущего прерывания.
  Турбо - Паскаль предоставляет программисту возможность написать процедуру обработки прерывания на языке высокого уровня, хотя обычно такие процедуры пишутся на языке ассемблера.
  Турбо-Паскалевая процедура обработки прерывания должна начинаться зарезервированным словом INTERRUPT (англ. прерывание), например:

Procedure IntProc(Flags, CS, IP, AX, BX, CX, DX, SI, DF, 0S, ES, BP: word); inerrupt;

begin

.......

end;

Список формальных параметров должен быть именно таким, как в примере: через эти параметры вызова все регистры прерванной программы становятся доступны процедуре обработки прерывания. Кодовое слово INTERRUPT приводит к генерации специальных машинных кодов, обеспечивающих заталкивание регистров в стек при входе в процедуру и извлечение их из стека перед выходом из нее.

При входе в процедуру:

push ax

push bx

push cx

push dx

push si

push di

push ds

push es

push bp

mov bp,si

sub sp,LocalSize

mov ax,SEG DATA

mov ds,ax

При выходе из процедуры:

mov sp,bp

pop bp

pop es

pop ds

pop di

pop si

pop dx

pop cx

pop bx

pop ax

irep

  В самой процедуре обработки прерывания не рекомендуется обращение к другим функциям ДОС, так как некоторые из них, в том числе все функции ввода-вывода, нереентерабельны.
  Для связи с любыми процедурами прерываний, а следовательно и с процедурами, написанными программистом, используются векторы прерываний - четырехбайтные абсолютные адреса точек входа в эти процедуры. Векторы прерываний располагаются в младших адресах оперативной памяти, начиная с нулевого адреса: прерывание номер 0 - по адресу 0, номер 1 - по адресу 1 * 4 = 4, номер N - по адресу N*4.
  С помощью следующих двух процедур программист может прочитать содержимое любого вектора или установить его новое значение.
  Процедура GETINTVECT. Возвращает вектор прерывания с указанным номером;
формат обращения GETINTVECT(< N >, < вектор >> )
Здесь < N > - выражение типа ВYТЕ, содержащее номер прерываиия;
< вектор > -переменная типа РOINTER, в которой возвращается адрес точки входа в процедуру обработки прерывания.
  Пример: программа выводит на экран содержимое всех ненулевых векторов прерываний.

Uses DOS;

var

i: byte;

p: pointer;

Begin

for i:= 0 to 255 do

Begin

GetIntVec(i, p);

if (Seg(p^) <> 0) or (Ofs(p^) <> 0) then

write1n('N = ', i:3, 'Seg = ', Seg(p^):5, 'Ofs =', Ofs(p^):5);

End;

End.

  Процедура SETINTVEC. Устанавливает новое значение вектора прерывания;
формат обращения SETINTVEC(< N >>, < адрес >);
Здесь < адрес > - выражение типа РOINTER , в котором задается адрес точки входа в процедуру обработки прерывания.
  При нормальном завершении Турбо-Паскалевой программы она выгружается из памяти, что делает невозможным разработку резидентных в памяти процедур обработки прерываний. Вы можете прекратить работу программы и оставить ее в памяти, если воспользуетесь процедурой КЕЕР.
  Процедура КЕЕР. Завершает работу программы и оставляет ее в памяти;
формат обращения КЕЕР(< код >)
< код > - выражение типа WORD, в котором содержится код завершения программы.
  Код завершения представляет собой фактически единственный механизм передачи сообщений от запущенной программы к программе, которая ее запустила. Он может быть проанализирован в вызывающей программе с помощью функции DOSEXITCODE.
  Функция DOSEXITCODЕ. Возвращает значение типа WORD - код завершения подчиненной программы.

  Из Турбо-Паскалевой программы можно запустить любую другую готовую к работе программу. Для этого используется процедура ЕХЕС из библиотечного модуля DOS;
формат обращения ЕХЕС(< имя >, < параметры >);
Здесь < имя > - выражение типа STRING, в котором задается имя файла с вызываемой программой;
< параметры > - выражение типа STRING, в котором передаются параметры вызова.
  Имени запускаемой программы должен предшествовать путь к файлу. Параметры передаются запускаемой программе в виде текстовой строки и могут быть проанализированы ею с помощью двух следующих функций.
  Функция PARAMCOUNT. Возвращает общее количество параметров вызова программы (значение типа WORD).
Обращение PARAMCOUNT
  Параметры вызова обычно следуют в командной строке ДОС сразу за именем вызываемой программы и отделяются от этого имени и друг от друга пробелами, например:
  С:\ТURBO MyProg.Рas
  C:\SIAM A:\Sistem.Sia
  Здесь MyProg.Pas и A:\Sistem.Sia - параметры, передаваемые программам TURBO и SIAM.
  При вызове программы непосредственно из среды Турбо-Паскаля ей можно передать параметры с помощью опции OPTIONS/PARAMETERS
  Функция PARAMSTR Возвращает значение типа STRING, соответствующее нужному параметру вызова,
формат обращения PARAMSTR(< N >)
Здесь < N > - выражение типа WORD, задающее порядковый номер параметра.
  Использование процедуры ЕХЕС имеет ряд специфических особенностей. Прежде всего необходимо отметить, что сама Турбо- Паскалевая вызывающая программа остается резидентной в памяти, поэтому она не должна занимать всю оперативную память. Объем выделяемой программе памяти регулируется опцией OPTIONS/COMPILER/MEMORY SIZE или директивой компилятора {$M . . }. По умолчанию параметры этой опции таковы (0 и 655360 байт соответственно), что Турбо-Паскалевая программа занимает весь доступный объем памяти и вызываемая программа не будет загружена. Полезно включить в текст вызывающей программы директиву компилятора, в которой изменяются принятые по умолчанию размеры памяти. Это можно сделать, например, так:
{$М 2048, 0, 0}
  Такая директива ограничивает используемую программой область стека объемом 2 Кбайт и исключает возможность использования в ней динамической памяти. Разумеется, Вы можете установить и другие значения параметров в этой директиве.

  Далее, специфические особенности исполнения Турбо-Паскалевых программ требуют изменения стандартных значений некоторых векторов прерываний. К ним относятся векторы со следующими шестнадцатеричными номерами: $00, $02, $18, $23, $24, $34, $35, $36, $37, $38, $39, $3А, $3В, $3С, $3D, $3Е, $3F, $75.
  Начальные значения этих векторов сохраняются в восемнадцати переменных с именами SAVEINTXX из библиотечного модуля SYSTEM, где ХХ -шестнадцатеричный номер прерывания. Поэтому непосредственно перед запуском внешней программы и сразу после возврата из нее рекомендуется вызвать библиотечную процедуру без параметров SWAPVECTORS, которая обменивает содержимое векторов прерывания и перечисленных переменных.
Пример: программа воспринимает с клавиатуры любую команду ДОС, затем вызывает командный процессор СОММАND.СОМ операционной системы и передает ему эту команду.

Program ExecDemo;

{$M 1024, 0, 0}

Uses DOS;

Var

st: string [79];

Begin

Write(‘Введите команду DOS:’);

Readln(st);

if st <> '' then

Begin

st:= 'C:\'+st,;

SwapVectors;

Exec(GetEnv('COMSPEC'), st);

SwapVectors;

End;

End.

  Обратите внимание: для указания файла СОММАND.СОМ и пути к нему использовано обращение к библиотечной функции GETENV, с помощью которой можно получить параметры настройки операционной системы. В частности, параметр СОМSPЕС определяет спецификацию файла, содержащего командный процессор.
  С помощью следующей несложной программы можно вывести на экран ПЭВМ список всех параметров настройки ДОС.

Program EnvParDemo;

Uses DOS;

Var

i: integer;

Begin

For i:= 0 To EnvCount Do

Writeln(EnvStr(i));

End.

  Функция ENVCOUNT. Возвращает значение типа INTEGER, в котором содержится общее количество установленных в ДОС параметров.
Обращение ENVCOUNT.
  Функция ENVSTR. Возвращает значение типа STRING, содержащее имя и значение нужного параметра настройки операционной системы;
формат обращения ENVSTR(< N >) Здесь < N > - выражение типа INTEGER, в котором указывается номер параметра.
  Эта функция возвращает строку вида NАМЕ = VАLUЕ, где NАМЕ - имя, а VALUE - значение соответствующего параметра настройки.
  Функция GETENV возвращает значение типа STRING, в котором содержится параметр настройки ДОС;
формат обращения GETENV (< имя >) Здесь < имя > - выражение типа STRING, определяющее имя параметра.
  Эта функция имеет параметр обращения NАМЕ и возвращает значение VALUE (см. функцию ENVSTR).

  Как уже говорилось в, максимальный размер модуля не может превышать 64 Кбайт, однако количество модулей не ограничено, что дает возможность разрабатывать весьма крупные программы, занимающие, например, всю доступную оперативную память ПЭВМ (приблизительно 580 Кбайт). Однако в некоторых случаях и этот объем может оказаться недостаточным. Турбо-Паскаль предоставляет в распоряжение программиста простой и достаточно эффективный механизм оверлея, с помощью которого Вы сможете создавать программы практически неограниченной длины (следует оговориться, что речь идет только о длине кода программ; два важных размера - длина стека данных и программного стека - в Турбо-Паскале не может превышать 64 Кбайт независимо от структуры программы).
  Оверлей - это такой способ использования оперативной памяти, при котором в один и тот же участок памяти, называемый оверлейным буфером, попеременно по мере надобности загружаются различные оверлейные (перекрывающиеся) модули. При этом все оверлейные модули в готовом к работе виде хранятся на диске, а в оперативной памяти в каждый момент находится лишь один активный модуль и, возможно, небольшое число других неактивных модулей.
  Пусть, например, программа состоит из главной части МАIN и двух модулей А и В. Пусть также LМ, LА и LВ - длина соответственно главной части и обоих модулей, причем LA > LВ. Тогда неоверлейная программа займет в памяти LМ + LA + LВ байт, в то время как оверлейная программа лишь LМ + LА.
  При исполнении оверлейной программы в память первоначально загружается главная часть и один из модулей, например А. Если в процессе исполнения программы встретится обращение к модулю В, программа приостановит свою работу, с диска в оверлейный буфер будет загружен модуль В (модуль А при этом будет частично уничтожен), после чего программа продолжит свою работу. Если в дальнейшем встретится обращение к А, точно таким же образом будет загружен модуль А, причем загрузка нужных модулей в оверлейный буфер осуществляется автоматически и программисту не нужно об этом заботиться.
  Описанный механизм выявляет главное преимущество оверлейной структуры: объем памяти, занимаемой оверлейной программой, определяется длиной главной части н наибольшего из перекрывающихся модулей, в то время как при неоверлейной структуре в этот объем входит суммарная длина всех модулей. Чем больше в программе оверлейных модулей и чем меньше длина наибольшего из них, тем больший выигрыш в памяти дает оверлейная структура. Однако совершенно очевиден и главный недостаток таких структур: на каждую загрузку оверлейного модуля с диска в оверлейный буфер требуется дополнительное время, поэтому оверлейная программа будет в общем случае исполняться с меньшей скоростью.
  Работа оверлейных программ обеспечивается с помощью процедур, и функций библиотечного модуля OVERLAY, входящего в библиотечный файл TURBO.TPL.
  Оверлейные программы нужно создавать в такой последовательности:

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

  В главной части программы необходимо указать с помощью директив компилятора вида {$0 < имя >} те модули, которые будут оверлейными, например:

Program Main;

Uses CRT, DOS, Graph, Overlay, UnitA, UnitB;

{$O DOS}

{$O UNITA}

{$O UNITB}

  Учтите, что из всех стандартных библиотечных модулей только модуль DOS может быть оверлейным, остальные же модули (CRT, Graph, Printer и т.д.) не могут объявляться оверлейными.

  Необходимо предусмотреть перед первым по логике работы программы обращением к какому-либо оверлейному модулю вызов процедуры инициализации оверлея OVERINIT. Здесь же, если это необходимо, следует установить размер оверлейного буфера и указать возможность использования расширенной памяти (см. ниже).

  Наконец, в начале главной программы и каждого оверлейного модуля необходимо поместить директивы компилятора {$O+} и {$F+} или установить опции OPTIONS/COMPILE/FORCE FAR CALLS и OPTIONS/COMPILE/OVERLAYS ALLOWED в состояние ОN, после чего следует откомпилировать программу на диск. Программа готова к работе.

  Необходимо использовать дальнюю модель вызова - это обязательное условие.

  Директива {$O+}, строго говоря, не является обязательной. Если она указана, то при вызове любой процедуры или функции программа будет помещать все фактические параметры обращения в резидентную (неоверлейную) часть памяти, что позволяет из одного оверлейного модуля вызывать процедуры и функции любого другого оверлейного же модуля.
Процедура OVRINIT. Инициализирует оверлейный файл;
формат обращения OVRINIT(< имя >)
Здесь < имя > - выражение типа STRING, означающее имя файла с оверлейной частью программы.
При компиляции оверлейной программы создается специальный файл с именем, совпадающим с именем главной программы, и расширением .OVR. В этот файл компилятор помещает все оверлейные модули, из него же эти модули будут загружаться в оверлейный буфер в процессе исполнения программы. Файл с оверлейной частью программы должен размещаться в том же каталоге, что и файл с главной частью (с расширением .ЕХЕ).
  Пример: пусть файл с главной частью программы называется MAIN.РАS, в программе используются два оверлейных модуля, помещаемые в файлы UNITA.PAS и UNITB.PAS.

Program OverlayDemo; {Текст главной программы нужно поместить в файл МAIN.РАS.}

{$F+,0+}

Uses Over1ay, UnitA, UnitB;

{$0 UnitA}

{$0 UnitB}

Begin

OvrInit('MAIN.OVR');

SubA

End.

{---------------------------------------------------------------}

UNIT UnitA; {Текст модуля нужно поместить в файл UNITA.PAS}

{$F+,0+}

Interface

Uses UnitB;

Procedure SubA;

Implementation

Procedure SubA;

const

st = 'Работает модуль’;

Begin

Writeln(st, 'A');

SubB(st);

End;

End.

{---------------------------------------------------------------}

Unit UnitB; {Текст модуля нумно поместить в файл UNITB.PAS.}

{$F+,0+}

Interface

Procedure SubB(s: string);

Implementation

Procedure SubB;

Begin

Writeln(s, 'B');

End;

End.

  0бычно размер оверлейного буфера автоматически определяется таким, что в нем может разместиться самый крупный из всех оверлейных модулей. Программист может увеличить размер буфера. Тогда при загрузке в буфер очередного модуля программа проверит, достаточно ли в буфере свободного места, и, если места достаточно, загрузит новый модуль сразу за старым, который таким образом не будет уничтожен. Такой механизм способствует минимизации потерь времени на перезагрузку модулей. Если установлен очень большой размер буфера, то в нем, возможно, смогут разместиться все оверлейные модули и потери времени будут сведены к нулю, однако в этом случае оверлейная структура становится просто ненужной.
  Процедура OVRSETBUF. Устанавливает больший, чем по умолчанию, размер оверлейного буфера;
формат обращения OVRSETBUF(< длина >)
Здесь < длина > - выражение типа LONGINT, определяющее новую длину буфера.
  Новая длина задается в байтах и не может быть меньше той, что устанавливает сама система автоматически. Расширение буфера идет за счет соответствующего уменьшения доступной динамической памяти, поэтому к моменту вызова этой процедуры куча должна быть пустой.
  Функция OVRGETBUF. Возвращает значение типа LONGINT, содержащее текущий размер кучи.
Обращение OVRGETBUF.

Если Ваша ЭВМ имеет расширенную память (общий объем памяти свыше 1024 Кбайт), Вы можете использовать эту память для размещения в ней оверлейного файла .ОVR. Поскольку время доступа к расширенной памяти значительно меньше времени чтения с диска, такое размещение увеличивает скорость исполнения оверлейной программы.
  Процедура OVRINITEMS обеспечивает использование расширенной памяти.
Обращение OVRINITEMS
  При обращении к этой процедуре программа прежде всего проверит, подключена ли к Вашей ЭВМ ЕМS-память (от англ. Expanded Memory Specification - расширенная память,) нужного для размещения оверлейной части объема. Если это так, то оверлейный файл будет считан в расширенную память, сам файл будет закрыт и программа будет считывать оверлейные модули из этой памяти. Если же расширенная память отсутствует или ее объем недостаточен для размещения оверлейного файла, обращение к процедуре игнорируется и программа будет считывать оверлейные модули с диска.

  В Турбо-Паскале имеется пять предварительно объявленных массивов: МЕМ, МЕМW, МЕМL, РОRТ и РОRТW. Первые три обеспечивают доступ к любому участку оперативной памяти по абсолютному адресу, два другие - доступ к портам ввода-вывода.
  Компонентами массива МЕМ являются данные типа ВYТЕ, массива МЕМW - типа WORD, массива МЕМL - типа LONGINT. Обращение к элементам этих массивов, т.е. их индексация, имеет специальный вид: каждый индекс представляет собой абсолютный адрес и состоит из двух выражений типа WORD; первое дает сегментную часть адреса, второе - смещение; выражения разделяются двоеточием:

Mem[$0000:$1000]:= 0;

DataMem:= MemW[Seg(p):Ofs(p)];

MemLong:= MemL[64:i*SizeOf(rea1)];

  Как следует из технического описания операционной системы МS DOS, в ПЗУ BIOS по адресу $F000:$FFFE зашит байт-идентификатор типа компьютера. Таким образом можно определить тип компьютера, на котором запускается программа:

Program DMA_Demo;

Begin

Write('Тип компьютера: ');

Case Mem[$FOOO:$FFFE] of

$FF: writeln('PC');

$FE: writeln('XT');

$FD: writeln('PCjr');

$FC: write1n('AT');

$F9: writeIn('совместимый c PC');

End

End.

  Компонентами массива РОRТ являются байты, а массива РОRТW - слова. Индексами этих массивов должно быть выражение типа ВYТЕ, указывающее номер нужного порта. Присвоение значения элементу массива РОRТ или РОRТW приведет к записи в порт, упоминание элемента в выражении - к чтению из порта. Компоненты массивов РОRТ и РОRТW нельзя передавать в качестве параметров процедурам или функциям. Эти идентификаторы нельзя употреблять без индексных выражений.

  Мы уже знаем, что на этапе проектирования архитектуры Турбо- Паскаль поддерживает модульное проектирование. Но наиболее эффективен Турбо-Паскаль на этапе детального проектирования.
  Процесс проектирования программ - это процесс решения проблем человеком, подобно другим процессам решения проблем в науке и технике. Из-за ограниченных возможностей человеческом мозга, не способного одновременно охватить все мельчайшие детали, необходимо определить некоторый способ представления проекта. Это представление затем будет использоваться как средство общения. Результирующий код должен выводиться из этого представления просто и однозначно. Приемы такого представления могут быть классифицированы как графические и языковые.
  К графическим приемам относят блок-схемы и диаграммы Нэсси- Шнейдерман.
  Блок-схема (схема) - наиболее распространенная и наиболее понимаемая форма графического представления. Она была предложена фон Нейманом как средство документации программ. Для каждой программной структуры существует соответствующая графическая схема. Основное преимущество этого метода - простота и наглядность. Однако, у схем есть и недостатки:

их нотации несовместимы с нотациями, используемыми в программных спецификациях и в реализациях;

невозможен прямой ввод в ЭВМ и вывод из нее, практически мало средств автоматизированной поддержки;

нет эффективном способа управления уровнем детализации в рамках каждой схемы;

нотации недостаточны для проектирования крупномасштабных систем ПО.

Диаграммы Нэсси-Шнейдерман призваны поддерживать структурное программирование. Предложены специальные графические прямоугольные изображения для базовых структур. Программа описывается с использованием этих изображений. Основные характеристики:

функциональная область хорошо определена;

не разрешены произвольные передачи управления;

легко определяются границы локальных и глобальных данных;

легко представляются рекурсивные свойства.

Среди приемов языкового представления наиболее известным является использование псевдокодов или языков проектирования программ.
  Язык проектирования (РDL) - это неграфическая форма представления проекта программы, характерной особенностью которой является возможность оформления шагов обработки на естественном языке с использованием специальных предопределенных слов (кодовых вставок) для описания операторов ветвлений, циклов и описания данных. Внесение изменений в алгоритм программы может быть осуществлено при помощи редактора текстов, имеющемся в составе ПО всех современных ЭВМ.
  Разработка исполнительной программы заключается в преобразовании описания шагов обработки и описания данных, выполненных на естественном языке, в операторы языка программирования. Наиболее приспособленным для поддержки методологии структурного программирования, является РАSCАL. На его базе элементарно строится язык проектирования PDL-PASCAL.
  Действия разработчика на каждом шаге Детализации заключаются в подстановке одной из структур, изображенных на рисунке вместо прямоугольников на схеме, полученной на предыдущем шаге. Доказано, что такая процедура детализации позволяет построить логику любом алгоритма. Выбор необходимой структуры для подстановки и составляет

суть проектирования на этом этапе.

  Начиная с версии 5.5, Турбо-Паскаль охватывает еще один современный метод проектирования программ, описанный выше как обьектно-ориентированное проектирование.
  Объект - это структура данных, содержащая поля данных (подобно записи) различных типов и заголовки методов.
Синтаксис объявления объекта:

< ИмяПотомка > = Object(< ИмяПредка >)

поле;

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

поле;

метод;

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

метод;

End;

  Метод - это процедура или функция, объявленные внутри объявления элемента типа объект и предназначенная в обычно для работы с полями этого объекта.
Формат обьявления
Procedure <ИмяМетода>(<Параметры, как у процедуры>);
  Метод имеет доступ к полям данных объекта, не требуя передачи их ему в виде параметров.
  Объявление метода внутри объявления объектного типа содержит только заголовок. Тело метода определяется вне объявления объекта. Его заголовок должен содержать имя объекта, которому принадлежит метод. Например:

Procedure Объект.Метод;

(< параметры >);

Begin

.......

.......

End;

  Методы подразделяются на статические и виртуальные. Виртуальный метод отличается от статического тем, что реализующий его код подсоединяется к вызову не в процессе компиляции, а в процессе выполнения, что достигается так называемым поздним связыванием. Это дает возможность строить иерархию объектов с одинаковыми названиями методов, реализуемыми, однако, различными кодами.
Синаксис объявления виртуального метода:
Procedure Метод(< параметры >); virtual;
  Кроме обычных процедур и функций Турбо-Паскаль 6.0 реализует два специальных типа методов: конструктор и деструктор.
  Конструктор - это специальный метод, инициализирующий объект, содержащий виртуальные методы, он объявляется специально зарезервированным словом constructor.
Синтаксис:
constructor Init(< параметры >);
  Конструктор инициализирует объект установлением связи между объектом и специальной таблицей виртуальных методов, содержащей адреса кодов, реализующих виртуальные методы. Конструктор может также использоваться для инициализации полей данных объекта.
  Деструктор - это специальный метод, освобождающий память кучи от динамических объектов. Он объявляется с использованием специально зарезервированного слова destructor.
Синтаксис:
destructor Done;

  Основными отличительными свойствами объекта являются:

инкапсуляция - объединение записей с процедурами и функциями, работающими с этими записями;

наследование - задание объекта, затем использование его для построения иерархии порожденных объектов с наследованием доступа каждом из порожденных объектов к коду и данным предка;

полиморфизм - задание одного имени действию, которое передается вверх и вниз по иерархии объектов, с реализацией этом действия способом, соответствующим каждому объекту в иерархии.

Рассмотрим смысл каждого из приведенных свойств.

  Допустим, наши практические интересы лежат в области построения изображений тел звездном неба в двумерной проекции. Очевидно, что основой всякого изображения является положение (позиция) отдельного элемента на экране, описываемая координатами Х и У. Для задания двумерной позиции подходит тип запись, имеющйся в Турбо- Паскале.

Position = Record

Х: Integer;

Y: Integer;

End;

  Что можно делать с парой координат (Х,У) ?
  Во-первых, может потребоваться задать значения координат (в программировании такая процедура носит название инициализации). Создадим соответствующую процедуру:

Procedure Init(СоordХ, СооrdУ: Integer);

Begin

Х:= СооrdX;

Y:= СооrdY.,

End;

  Во-вторых, нам может потребоваться знание фактических значений координат, для этом вводим две функции:

Function GetX: integer;

Begin

GetX:= X;

End;

{---------------------------}

Function GetY: integer;

Begin

GetY:= Y;

End;

  По нашему замыслу процедура Init и функции GetХ и GetY должны работать только с полями записи Pozition. Введение объектов в Паскаль позволяет зафиксировать зто положение, объявив и поля и действия в одном месте:

Pozition = Object

X: Integer;

Y: Integer,

Procedure Init(CoordX, CoordY: Integer);

Function GetX: Integer;

Function GetY: Integer;

End;

  Теперь для инициализации экземпляра типа Pozition достаточно вызвать его метод, как если бы он был полем записи:

Var

FirstPozition: Pozition;

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

Begin

FirstPozition.Init(10,15);

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

  Метод задается так же, как и процедура в модуле: внутри объекта записывается заголовок (как в секции Interface модуля), при этом все поля, используемые методом, должны предшествовать ем объявлению. Определение метода (расшифровка действий) происходит вне объявления объекта. Имя метода должно предваряться названием типа объекта, которому метод принадлежит, сопровождаемым точкой.

Procedure Pozition.Init(CoordX, CoordY: Integer);

Begin

X:= CoordX;

Y:= CoordY;

End;

  Заметим, что имена формальных параметров метода не могут совпадать с именами полей данных объекта.
  Также как модуль защищает детали реализации процедур от пользователя, объект может защищать свои поля и методы. Для этом используется ключевое слово private (личный), Личные поля и методы доступны только внутри метода. Объявление выглядит следующим образом:

Type

ObjectNam = Object

поле;

..........

поле;

метод;

..........

метод;

private

ЧастноеПоле;

..........

ЧастноеПоле;

ЧастныйМетод;

..........

ЧастныйМеетод;

End;

  Рассмотрим звезду с координатами Х и У. Ее можно сделать видимой или невидимой, ей можно задать цвет, ее можно переместить.
  Создадим объект с такими возможностями:

Star = Object

X: Integer;

Y: Integer;

Procedure Init(CoordX, CoordY: Integer);

Function GetX: Integer;

Function GetY: Integer;

Visible: Boolean;

Color: Word;

Procedure Init(CoordX, CoordY: Integer; InitColor: Word);

Function IsVisible: Boolean;

Procedure Show; { зажигает звезду }

Procedure Blind; { гасит звезду }

Procedure Jump(NextX, NextY: Integer); { перемещает звезду }

End;

  Заметим, однако, что поля Х,У и методы GetХ, GetУ практически совпадают с соответствующими полями и методами обьекта Pozition.
&nnsp Турбо-Паскаль предоставляет возможность учесть эту ситуацию. Следует считать тип объекта Star порожденным типом Pozition, записав это следующим образом (наследование):

Star = Object(Pozition)

Visible: Boolean;

Color: Word;

Procedure Init(CoordX, CoordY: Integer; InitColor: Word);

Function IsVisible: Boolean;

Procedure Show;

Procedure Blind;

Procedure Jump(NextX, NextY: Integer);

End;

Объект Star теперь наследует свойства объекта Pozition. Поля Х,У явно не заданы в Star, но Star ими обладает благодаря наследованию, т.е. можно написать:
Star.X:=17;

  Смысл обьектно-ориентированного программирования заключается именно в работе с полями объекта через его методы.

  Давайте создадим объект "планета". Очевидно, что новый объект должен иметь предком объект Star, обладая всеми его свойствами, кроме того, быть "больше" по размеру (точнее - видимому размеру). Однако, даже начинающему программисту ясно, что нарисоавть на экране точку и закрашенную окружность не удастся одними и теми же командами.
  Турбо-Паскаль разрешает сохранить потомку имя родительского метода, "перекрывая" его. Чтобы перекрыть родительский метод, нужно просто задать его с тем же именем, но с другим телом (кодом) и, если необходимо, с другим набором параметров. Такой метод делается виртуальным и к его объявлению добавляется слово virtual. Применение виртуальных методов налагает ограничения на процедуры инициализации, которые должны записываться с зарезервированным словом constructor и иметь общее имя Init.
  Каждый отдельный экземпляр объекта должен инициализироваться с помощью отдельного вызова конструктора.
  Для очистки и убирания динамически распределенных объектов существует специальная процедура - destructor Done.
  Деструктор комбинирует шаг освобождения памяти в "куче" с некоторыми другими задачами. Метод деструктора может быть пустым, поскольку работу выполняет не только код тела, но и код, генерируемый Турбо-Паскалем в ответ на зарезервированное слово destructor.

  Turbo Vision - это оболочка оконной программы, управляемой событиями, включающая:

многократные перекрывающиеся окна с изменяемыми размерами,

выпадающие меню,

поддержку мышки,

диалоговые окна,

встроенную установку цвета,

кнопки, полосы скроллинга, окна ввода, зависимые и независимые кнопки,

стандартную обработку клавиш и нажатий мышки.

  Turbo Vision использует понятия видимых элементов, событий и невидимых объектов.
  Видимый элемент - это любой элемент программы прямоугольной формы, который виден на экране: поля, рамки окон, полосы скроллинга, полосы меню и диалоговые окна. Только видимые элементы могут взаимодействовать с дисплеем. Видимые элементы могут объединяться для формирования более сложных элементов таких, как окна и диалоговые окна. Эти наборы видимых элементов называются группами и они работают вместе так, как если бы это был один элемент.
  Невидимые объекты - это любые другие объекты программы, которые ничего не выводят на экран.
  Событие - это внешний фактор, заставляющий реагировать Вашу программу: нажатие клавиши, нажатие кнопки мышки, какие либо другие события в системе компьютера.

  Если Вы забыли, как точно пишется имя процедуры, какие аргументы ей требуются, то ИПО может помочь, предоставив в Ваше распоряжение свою справочную систему. Ее можно вызвать, нажав клавишу [F1]. Справка, которую выдает система, является контекстно-зависимой. Это означает, что Вы получите сообщение об объекте, указываемом курсором в тексте программы или в меню, либо сообщение о текущей ситуации в системе. Передвигая курсор по тексту справки, выбирая те или иные отмеченные элементы и нажимая затем клавишу [Enter], можно получить более подробную информацию. Целесообразно пользоваться справочной системой и при появлении сообщений об ошибках. Это избавляет от необходимости выяснять их причины в руководствах и справочниках.
  Во время работы с редактором текста в ТП 7.0 Вы можете с помощью комбинации [Ctrl+Fl] или правой кнопки мыши (для получения справки необходимо активизировать правой кнопкой мыши локальное меню и вызвать команду Topic\search) получить справочную информацию об операторе программы, на который указывает курсор. Установите курсор на строку, содержащую оператор WriteLn (непосредственно на само имя), и, используя комбинацию [Ctrl+Fl], активизируйте справочную систему ТП 7.0. Вы получите справку об операторе WriteLn.
  Если курсор не находится на зарезервированном слове и транслятор ошибок не обнаружил, то нажатие комбинации клавиш [Ctrl+Fl] приводит к выдаче индексной страницы (предметного указателя справок), из которой можно вызвать справочную информацию о любой процедуре или функции, даже если ее имя неточно указано в тексте программы (или вообще там отсутствует).
  Если Вы уже вызвали справку, а затем еще раз нажали клавишу [F1], Вы попадете в меню доступных справок. Это меню построено по иерархическому принципу и организовано как дерево, передвижение по которому в направлении корня осуществляется с помощью клавиш [Alt+Fl], а в противоположную сторону - выбором в справках конкретного термина, подлежащего более подробному истолкованию.

9

Тема 1. Основные этапы разработки программ.

Вопросы:

Этапы подготовки и решения задач на ЭВМ.

Алгоритмирование вычислительного процесса. Структурные схемы алгоритмов.

Редактирование, компиляция, и выполнение программы в инструментальной среде программирования.

На ЭВМ могут решаться задачи различного характера,

например: научно-инженерные; разработки системного программного обеспечения; обучения; управления производственными процессами и т.д.

В процессе подготовки и решения на ЭВМ научно-инженерных задач можно выделить следующие этапы:

постановка задачи;

математическое описание задачи;

выбор и обоснование метода решения;

алгоритмизация вычислительного процесса;

составление программы;

отладка программы;

решение задачи на ЭВМ и анализ результатов.

В задачах другого класса некоторые этапы могут отсутствовать, например, в задачах разработки системного программного обеспечения отсутствует математическое описание.

Перечисленные этапы связаны друг с другом.

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

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

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

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

Математическое описание задачи. Настоящий этап характеризуется математической формализацией задачи, при которой существующие соотношения между величинами, определяющими результат, выражаются посредством математических формул.

Так формируется математическая модель явления с определенной точностью, допущениями и ограничениями.

При этом в зависимости от специфики решаемой задачи могут быть использованы различные разделы математики и других дисциплин.

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

Само по себе математической описание задачи в большинстве случаев трудно перевести на язык машины.

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

Одну и ту же задачу можно решить различными методами, при этом в рамках каждого метода можно составить различные алгоритмы.

Алгоритмизация вычислительного процесса. На данном этапе составляется алгоритм решения задачи согласно действиям, задаваемым выбранным методом решения.

Процесс обработки данных разбивается на отдельные относительно самостоятельные блоки и устанавливается последовательность выполнения блоков. Разрабатывается блок-схема алгоритма.(Смотри алгоритмизацию вычислительного процесса)

Составление программы. При составлении программы алгоритм решения задачи переводится на конкретный язык программирования.

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

Отладка программы. Отладка заключается в поиске и устранении синтаксических и логических ошибок в программе.

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

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

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

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

Разработанная программа длительного использования устанавливается на ЭВМ, как правило, в виде готовой к выполнению машинной программы. К программе прилагается документация, включая инструкцию для пользователя.

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

Рассмотрим подробнее алгоритмизацию вычислительного процесса.

2. Алгоритмирование вычислительного процесса.

2.1 Способы описания алгоритмов

К основным способам описания алгоритмов можно отнести следующие:

словесно-формульный;

структурный или блок-схемный;

с помощью граф-схем;

с помощью сетей Петри.

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

Иногда перед составлением программ на низкоуровневых языках программирования типа Ассемблера алгоритм программы записывают, пользуясь конструкциями некоторого высокоуровнего языка программирования.

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

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

Пусть, например, необходимо найти значение следующего выражения:

y = 2a - (x+6).

Словесно-формульным способом алгоритм решения этой задачи может быть записан в следующем виде:

Ввести значения а и х.

Сложить х и 6.

Умножить а на 2.

Вычесть из 2а сумму (х+6).

Вывести у как результат вычисления выражения.

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

Данный способ по сравнению с другими способами записи алгоритма имеет ряд преимуществ.

Он наиболее нагляден: каждая операция вычислительного процесса изображается отдельной геометрической фигурой.

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

Оформление программ должно соответствовать определенным требованиям. В настоящее время действует единая система программной документации (ЕСПД), которая устанавливает правила разработки, оформления программ и программной документации. В ЕСПД определены и правила оформления блок-схем алгоритмов (ГОСТ 10.002-80 ЕСПД, ГОСТ 10.003-80 ЕСПД).

Операции обработки данных и носители информации изображаются на схеме соответствующими блоками.

Большая часть блоков по построению условно вписана в прямоугольник со сторонами a и b. Минимальное значение а равно 10 мм, увеличение а производится на число, кратное 5 мм. Размер b=1,5а. Для отдельных блоков допускается соотношение между a и b, равное 1:2. В пределах одной схемы рекомендуется изображать блоки одинаковых размеров. Все блоки нумеруются. Виды и назначение основных блоков приведены в табл.1.

Блок-схема должна содержать все разветвления, циклы и обращения к подпрограммам, содержащиеся в программе.

Вычислительные процессы, выполняемые на ЭВМ по заданной программе, можно разделить на три основных вида:

линейные;

ветвящиеся;

циклические.

На Рис.1 показан пример линейного алгоритма, определяющего процесс вычисления арифметического выражения y=(b2-ac):(a+c).

Рис. 2 .1. Пример линейного алгоритма

Вычислительный процесс называется ветвящимся, если для его реализации предусмотрено несколько направлений (ветвей).

Ветвящийся процесс, включающий в себя две ветви, называется простым, более двух ветвей - сложным.

Сложный ветвящийся процесс можно представить с помощью простых ветвящихся процессов.

Направление ветвления выбирается логической проверкой, в результате которой возможны два ответа: “да” - условие выполнено и “нет” - условие не выполнено.

На Рис. 2.2. показан пример алгоритма с разветвлением для вычисления следующего выражения:

Рис. 2 .2. Пример разветвляющегося алгоритма

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

Рис. 2 .3. Алгоритм нахождения суммы 10-и чисел

Задание на самоподготовку: найти в литературе для самостоятельной подготовки и записать в конспект условные обозначения блоков схем алгоритмов с расшифровкой назначения.

3.1 Среда программирования TurboPascal 7.0

Среда программировании Turbo Pascal 7.0 представляет собой интегрированную среду разработки компьютерных программ с использованием языка программирования Pascal.

Следует отметить, что язык программирования, используемый этой системой, значительно шире и мощнее так называемого стандартного языка Pascal.

Turbo Pascal - это эффективный компилятор Паскаль с интегрированной усовершенствованной средой, легкой для изучения и использования.

В среду программирования входят:

текстовый редактор,

компилятор,

редактор связей,

отладчик,

контекстно-ориентированный справочник .

Все эти свойства встроены в Turbo Pascal, и. все они доступны из среды программирования.

Справочную информацию можно получить посредством нажатия F1 (Ctrl-F1) и из меню Help.

3.2 Компоненты среды программирования T.P 7.0.

Существуют три видимых компоненты в интегрированной усовершенствованной среде:

полоса меню в верхней части,

область окна в центре,

строка статуса внизу.

Многие элементы меню также предлагают диалоговые окна.

Среда программирования TP7.0 запускается программой TURBO.EXE, которая находится в каталоге на жестком диске (обычно: c:\tp)

3.3 Создание программы.

При загрузке Turbo Pascal (набрав TURBO и нажав Enter в ответ на подсказку DOS), Вы увидите полосу меню, строку статуса, пустой экран и окно с информацией о версии продукта (выбор команды About (о) из меню Ё, или System (системного), в любой момент времени приведет к появлению этой информации). При нажатии любой клавиши информация с версией исчезает, но среда с окнами остается.

Перед началом работы необходимо настроить компилятор и директории в которых вы хотите хранить исходный текст программы и директории куда вы хотите поместить откомпилированную программу.

Выход в меню производится нажатием клавиши F10.

Установите в строке меню File – Change dir рабочий каталог для хранения своих файлов.

Меню Compile – Destination Memory поменять на Destination Disk

В меню Options укажите реальные пути к каталогам TPU, Unit, Object

Нажатие клавиши F3 (сокращение для File/Open) открывает диалоговое окно Open a File в котором задается или вызовается текстовый файл с программой.

Все действия в среде программирования подтверждаются нажатием клавиши Enter или кн. “ОК” (кроме работы в текстовом редакторе).

Для удаления используется Backspace, а для передвижения внутри окна редактора используйте клавиши со стрелками.

3.4 Сохранение программы.

Выберается команду Save из меню File.

Или клавишей F2.

3.5 Компиляция программы.

Производится из опции Complile в основном меню или Alt-F9.

Turbo Pascal компилирует Вашу программу, изменяя ее с Паскаля (который можно читать) на машинный код 8086 для микропроцессора (который может выполнить Ваша РС). Вы не увидите машинный код 8086; он хранится в памяти (или на диске).

Когда Вы начинаете компиляцию, в центре экрана появляется окно, содержащее информацию о данной компиляции.

Если во время компиляции не произошло никаких ошибок, то в этом окне появится сообщение "Compilation successful: press any key" (компиляция успешна: нажмите любую клавишу).

Окно остается на экране до тех пор, пока Вы не нажмете клавишу.

Если во время компиляции произошла ошибка, Turbo Pascal останавливается, устанавливает курсор на ошибку в редакторе и показывает сообщение об ошибке вверху редактора. (Первое нажатие клавиши очистит это сообщение, а Ctrl-Q W будет показывать его снова до тех пор, пока Вы не измените файл или не перекомпилируете его). Сделайте исправления, сохраните обновленный файл и компилируйте снова.

3.6 Выполнение программы.

После фиксации ошибок в основнм меню и выберите Run/Run

(или нажмите Ctrl-F9).

Если во время выполнения программы произошла ошибка, то на экране появится сообщение, которое выглядит следующим образом:

Run-time error <errnum> at <segment>:<offset>

где <errnum> - это соответствующий номер ошибки (см. в приложении А "Сообщения об ошибках" в руководстве программиста информацию по ошибкам компиляции и ошибкам времени выполнения), а <segment>:<offset> - это адрес в памяти, где произошла ошибка.

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

Пока сообщение находится в строке статуса редактора, можно нажать F1 для получения справочной информации по конкретной ошибке.

Нажатие любой другой клавиши приводит к исчезновению сообщения об ошибке.

Если Вам нужно будет найти местоположение ошибки снова, выберите Search/Find Error.

Когда Ваша программа закончит выполнение, Вы вернетесь в то место программы, с которого начинали.

Теперь Вы можете модифицировать программу, если хотите.

Если Вы выберете команду Run/Run перед внесением изменений в свою программу, Turbo Pascal немедленно выполнит ее снова без перекомпиляции.

Вы можете просмотреть вывод своей программы посредством выбора команды Run/User Screen (или нажатия Alt-F5).

Выберите ее снова для возврата в среду Turbo Pascal.

Более широко функции среды программирования Turbo Pascal будут рассмотрены на практических занятиях.

Проверка файлов, которые Вы создали.

Если Вы вышли из Turbo Pascal (выбрав Exit из меню File), Вы можете просмотреть справочный листинг исходного файла (Паскаль), который Вы создали

в любом текстовом редакторе файловых оболочек.

Вывод:

На сегодняшней лекции рассмотрены:

основные этапы разработки программ, способы создания алгоритма будущей программы, минимальный набор управляющих команд среды программирования для создания программ на языке Turbo Pascal.

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

6

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

Инициализация графики

Язык Turbo   Pascal   предоставляет целый ряд   процедур   и других средств, позволяющих рисовать на экране разноцветные точки, отрезки прямых, дуги, закрашенные и незакрашенные окружности, прмоугольники, а также выполнять ряд других действий.

Все средства для работы с графикой находятся в модуле GRAPH, поэтому он должен быть подключен в программе перед тем, как начать работу:

USES Graph;
Инициализация графики производится с помощью процедуры InitGraph:

InitGraph(var GraphDriver:Integer; var GraphMode:Integer; PathToDriver:String)

Переменная GraphDriver определяет тип видеоадаптера, GraphMode - тип графического режима. Если переменной GraphDriver присвоить значение Detect, то Паскаль сам определит установленный видеоадаптер и установит самый мощный из имеющихся графический режим

Переменная PathToDriver определяет путь к каталогу, в котором находятся графические драйвера Паскаля. Для проверки успешности инициализации графики можно использовать процедуру GraphResult.

Если графика была успешно инициализировнана, то процедура GraphResult вернет значение grOk.

Процедуры модуля Graph.

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

Очень важно! В языке Паскаль используется нестандартная система координат. Нуль ее расположен в левом верхнем углу, ось Ox направлена вправо, а Oy - вниз.

Процедуры для рисования фигур.

PutPixel(X, Y:Integer; Pixel:Word);

Рисует на экране точку с координатами (X, Y) цветом Pixel.

Line(X1, Y1, X2, Y2:Integer);

Рисует на экране отрезок прямой от точки (X1, Y1) до точки (X2, Y2).

Rectangle(X1, Y1, X2, Y2:Integer);

Рисует на экране прямоугольник с верхним левым углом в точке (X1, Y1) и нижним правым углом в точке (X2, Y2).

Bar(X1, Y1, X2, Y2:Integer);

Рисует на экране залитый прямоугольник с верхним левым углом в точке (X1, Y1) и нижним правым углом в точке (X2, Y2). Стиль и цвет заливки задаются процедурой SetFillStyle.

Bar3D(X1, Y1, X2, Y2:Integer; Depth:Word; Top:Boolean);

Рисует на экране параллелепипед с залитой передней гранью. Глубина фигуры - Depth. Если Top равно TopOn , то параллелепипед рисуется с верхней гранью, если TopOff, то без верхней грани. Стиль и цвет заливки передней грани задаются процедурой SetFillStyle.

Circle(X, Y:Integer; Radius:Word);

Рисует на экране окружность с центром в точке (X, Y) радиусом Radius.

Ellipse(X, Y:Integer; StAngle, EndAngle:Word; XRadius, YRadius:Word);

Рисует на экране эллиптическую дугу с центром в точке (X, Y), радиусами XRadius, YRadius. StAngle, EndAngle - начальный и конечный углы.

Arc(X, Y:Integer; StAngle, EndAngle:Word; Radius:Word);

Рисует на экране дугу окружности с центром в точке (X,Y), радиусом Radius. StAngle, EndAngle - начальный и конечный углы.

FillEllipse(X, Y:Integer; XRadius,YRadius:Word);

Рисует на экране залитый эллипс с центром в точке (X, Y), радиусами XRadius, YRadius. Стиль и цвет заливки задаются процедурой SetFillStyle.

Sector(X, Y:Integer; StAngle, EndAngle:Word; XRadius, YRadius:Word);

Рисует на экране закрашенный сектор эллипса с центром в точке (X, Y), радиусами XRadius, YRadius. StAngle, EndAngle - начальный и конечный углы. Стиль и цвет заливки задаются процедурой SetFillStyle.

PieSlice(X, Y:Integer; StAngle, EndAngle:Word; Radius:Word);

Рисует на экране закрашенный сектор круга с центром в точке (X, Y), радиусом Radius. StAngle, EndAngle - начальный и конечный углы. Стиль и цвет заливки задаются процедурой SetFillStyle.

Другие процедуры.

ClearDevice;

Очищает экран в графическом режиме.

CloseGraph;

Закрывает графический режим.

SetColor(Color:Word);

Устанавливает новый цвет для рисования.

SetLineStyle(LineStyle:Word; Pattern:Word; Thickness:Word);

Устанавливает стиль и толщину линий. Если Thickness равно ThickWidth, то линии будут толстыми, если NormWidth, то обычными.

SetFillStyle(Pattern:Word; Color:Word);

Устанавливает стиль и цвет заливки. Если Pattern равно UserFill, то используется определенный пользователем стиль, описанный процедурой SetFillPattern.

SetFillPattern(Pattern:FillPatternType; Color:Word);

Устанавливает определяемый пользователем стиль и цвет заливки. FillPatternType=Array [1..8] of Byte;

FloodFill(X, Y:Integer; Border:Word);

Заливает область вокруг точки (X, Y) до линии цвета Border, используя текущий стиль и цвет заливки.

SetTextStyle(Font, Direction:Word; CharSize:Word);

Устанавливает используемый шрифт, его направление и размер. Направление соответствует значению переменной Direction и может быть горизонтальным (Direction=0) или вертикальным (Direction=1). Шрифт может быть как одним из стандартных, так и определенный пользователем (с помощью функции InstallUserFont).

SetUserCharSize(MultX, DivX, MultY, DivY:Word);

Устанавливает ширину букв используемого шрифта в MultX/DivX раз больше, а высоту в MultY/DivY раз больше.

OutTextXY(X, Y:Integer; TextString:String);

Выводит текст TextString на экран от точки (X, Y).

Образец:

{ Внимание! Для работы этой программы необходимо, чтобы:

1) Turbo Pascal был установлен в каталог C:\TP;

2) каталог C:\TP\BGI содержал файл egavga.bgi ;

3) в меню Options/Directories был указан путь

к файлу graph.tpu, н пример, С:\TP\UNITS.

Если Turbo Pascal установлен в другом каталоге, нужно изменить

путь к нему в процедуре InitGraph (10-я строк программы).

}

Program Lines;

Uses Graph, Crt; {подключение к программе библиотек Crt и Graph}

Var

Key : Char;

LineStyle : Word; { номер стиля рисования линии }

Style : String; { название стиля }

GrDriver, GrMode : Integer; { тип и режим работы графического драйвера }

GrError : Integer; { код ошибки графики }

BEGIN

GrDriver := Detect; { втоопределение тип графического драйвера }

InitGraph(GrDriver, GrMode, 'C:\TP\BGI'); { установка графического режим }

GrError := GraphResult;

If GrError<>GrOk then begin Writeln('Обнаружена ошибка !'); Halt

end;

SetBkColor(LightGray); SetColor(Red); { цвет фона и цвет рисования }

{------------------------------------------------------------}

OutTextXY(120, 100, 'Рисуем линию от точки (200,200) к точке (400,280)');

Line(200, 200, 400, 280);

Key:=ReadKey; { приостановление исполнения программы }

ClearViewPort; { очистка окна }

{-----------------------------------------------------------}

OutTextXY(240, 80, 'Рисуем ломанную');

Rectangle(110, 120, 520, 400); { рисование рамки }

MoveTo(Round(GetMaxX/2), Round(GetMaxY/2)); { указатель в центре окна }

Repeat {цикл прерывается нажатием любой клавиши}

LineTo(Random(GetMaxX-250)+120, Random(GetMaxY-210)+120);

Delay(100);

until KeyPressed;

Key := ReadKey; ClearViewPort;

{-----------------------------------------------------------}

OutTextXY(190, 80, 'Mеняем стили рисования линий');

For LineStyle := 0 to 3 do

begin

SetLineStyle(LineStyle, 0, 1);

Case LineStyle of

0: Style:='Сплошная';

1: Style:='Точечная';

2: Style:='Штрихпунктирная';

3: Style:='Пунктирная'

end;

Line(120, 150+LineStyle*50, 430, 150+LineStyle*50);

OutTextXY(450, 145+LineStyle*50, Style);

end;

Key:=ReadKey; ClearViewPort; {очистка окна }

{-----------------------------------------------------------}

OutTextXY(180, 80, 'Меняем толщину рисования линий');

SetLineStyle(0, 0, 1); {толщина 1 пиксела }

Line(140, 200, 430, 200); OutTextXY(450, 195, 'Нормальная');

SetLineStyle(0, 0, 3); {толщина 3 пиксела}

Line(140, 250, 430, 250); OutTextXY(450, 245, 'Тройная');

ReadLn; CloseGraph; {закрытие графического режима }

END.

Образец 2:

{ Движущееся сложное изображение }

program titanik;

uses Graph,

Crt;

var

grDriver:integer; { драйвер }

grMode:integer; { графический режим }

grPath:string; { место расположения драйвера }

ErrCode:integer; { результат инициализации граф. режим }

x,y:integer; { координаты кораблика }

color:word; { цвет кораблика }

bkcolor:word; { цвет фона экрана }

{ Кораблик }

Procedure Titan(x,y:integer; { координаты базовой точки }

color:word); { цвет корабля }

const

dx=5;

dy=5;

var

OldColor:word;

begin

OldColor:=GetColor; { сохранить текущий цвет }

SetColor(color); { установить новый цвет }

{ корпус }

MoveTo(x,y);

LineTo(x,y-2*dy);

LineTo(x+10*dx,y-2*dy);

LineTo(x+11*dx,y-3*dy);

LineTo(x+17*dx,y-3*dy);

LineTo(x+14*dx,y);

LineTo(x,y);

{ надстройка }

MoveTo(x+3*dx,y-2*dy);

LineTo(x+4*dx,y-3*dy);

LineTo(x+4*dx,y-4*dy);

LineTo(x+13*dx,y-4*dy);

LineTo(x+13*dx,y-3*dy);

Line(x+5*dx,y-3*dy,x+9*dx,y-3*dy);

{ капитанский мостик }

Rectangle(x+8*dx,y-4*dy,x+11*dx,y-5*dy);

{ труб }

Rectangle(x+7*dx,y-4*dy,x+8*dx,y-7*dy);

{ иллюминаторы }

Circle(x+12*dx,y-2*dy,Trunc(dx/2));

Circle(x+14*dx,y-2*dy,Trunc(dx/2));

{ мачта }

Line(x+10*dx,y-5*dy,x+10*dx,y-10*dy);

{ оснастка }

MoveTo(x+17*dx,y-3*dy);

LineTo(x+10*dx,y-10*dy);

LineTo(x,y-2*dy);

SetColor(OldColor); { восстановить текущий цвет }

end;

begin

grDriver := VGA; { режим VGA}

grMode:=VGAHi; { разрешение 640х480}

grPath:='d:\bp\bgi'; { драйвер, файл EGAVGA.BGI, находится

в каталоге d:\bp\bgi }

InitGraph(grDriver, grMode,grPath);

ErrCode := GraphResult;

if ErrCode <> grOk then Halt(1);

x:=10;

y:=200;

color:=LightGray;

SetBkColor(Blue);

bkcolor:=GetBkColor;

repeat

Titan(x,y,color); { нарисовать корабль }

Delay(100);

Titan(x,y,bkcolor); { стереть корабль }

PutPixel(x,y,color); { след от корабля }

x:=x+2;

until (x>500);

OutTextXY(10,10,'Рейс завершен!');

readln;

CloseGraph;

End.

{ Программ изображает планету, вращающуюся вокруг Солнца

н фоне мерцающих звезд и расходящейся галактики

Внимание! Для работы этой программы необходимо, чтобы:

1) Turbo Pascal был установлен в к т лог C:\TP;

2) каталог C:\TP\BGI содержал файл egavga.bgi ;

3) в меню Options/Directories был указан путь

к файлу graph.tpu, н пример, С:\TP\UNITS.

Если Turbo Pascal установлен в другом к т логе, то

нужно изменить путь к нему в процедуре InitGraph.

}

Program Space;

Uses Graph, Crt;

Const

RadOrb = 250 { радиус орбиты Земли }; RadSun = 70 { радиус Солнц };

RadGal = 100 { радиус галактики }; RadZem = 18 { радиус Земли };

Naklon = 0.2 { коэффициент наклона плоскости орбиты Земли };

PressZem = 0.65 { коэффициент сплющенности полюсов Земли };

Compress = 0.8 { коэффициент сжатия при переходе из };

{ расширения режим VGA в режим CGA }

Var

ZemX, ZemY, UgMer, PixelY, DUgZem , UpDown,

XRad, Grad, UgZem, PixelX, StAngle, Ua, Ub,

ParallelY, Color, ZemPix, EndAngle,

VisualPage, GrMode, GrError, GrDriver, i : Integer;

Ugol, CompressZem, Expansion,

DUgol, Projection, PolUgol : Real;

BEGIN

{ установк графического режим и проверк возможных ошибок }

GrDriver := EGA; GrMode := EGAHi;

InitGraph(GrDriver, GrMode, 'C:\TP\BGI');

GrError := GraphResult; If GrError<>GrOk then Halt;

SetBkColor(Black);

SetFillStyle(1, Yellow); { установка стиля заполнения и цвет Cолнцa }

Ugol := 0; DUgol := 2*Pi/180; { орбитальное угловое смещение Земли }

UgZem := 0; DUgZem := 14; { осевое угловое смещение Земли }

{--------------------------------------------------}

VisualPage := 1;

Repeat { цикл прерывается нажатием любой клавиши }

SetVisualPage(1- (VisualPage mod 2));

{ установка номер видимой видеостраницы }

VisualPage := VisualPage+1; { листание видеостраниц }

SetActivePage(1 - (VisualPage mod 2));

{ установк номера невидимой ( активной) видеостраницы, }

{ используемой для построения смещенного изображения }

ClearDevice; { очистка графического экрана }

{-----------------------------------}

{ Рисование "расходящейся" галактики }

RandSeed:=1; { исходное значение датчика случайных чисел }

Expansion:=VisualPage/100; { cкорость расширения галактики }

For i:= 1 to VisualPage do

begin XRad := Trunc(Expansion*RadGal*Random);

{ текущее расстояние от звезды до центра галактики }

PolUgol:= 2*Pi*Random-VisualPage/30;

{ текущий центральный угол положения звезды галактики }

PixelX := 370+Trunc(XRad*cos(PolUgol+1.8)); { координаты }

PixelY := 250+Trunc(XRad*0.5*sin(PolUgol)); { звезды }

PutPixel(PixelX, PixelY, White) { рисование звезды }

end;

{-----------------------------------}

{Рисование мерцающих звезд}

Randomize; { инициализация датчика случайных чисел }

For i:=1 to 70 do

PutPixel(Random(640),Random (350),White); { вспыхивающие звезды }

{-----------------------------------}

For i := 1 to 100 do { Рисование орбиты }

PutPixel(320+Round(RadOrb * cos((i+VisualPage/5)*Pi/50+0.3)),

160+Round(RadOrb*Naklon*sin((i+VisualPage/5)*Pi/50-Pi/2)),15);

{-----------------------------------}

PieSlice(310, 160, 0, 360, RadSun); { Рисование Солнц }

{-----------------------------------}

{ Рисов ние Земли (ее параллелей и меридианов) }

Ugol := Ugol+DUgol ; { угол поворот Земли относительно Солнц }

Grad := Round(180*Ugol/Pi) mod 360; { в рад.(Ugol) и в град.(Grad) }

ZemX := 320+Round(RadOrb*cos((Ugol+Pi/2+0.3))); { координаты }

ZemY:=160+Round(RadOrb*Naklon*sin(Ugol)); { центр Земли }

CompressZem := 2.5-cos(Ugol+0.3);

{ коэффициент учета удаленности Земли от наблюдателя }

ZemPix := Round(RadZem*CompressZem); { текущий радиус Земли }

UgZem := UgZem+DUgZem; { угол поворот Земли относительно своей оси }

For i := 0 to 11 do { рисование меридианов }

begin

UgMer := (UgZem+i*30) mod 360;

If (90<UgMer) and (UgMer<270) { установк начального и конечного }

then begin StAngle := 90; EndAngle := 270 end { углов дуги }

else begin StAngle := 270; EndAngle := 90 end; {эллипс меридиан }

Ua := (Grad+220) mod 360; Ub := (Grad+400) mod 360;

{ установка цветов рисования затененной и освещенной }

{ частей меридиана }

Color := LightBlue;

If Ua<=Ub then if (Ua<UgMer) and (UgMer<Ub) then Color := White;

If Ua >Ub then if (Ua<UgMer) or (UgMer<Ub) then Color := White;

SetColor(Color);

XRad := round((ZemPix*cos(UgMer*Pi/180)));

Ellipse(ZemX,ZemY,StAngle,EndAngle,abs(XRad),round(PressZem*ZemPix));

end;

For i := 2 to 7 do { рисование параллелей }

begin

XRad := abs(Round(ZemPix*sin(i*Pi/9)));

{ большая полуось эллипс параллели }

UpDown := Round(ZemPix*PressZem*cos(i*Pi/9));

{ высота параллели над плоскостью экватора }

ParallelY := ZemY+UpDown; { координата Y центр эллипса параллели }

SetColor(LightBlue);

Ellipse(ZemX, ParallelY, 0, 360, XRad, Round(Naklon*XRad));

{ затененная часть параллели }

SetColor(White);

Ellipse(ZemX,ParallelY,Grad+220,Grad+400,XRad,Round(Naklon*XRad));

{ освещенная часть параллели }

end;

{-----------------------------------}

{ Повторное рисование Cолнца , если оно ближе к наблюдателю, чем Земля }

If CompressZem<2 then PieSlice(310, 160, 0, 360, RadSun);

{-----------------------------------}

RandSeed := VisualPage mod 12;

For i := 1 to 250 do { Рисование протуберанцев }

begin

Projection := (1-sqr(Random))*Pi/2;

XRad := RadSun+Round((20)*sin(Projection))-15;

PolUgol := 2 * Pi * Random+VisualPage/20;

{ PolUgol, XRad - полярные координаты протуберанца }

PixelX := 310 + Round( XRad * cos(PolUgol));

PixelY := 160 + Round( Compress * XRad * sin(PolUgol));

PutPixel(PixelX, PixelY, LightRed)

end;

until KeyPressed

END.

4

Структура модуля.

Модуль обеспечивает набор средств, благодаря возможности испольозвания процедур и функций, поддерживающих константы, типы данных и переменных, но их действительная реализация скрыта из-за того, что модуль разделен на два раздела: интерфейс и реализация.

Все объявления и описания модуля становятся доступными

программе, использующей его.

Структура модуля похожа на структуру программы, но имеет и

отличия:

unit <идентификатор>;

interface

uses <список модулей>;

{общие объявления}

implementation

uses <список модулей>;

{личные объявления}

{реализация процедур и функций}

begin

{код инициализации}

end.

Заголовок модуля - слово unit, за которым следует имя модуля - идентификатор.

Следующий элемент - ключевое слово interface. Это слово обозначает начало раздела интерфейса модуля, доступного для всех других модулей и программ, использующих этот модуль.

В предложении uses указываются модули, которые может использовать этот модуль.

Слово uses может появляться в двух местах:

- сразу же после слова interface; в этом случае, константы или типы данных, объявленные в интерфейсах этих модулей, могут быть использованы в любых объявлениях.

- сразу же после слова implementation; в этом случае, любые объявления этого модуля могут использоваться только внутри раздела реализации. Это так же допускает циклические ссылки модулей; мы покажем как их использовать ниже.

Раздел интерфейса.

Это "открытая" часть модуля, она начинается ключевым словом interface, следующим сразу за заголовком, и ограничена ключевым словом imрlеmentation.

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

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

В интерфейсе модуля можно объявить константы, типы данных,

переменные, процедуры и функции. Как и в программе, они могут быть

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

(type...var...<proc>...type...const...var)

Процедуры и функции, доступные для программы, использующей

этот модуль описываются в разделе интерфейса. А их действительные

тела - операторы, реализующие их, - в разделе реализации.

Объявление forward не разрешается.

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

Секция реализации.

Раздел реализации - закрытая, недоступная часть - начинается со слова implementation. Все, что объявлено в части интерфейса видимо для раздела реализации: константы, типы, переменные, процедуры и функции. Кроме того, в разделе реализации могут быть свои собственные дополнительные объявления, недоступные программам, использующим этот модуль.

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

Предложение uses может появляться в разделе implementation. В

этом случае uses следует непосредственно за ключевым словом

implementation.

Если процедуры были объявлены как внешние, то в исходном файле

должна быть директива {$L имя файла} в любом месте до конца модуля

end. Обычные процедуры и функции, объявленные в разделе интерфейса

- которые не являются встроенными - должны появляться в разделе

реализации.

Заголовок procedure (function) в разделе реализации должен быть такой же, как и в разделе интерфейса, или же иметь короткую форму. В краткой форме за ключевым словом (procedure или function) следует идентификатор (имя). Подпрограмма содержит свои собственные локальные объявления (метки, константы, типы, переменые, процедуры и фукции). За ними следует тело главной программы.

Например, в разделе интерфейса объявлены:

procedure ISwap (var v1,v2: integer);

function IMax (v1,V2:integer);

Раздел реализации может быть:

procedure ISwap;

var

Temp : integer;

begin

Temp := V1;V1:= V2;V2 := Temp;

end; {процедуры ISwap}

function IMax (v1,v2:integer):integer;

begin

if V1 > V2 then

IMax := V1

else IMax := V2

end; {функции IMax}

Подпрограммы раздела реализации (неописанные в секции интерфейса), должны иметь полный заголовок procedure/funсtion.

Раздел инициализации.

Раздел реализации модуля заключен между словами implementation и end. Но если присутствует слово begin перед end, и операторы между этими словами, то получившийся составной оператор, похожий на тело главной программы, становится разделом инициализации модуля.

В разделе инициализации инициализируются структуры данных (переменных), используемые модулем или доступные программам, использующим этот модуль. Вы можете использовать этот раздел для открытия файлов. Например, стандартный модуль Printer использует этот раздел для открытия на вывод текстового файла Lst. Файл Lst впоследствии можно использовать в программах, в операторах Write или Writeln.

При выполнении программы, использующей некоторый модуль, раздел инициализации вызывается перед выполнением тела главной программы. Если в программе используется несколько модулей, раздел инициализации каждого модуля вызывается (в порядке, указанном в операторе uses программы) до выполнения тела главной программы.

Как используются модули?

и хранятся в специальном машинном коде; это не файлы типа Include.

Даже раздел интерфейса хранится в специальном двоичном формате, который использует Turbo Pascal. Более того, стандартные модули хранятся в специальном файле TURBO.TPL и автоматически загружаются в память с Turbo Pascal.

В результате подключения модулей к программе увеличивается

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

Для использования модулей необходимо, чтобы в начале присутствовало предложение uses, за которым следует список имен всех модулей, разделенных запятыми.

program MyProg;

uses thisUnit,thatUnit,theotherUnit;

При компиляции этой информации к таблице символов прибавляется

информации из раздела интерфейса, а из раздела реализации к самой программе машинный код. Порядок описания модулей в предложении uses не имеет большого значения. Если thisUnit использует thatUnit, то можно объявить их в любом порядке. Компилятор сам определит, который из них должен следовать первым.

Иначе говоря, если thisUnit использует thatUnit, а программа MyProg не вызывает какие-либо программы в подпрограмме thatUnit, то можно "спрятать"подпрограммы в программу thatUnit, опуская их в операторе uses:

unit thisUnit

uses thatUnit

...

program MyProg;

uses thisUnit,theotherUnit;

...

В этом примере thisUnit может вызвать подпрограмму thatUnit, а MyProg - подпрограммы thisUnit и thеоtherUnit. MyProg не может вызвать thatUnit, т.к эта подпрограмма не описана в его предложении uses.

Если предложение uses отсутствует, Turbo Pascal подсоединяет стандартный модуль System. Этот модуль обеспечивает выполнение некоторых стандартных подпрограмм Turbo Pascal и программ, специфичных для Turbo Pascal.

15

Целочисленная арифметика TURBO PASCAL (примеры задач)

1. 0.pas-Подсчитать кол-во цифр в заданном натуральном числе

program N1{подсчит ть кол-во цифр в з д нном н тур льном числе};

var N:integer;

function KOL(N:integer):integer;

begin

if N>9 then KOL:=KOL(N mod 10)+KOL(N div 10)

else KOL:=1;

end;

BEGIN

Write('Введите N');ReadLn(N);

WriteLn(KOL(N));

ReadLn;

END.

2. Найдите целые числа-палиндромы, которые при возведении в квадрат

тоже дают палиндромы

program borlpasc;

{н йдите целые числа -палиндромы, которые при возведении в квадрат

тоже д ют п линдромы}

var i,i1,i2:longint;

function Palindrom(n:longint):boolean;

var n1,n2,o:longint;

begin n1:=n;n2:=0; {n1 - данное число, n2 - число которое получится}

while n1>0 do

begin o:=n1 mod 10;{о - ост ток от деления н 10}

n1:=n1 div 10;

n2:=n2*10+o;

end;

Palindrom:=(n=n2);

end;

begin writeln('Введите интервал поиск :');

write('Начало интервала:');readln(i1);

write('Конец интерв л :');readln(i2);

for i:=i1 to i2 do

if Palindrom(i) and Palindrom(sqr(i))

then writeln(i,'-п линдром ',sqr(i),'-п линдром');

end.

3. Поменять местами первую и последнюю цифры числа

program borlpasc;

var b,a,n,k:integer;

begin write('введите число n=');

readln(n);

k:=n;

a:=k mod 10;

repeat b:=k mod 10;

k:=k div 10

until k div 10 =0;

b:=k mod 10;

writeln(a,n div 10 div 10 mod 10,n div 10 mod 10,b)

end.

4. Дано нат. K. напечатать К-ю цифру последовательности

12345678910111213...,

в которой записаны подряд все натуральныe числa

{Andrey Sharov}

{ e-mail : ansharov@one.lv }

{ website: borlpasc.narod.ru }

{д но н т. K. н печ т ть К-ю цифру последов тельности 12345678910111213...,

в которой з пис ны подряд все н тур льныe числa}

program borlpasc;

var i,j,k,n,o:integer;

a,t:longint;

begin write('Введите k=');readln(k);

t:=0;i:=0;

repeat t:=t+1;

j:=t;

while j>0 do{счит ем количество цифр в числе

и доб вляем к общему количеству}

begin j:=j div 10;

i:=i+1;

{if i=k then o:=j mod 10;}

end;

until i>=k;

while i>=k do{возвр щ емся по цифр м последнего числ

до нужной}

begin o:=t mod 10;

t:=t div 10;

i:=i-1;

end;

writeln('k-я цифр :',o)

end.

5. Дано число N<=99. Дописать в начало и в конец числа цифру k

program borlpasc;

var n,k:integer;

begin write('введите k=');

readln(k);

write('введите n=');

readln(n);

writeln('Получилось число:');

write(k,n,k)

end.

6. Проверить, есть ли в записи числа N в степени k цифра m

Program borlpasc;

var i,n,m,s,k,l,a:integer;

begin write('введите n=');

readln(n);

write('введите k=');

readln(k);

write('введите цифру m=');

readln(m);

i:=0;l:=0;s:=1;

repeat s:=s*n;

i:=i+1

until i=k;

repeat a:=s mod 10;

if a=m then l:=l+1;

s:=s div 10

until s=0;

if l=0 then writeln('В з писи числ нет цифры',' ',m)

else writeln('В з писи числ цифр ',m,' есть')

end.

7. Найти наименьшее нат. число, представимое двумя различными

способами в виде суммы кубов двух натуральных чисел

program borlpasc;

var i,k:integer;

x,y:integer;

begin i:=1; k:=0;

repeat i:=i+1;

for y:=1 to i-1 do

for x:=1 to i do

if x*x*x+y*y*y=i then k:=k+1

until k>=2; writeln(x,y);

writeln('н им н т число=',i)

end.

8. Доказать, что любую целочисленную денежную сумму большую 7 рублей можно выплатить без сдачи трешками и пятерками.

program borlpasc;

var n,n3,n5,k:integer;

begin write('Введите сумму(>7) n=');

readln(n);

k:=0;

for n3:=0 to (n div 3) do

for n5:=0 to (n div 5) do

begin if n3*3+n5*5=n

then writeln(n3,' трешки и ',n5,' пятерок');

k:=k+1

end;

if k=0

then writeln('Из трешек и пятерок эту сумму не сложить.')

end.

9. Дано нат. K. напечатать К-ю цифру последовательности 149162536...,

в которой записаны подряд квадраты всех натуральных чисел

program borlpasc;

var i,j,k,n,o:integer;

a,t:longint;

begin write('Введите k=');readln(k);

j:=0;a:=1;i:=0;

repeat j:=j+1;a:=sqr(j);

t:=a;

while t>0 do{счит ем количество цифр в числе

и доб вляем к общему количеству}

begin t:=t div 10;

i:=i+1;

end;

until i>=k;

t:=a;

while i>=k do{возвр щ емся по цифр м последнего числ

до нужной}

begin o:=t mod 10;

t:=t div 10;

i:=i-1;

end;

writeln('k-я цифр :',o)

end.

10. Есть ли в записи числа 3 одинак цифры

PROGRAM borlpasc;{Есть ли в з писи числ 3 один к цифры}

VAR N:INTEGER;a,b,c,d:integer;

BEGIN WRITE('ВВЕДИТЕ ЧИСЛО N=');

READLN(N);

a:=n div 1000;

b:=n div 100 mod 10;

c:=n div 10 mod 10;

d:=n mod 10;

IF (a=b) and (a=c) or (a=b) and (a=d) or (a=c) and (a=d) or

(b=c) and (b=d)

THEN WRITELN('В ЗАПИСИ ЧИСЛА ЕСТЬ 3 ОДИНАКОВЫЕ ЦИФРЫ')

ELSE WRITELN('В ЗАПИСИ ЧИСЛА НЕТ ТРЕХ ОДИНАКОВЫХ ЦИФР')

END.

11. Дано натур число n<=9999. Поменять порядок следования цифр.

program borlpasc;

var s,x:integer;

begin write('введите число=');

readln(x);

s:=0;

repeat s:=s*10+x mod 10;

x:=x div 10

until x=0;

writeln(s)

end.

12. Перевод из 10 в двоичную ситему счисления

PROGRAM borlpasc; {ПЕРЕВОД ЧИСЛА ИЗ 10-ОЙ СИСТЕМЫ СЧИСЛЕНИЯ В 2-УЮ}

TYPE massiv=array [1..50] of integer;

var a:massiv;

n,i:integer;

begin write('введите число:');

readln(n);

i:=1;

while n>=2 do

begin a[i]:= n mod 2;

i:=i+1;

n:= n div 2;

end;

i:=i-1;

write(n);

while i<>0 do

begin write(' ',a[i]);

i:=i-1;

end;

writeln

end.

13. Перевод из 10 в двоичную ситему счисления (II способ);

program two_system;

var sec:array[1..16] of byte;

d,ten,i:integer;

procedre two( ten_1:integer;var two_s:byte);

begin two_s:=ten_1 mod 2;

ten_1:=ten_1 div 2;

end;

begin

write('введите н т.число: ');

readln(ten);

if ten<=0 then write('некорректные д нные')

else

d:=ten;

a[i]:=0;

fori:=16 downto 1 do two(ten,sec[i]);

write('н тур льное число: ',d);

write('в двоичной системе счисления ');

for i:=1 to 16 do write(' ',sec[i]);

end.

14. Найти все делители натурального числа N

program borlpasc;

const kol=100;

type cyfra=0..9;

chislo=array[1..kol] of cyfra;

var i,r,d,s,k,code:integer;

j,c0,c1,x,y,z,o,z1,n,lastd:chislo;

p:boolean;

function sravnenie(x,y:chislo):integer;

var i,r:integer;

begin r:=0;i:=1;

repeat if (x[i])>(y[i]) then r:=1;

if x[i]<y[i] then r:=-1;

i:=i+1;

until (r<>0)or(i>kol);

sravnenie:=r;

end;

procedure add(x,y:chislo;var z:chislo);

var p,a,b,c:integer;

begin p:=0;

for i:=kol downto 1 do

begin a:=x[i];

b:=y[i];

c:=a+b+p;

z[i]:=c mod 10;

p:=c div 10;

end;

if p>0 then begin write('переполнение');

readln

end

end;

procedure sub (x,y:chislo;var z:chislo);

var i,j,p,l,a,b,r,c:integer;

begin p:=0;

for i:=kol downto 1 do

begin a:=(x[i]);

b:=(y[i]);

c:=a-b+p;

if c<0 then begin c:=c+10;

p:=-1;

end

else p:=0;

z[i]:=(c);

end;

if p<0 then begin write('отриц.число');

readln

end;

end;

procedure Division(x,y:chislo;var z,O:chislo);

var a,b,r,c,i,j,xt,yt,yt1,s:integer;

y1:chislo;

begin z:=C0; o:=x;

if sravnenie(x,y)=-1 then exit;

y1:=y;

yt:=1;while y[yt]=0 do inc(yt);

xt:=1;while x[xt]=0 do inc(xt);

s:=yt-xt;yt1:=xt;

for i:=1 to kol do if i+s<=kol then y1[i]:=y1[i+s]

else y1[i]:=0;

while yt1<=yt do

begin r:=0;

while not(sravnenie(x,y1)=-1) do

begin Sub(x,y1,x);

r:=r+1

end;

for i:=1 to kol-1 do z[i]:=z[i+1];

z[kol]:=r;r:=0;

for i:=kol downto 2 do y1[i]:=y1[i-1];

y1[1]:=0;yt1:=yt1+1;

end;

o:=x

end;

procedure print(x:chislo);

var i:integer;

p:boolean;

begin p:=false;

for i:=1 to kol do

begin if x[i]<>0 then p:=true;

if p then write(x[i])

end;

if not(p) then write(0)

end;

procedure input(var x:chislo);

var i,j:integer; s:string;

begin readln(s);

x:=c0;j:=kol;

for i:=length(s) downto 1 do

begin val(s[i],x[j],code);

j:=j-1;

end;

end;

begin for i:=1 to kol do c0[i]:=0;

c1:=c0;c1[kol]:=1;

write('Введите n=');input(n);x:=n;

j:=c1;add(j,c1,j);k:=0;

writeln('Делители:');

writeln(1);p:=true;lastd:=c1;

while not(sravnenie(x,j)=-1) do

begin division(x,j,z,o);

if sravnenie(o,c0)=0

then begin x:=z;

if not(sravnenie(lastd,j)=0)

then begin k:=k+1;

lastd:=j;

print(j);

writeln

end

end

else add(j,c1,j);

end;

writeln('Всего ',k+1,' делителей');

readln

end.

15. Переставить цифры числа так, чтобы образовалось максимальное

число, записанное теми же цифрами

program borlpasc;

var n:string; c:char;i,j:integer;

begin write('введите n'); readln(n);

for j:=1 to length(n) do

for i:=1 to length(n)-1 do

if n[i]<n[i+1] then begin c:=n[i]; n[i]:=n[i+1]; n[i+1]:=c;

end;

writeln('n=',n);

end.

16. Переставить цифры числа так, чтобы образовалось наименьшее число, записанное теми же цифрами.

program borlpasc;

var n:string; c:char;i,j:integer;

begin write('введите n='); readln(n);

for j:=1 to length(n) do

for i:=1 to length(n)-1 do

if n[i]>n[i+1] then begin c:=n[i]; n[i]:=n[i+1]; n[i+1]:=c;

end;

writeln('n=',n);

end.

17. составить программу перевода римских чисел в арабски

program borlpasc;{сост вить прогр мму перевод римских чисел в р бские}

var s:string; {ВЕРНА!!!!}

n,c,c1,i,a:integer;

begin writeln('введите число:');

readln(s);

c:=0;n:=0;

for i:=1 to length(s) do

begin

c1:=c;

if s[i]='I' then c:=1;

if s[i]='V' then c:=5;

if s[i]='X' then c:=10;

if s[i]='L' then c:=50;

if s[i]='C' then c:=100;

if s[i]='D' then c:=500;

if s[i]='M' then c:=1000;

if c>c1 then a:=-2*c1

else a:=0;

n:=n+a+c

end;

writeln('в ше число=',n)

end.

18. Дано натур. число N. Если это не палиндром, реверсируйте его цифры

и сложите исходное число с числом, полученным в результате

реверсирования. Если сумма не палиндром, то повторите те же действия

и выполняйте их до тех пор, пока не получится палиндром

{ Пример: }

{ 78+87=165 }

{ 165+561=726 }

{ 726+627=1353 }

{ 1353+3531=4884 }

uses CRT;

var N, N2, nn:Longint;

BEGIN

ClrScr;

Write('N:= '); ReadLn(N);

nn:= 0;

repeat

N:= N+ nn;

nn:= 0;

N2:= N;

while N>0 do begin

nn:= nn*10+(N mod 10);

N:= N div 10;

end;

N:= N2;

Write(#13#10,N,'+ ', nn, '=');

until N=nn;

WriteLn(' Ответ');

Write('< Ok >'); ReadKey;

END.

19. Дано натур. число N. Поменять порядок следования цифр в этом числе на обратный

uses CRT;

var N, nn:Longint;

BEGIN

ClrScr;

Write('N:= '); ReadLn(N);

nn:= 0;

while N>0 do begin

nn:= nn*10+(N mod 10);

N:= N div 10;

end;

WriteLn('N''= ',nn);

Write(#10#13'< Ok >'); ReadKey;

END.

20. Дано натур. число N. Найти и вывести все числа в интервале от 1

до N-1, у которых произведение всех цифр совпадает с суммой цифр

данного

uses CRT;

var N, nn, i, A, B:integer;

BEGIN

ClrScr;

Write('N:= '); ReadLn(N);

A:= 1;

nn:= N;

Write('Произведение ');

while nn>0 do begin

A:= (nn mod 10)* A;

if (nn mod 10)>1 then

Write(nn mod 10,'x');

nn:= nn div 10;

end;

WriteLn(#8'=',A);

WriteLn('Числ :');

for i:=1 to N-1 do begin

nn:= i;

B:=1;

while nn>0 do begin

B:= (nn mod 10)* B;

nn:= nn div 10;

end;

if A=B then Write(i:8);

end;

Write(#10#13'< Ok >'); ReadKey;

END.

20. Найти произведение цифр заданного целого четырехзначного

числа.

Систем тестов

+------------------------------------------------------------------------------+

¦ Номер ¦ Проверяемый ¦ Число ¦ Результ ты ¦

¦ тест ¦ случ й ¦ ¦ ¦

¦-------+---------------------+---------------+----------------¦

¦ 1 ¦ Число положительное ¦ Number = 2314 ¦ P = 24 ¦

¦-------+---------------------+---------------+----------------¦

¦ 2 ¦ Число отриц тельное ¦ Number =-1245 ¦ P = 40 ¦

+-------------------------------------------------------------------------------+

Program DigitsProduct;

Uses Crt;

Var Number, {з д нное число}

i, j, k, l, {цифры числ }

P : Integer; {произведение цифр}

BEGIN ClrScr;

Write( 'Введите четырехзн чное число : ' ); ReadLn(Number);

Write( 'Цифры числ ' , Number , ' : ' );

Number:=Abs(Number);

i := Number div 1000; Write(i:3); {перв я цифр }

j := Number div 100 mod 10; Write(j:3); {втор я цифр }

k := Number div 10 mod 10; Write(k:3); {третья цифр }

l := Number mod 10; WriteLn(l:3); {четверт я цифр }

P := i * j * k * l ;

WriteLn( 'О т в е т : произведение цифр равно ' , P );

ReadLn

END.

21. Определить является ли заданная последовательность

чисел 1, 2,..., N монотонно убывающей.

Систем тестов

+------------------------------------------------+

¦ Номер ¦ Проверяемый ¦ Д нные ¦ ¦

¦ тест ¦ случ й +--------------¦ Результ т ¦

¦ ¦ ¦ N ¦ Вектор А ¦ ¦

¦-------+-------------+---+----------+-----------¦

¦ 1 ¦ Является ¦ 3 ¦(3, 2, 1) ¦ "Да " ¦

¦-------+-------------+---+----------+-----------¦

¦ 2 ¦ Не является ¦ 3 ¦(2, 3, 1) ¦ "Нет" ¦

+------------------------------------------------+}

Program Decrease;

Uses Crt;

Var A : Array [1..10] of Real;

N, i : Integer;

Otvet: Boolean;

{--------------------------------------------}

Procedure InputOutput; {опис ние процедуры ввод -вывод д нных}

Begin

ClrScr;

Write('Количество элементов - '); ReadLn(N);

For i := 1 to N do

begin

Write('A[' , i , '] = '); ReadLn(A[i])

end; WriteLn;

WriteLn('З д нн я последов тельность чисел');

For i := 1 to N do Write(A[i] : 5 : 1);

WriteLn

End; { of InputOutput }

{--------------------------------------------}

Procedure Processing( Var Otvet: Boolean);

Begin {опис ние процедуры проверки н убыв ние элементов}

Otvet := TRUE; i:=1;

While (i<=N-1) and Otvet do

If (A[i]<A[i+1]) then Otvet := FALSE

else i := i+1;

End; { of Processing }

{--------------------------------------------}

Procedure Result(Otvet: Boolean); {опис ние процедуры вывод результ т }

Begin

If Otvet then Write('обр зует ')

else Write('не обр зует ');

WriteLn('монотонно убыв ющую последов тельность.');

ReadLn

End;

{--------------------------------------------}

BEGIN

InputOutput; {вызов процедуры ввод -вывод }

Processing(Otvet); {вызов процедуры проверки н убыв ние}

Result(Otvet); {вызов процедуры вывод результ т }

END.

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

Инициализация графики

Язык Turbo   Pascal   предоставляет целый ряд   процедур   и других средств, позволяющих рисовать на экране разноцветные точки, отрезки прямых, дуги, закрашенные и незакрашенные окружности, прмоугольники, а также выполнять ряд других действий.

Все средства для работы с графикой находятся в модуле GRAPH, поэтому он должен быть подключен в программе перед тем, как начать работу:

USES Graph;
Инициализация графики производится с помощью процедуры InitGraph:

InitGraph(var GraphDriver:Integer; var GraphMode:Integer; PathToDriver:String)

Переменная GraphDriver определяет тип видеоадаптера, GraphMode - тип графического режима. Если переменной GraphDriver присвоить значение Detect, то Паскаль сам определит установленный видеоадаптер и установит самый мощный из имеющихся графический режим

Переменная PathToDriver определяет путь к каталогу, в котором находятся графические драйвера Паскаля. Для проверки успешности инициализации графики можно использовать процедуру GraphResult.

Если графика была успешно инициализировнана, то процедура GraphResult вернет значение grOk.

Процедуры модуля Graph.

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

Очень важно! В языке Паскаль используется нестандартная система координат. Нуль ее расположен в левом верхнем углу, ось Ox направлена вправо, а Oy - вниз.

Процедуры для рисования фигур.

PutPixel(X, Y:Integer; Pixel:Word);

Рисует на экране точку с координатами (X, Y) цветом Pixel.

Line(X1, Y1, X2, Y2:Integer);

Рисует на экране отрезок прямой от точки (X1, Y1) до точки (X2, Y2).

Rectangle(X1, Y1, X2, Y2:Integer);

Рисует на экране прямоугольник с верхним левым углом в точке (X1, Y1) и нижним правым углом в точке (X2, Y2).

Bar(X1, Y1, X2, Y2:Integer);

Рисует на экране залитый прямоугольник с верхним левым углом в точке (X1, Y1) и нижним правым углом в точке (X2, Y2). Стиль и цвет заливки задаются процедурой SetFillStyle.

Bar3D(X1, Y1, X2, Y2:Integer; Depth:Word; Top:Boolean);

Рисует на экране параллелепипед с залитой передней гранью. Глубина фигуры - Depth. Если Top равно TopOn , то параллелепипед рисуется с верхней гранью, если TopOff, то без верхней грани. Стиль и цвет заливки передней грани задаются процедурой SetFillStyle.

Circle(X, Y:Integer; Radius:Word);

Рисует на экране окружность с центром в точке (X, Y) радиусом Radius.

Ellipse(X, Y:Integer; StAngle, EndAngle:Word; XRadius, YRadius:Word);

Рисует на экране эллиптическую дугу с центром в точке (X, Y), радиусами XRadius, YRadius. StAngle, EndAngle - начальный и конечный углы.

Arc(X, Y:Integer; StAngle, EndAngle:Word; Radius:Word);

Рисует на экране дугу окружности с центром в точке (X,Y), радиусом Radius. StAngle, EndAngle - начальный и конечный углы.

FillEllipse(X, Y:Integer; XRadius,YRadius:Word);

Рисует на экране залитый эллипс с центром в точке (X, Y), радиусами XRadius, YRadius. Стиль и цвет заливки задаются процедурой SetFillStyle.

Sector(X, Y:Integer; StAngle, EndAngle:Word; XRadius, YRadius:Word);

Рисует на экране закрашенный сектор эллипса с центром в точке (X, Y), радиусами XRadius, YRadius. StAngle, EndAngle - начальный и конечный углы. Стиль и цвет заливки задаются процедурой SetFillStyle.

PieSlice(X, Y:Integer; StAngle, EndAngle:Word; Radius:Word);

Рисует на экране закрашенный сектор круга с центром в точке (X, Y), радиусом Radius. StAngle, EndAngle - начальный и конечный углы. Стиль и цвет заливки задаются процедурой SetFillStyle.

Другие процедуры.

ClearDevice;

Очищает экран в графическом режиме.

CloseGraph;

Закрывает графический режим.

SetColor(Color:Word);

Устанавливает новый цвет для рисования.

SetLineStyle(LineStyle:Word; Pattern:Word; Thickness:Word);

Устанавливает стиль и толщину линий. Если Thickness равно ThickWidth, то линии будут толстыми, если NormWidth, то обычными.

SetFillStyle(Pattern:Word; Color:Word);

Устанавливает стиль и цвет заливки. Если Pattern равно UserFill, то используется определенный пользователем стиль, описанный процедурой SetFillPattern.

SetFillPattern(Pattern:FillPatternType; Color:Word);

Устанавливает определяемый пользователем стиль и цвет заливки. FillPatternType=Array [1..8] of Byte;

FloodFill(X, Y:Integer; Border:Word);

Заливает область вокруг точки (X, Y) до линии цвета Border, используя текущий стиль и цвет заливки.

SetTextStyle(Font, Direction:Word; CharSize:Word);

Устанавливает используемый шрифт, его направление и размер. Направление соответствует значению переменной Direction и может быть горизонтальным (Direction=0) или вертикальным (Direction=1). Шрифт может быть как одним из стандартных, так и определенный пользователем (с помощью функции InstallUserFont).

SetUserCharSize(MultX, DivX, MultY, DivY:Word);

Устанавливает ширину букв используемого шрифта в MultX/DivX раз больше, а высоту в MultY/DivY раз больше.

OutTextXY(X, Y:Integer; TextString:String);

Выводит текст TextString на экран от точки (X, Y).

Образец:

{ Внимание! Для работы этой программы необходимо, чтобы:

1) Turbo Pascal был установлен в к т лог C:\TP;

2) к талог C:\TP\BGI содержал файл egavga.bgi ;

3) в меню Options/Directories был указан путь

к файлу graph.tpu, н пример, С:\TP\UNITS.

Если Turbo Pascal установлен в другом к т логе, нужно изменить

путь к нему в процедуре InitGraph (10-я строк программы).

}

Program Lines;

Uses Graph, Crt; {подключение к программе библиотек Crt и Graph}

Var

Key : Char;

LineStyle : Word; { номер стиля рисования линии }

Style : String; { название стиля }

GrDriver, GrMode : Integer; { тип и режим р боты гр фического др йвер }

GrError : Integer; { код ошибки гр фики }

BEGIN

GrDriver := Detect; { втоопределение тип гр фического др йвер }

InitGraph(GrDriver, GrMode, 'C:\TP\BGI'); { уст новк гр фического режим }

GrError := GraphResult;

If GrError<>GrOk then begin Writeln('Обн ружен ошибк !'); Halt

end;

SetBkColor(LightGray); SetColor(Red); { цвет фон и цвет рисов ния }

{------------------------------------------------------------}

OutTextXY(120, 100, 'Рисуем линию от точки (200,200) к точке (400,280)');

Line(200, 200, 400, 280);

Key:=ReadKey; { приост новление исполнения прогр ммы }

ClearViewPort; { очистк окн }

{-----------------------------------------------------------}

OutTextXY(240, 80, 'Рисуем лом нную');

Rectangle(110, 120, 520, 400); { рисов ние р мки }

MoveTo(Round(GetMaxX/2), Round(GetMaxY/2)); { ук з тель в центре окн }

Repeat {цикл прерыв ется н ж тием любой кл виши}

LineTo(Random(GetMaxX-250)+120, Random(GetMaxY-210)+120);

Delay(100);

until KeyPressed;

Key := ReadKey; ClearViewPort;

{-----------------------------------------------------------}

OutTextXY(190, 80, 'Mеняем стили рисов ния линий');

For LineStyle := 0 to 3 do

begin

SetLineStyle(LineStyle, 0, 1);

Case LineStyle of

0: Style:='Сплошн я';

1: Style:='Точечн я';

2: Style:='Штрихпунктирн я';

3: Style:='Пунктирн я'

end;

Line(120, 150+LineStyle*50, 430, 150+LineStyle*50);

OutTextXY(450, 145+LineStyle*50, Style);

end;

Key:=ReadKey; ClearViewPort; {очистк окн }

{-----------------------------------------------------------}

OutTextXY(180, 80, 'Меняем толщину рисов ния линий');

SetLineStyle(0, 0, 1); {толщин 1 пиксел }

Line(140, 200, 430, 200); OutTextXY(450, 195, 'Норм льн я');

SetLineStyle(0, 0, 3); {толщин 3 пиксел }

Line(140, 250, 430, 250); OutTextXY(450, 245, 'Тройн я');

ReadLn; CloseGraph; {з крытие гр фического режим }

END.

Образец 2:

{ Движущееся сложное изобр жение }

program titanik;

uses Graph,

Crt;

var

grDriver:integer; { др йвер }

grMode:integer; { гр фический режим }

grPath:string; { место р сположения др йвер }

ErrCode:integer; { результ т иници лиз ции гр ф. режим }

x,y:integer; { координ ты кор блик }

color:word; { цвет кор блик }

bkcolor:word; { цвет фон экр н }

{ Кор блик }

Procedure Titan(x,y:integer; { координ ты б зовой точки }

color:word); { цвет кор бля }

const

dx=5;

dy=5;

var

OldColor:word;

begin

OldColor:=GetColor; { сохр нить текущий цвет }

SetColor(color); { уст новить новый цвет }

{ корпус }

MoveTo(x,y);

LineTo(x,y-2*dy);

LineTo(x+10*dx,y-2*dy);

LineTo(x+11*dx,y-3*dy);

LineTo(x+17*dx,y-3*dy);

LineTo(x+14*dx,y);

LineTo(x,y);

{ н дстройк }

MoveTo(x+3*dx,y-2*dy);

LineTo(x+4*dx,y-3*dy);

LineTo(x+4*dx,y-4*dy);

LineTo(x+13*dx,y-4*dy);

LineTo(x+13*dx,y-3*dy);

Line(x+5*dx,y-3*dy,x+9*dx,y-3*dy);

{ к пит нский мостик }

Rectangle(x+8*dx,y-4*dy,x+11*dx,y-5*dy);

{ труб }

Rectangle(x+7*dx,y-4*dy,x+8*dx,y-7*dy);

{ иллюмин торы }

Circle(x+12*dx,y-2*dy,Trunc(dx/2));

Circle(x+14*dx,y-2*dy,Trunc(dx/2));

{ м чт }

Line(x+10*dx,y-5*dy,x+10*dx,y-10*dy);

{ осн стк }

MoveTo(x+17*dx,y-3*dy);

LineTo(x+10*dx,y-10*dy);

LineTo(x,y-2*dy);

SetColor(OldColor); { восст новить текущий цвет }

end;

begin

grDriver := VGA; { режим VGA}

grMode:=VGAHi; { р зрешение 640х480}

grPath:='d:\bp\bgi'; { др йвер, ф йл EGAVGA.BGI, н ходится

в к т логе d:\bp\bgi }

InitGraph(grDriver, grMode,grPath);

ErrCode := GraphResult;

if ErrCode <> grOk then Halt(1);

x:=10;

y:=200;

color:=LightGray;

SetBkColor(Blue);

bkcolor:=GetBkColor;

repeat

Titan(x,y,color); { н рисов ть кор бль }

Delay(100);

Titan(x,y,bkcolor); { стереть кор бль }

PutPixel(x,y,color); { след от кор бля }

x:=x+2;

until (x>500);

OutTextXY(10,10,'Рейс з вершен!');

readln;

CloseGraph;

End.

11

ОСНОВНЫЕ ПРИНЦИПЫ ООП

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

Характерной чертой объектов является инкапсуляция (объединение) данных и алгоритмов их обработки, в результате чего и данные, и процедуры во многом теряют самостоятельное значение.

Фактически объ­ектно-ориентированное программирование можно рассматривать как модульное про­граммирование нового уровня, когда вместо во многом случайного, механического, объединения процедур и данных акцент делается на их смысловую связь.

Какими мощными средствами располагает объектно-ориентированное программирование, наглядно демонстрирует библиотека Turbo Vision, входящая в комплект по­ставки Турбо Паскаля

Объектно-ориентированное программирование основано на «трех китах» - трех важнейших принципах, придающих объектам новые свойства.

Этими принципами являются инкапсуляция, наследование и полиморфизм.

Инкапсуляция - есть объединение в единое целое данных и алгоритмов обработки этих данных. В рамках ООП данные называются полями объекта, а алгоритмы - объектными методами.

Инкапсуляция позволяет в максимальной степени изолировать объект от внешнего окружения.

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

Другим немаловажным следствием инкапсуляции является легкость обмена объ­ектами, переноса их из одной программы в другую. Можно сказать, что ООП «провоцирует» разработку библиотек объектов, таких как Turbo Vision.

Наследование

Наследование есть свойство объектов порождать своих потомков.

Объект-потомок автоматически наследует от родителя все поля и методы, может дополнять объекты новыми полями и заменять (перекрывать) методы родителя или дополнять их.

Принцип наследования решает проблему модификации свойств объекта и придает ООП в целом исключительную гибкость. При работе с объектами программист обыч­но подбирает объект, наиболее близкий по своим свойствам для решения конкретной задачи, и создает одного или нескольких потомков от него, которые «умеют» делать то, что не реализовано в родителе.

Последовательное проведение в жизнь принципа «наследуй и изменяй» хорошо согласуется с поэтапным подходом к разработке крупных программных проектов и во многом стимулирует такой подход.

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

В рам­ках ООП поведенческие свойства объекта определяются набором входящих в него методов. Изменяя алгоритм того или иного метода в потомках объекта, программист может придавать этим потомкам отсутствующие у родителя специфические свойства. Для изменения метода необходимо перекрыть его в потомке, т.е. объявить в потомке одноименный метод и реализовать в нем нужные действия. В результате в объекте-родителе и объекте-потомке будут действовать два одноименных метода, имеющие разную алгоритмическую основу и, следовательно, придающие объектам разные свой­ства. Это и называется полиморфизмом объектов.

(на примере двух работающих модулей и тексте программы)

Обработанный материал из учебного пособия Фаронов В.В. “Turbo Pascal 7.0” Учебное пособие. Начальный курс. Нолидж. Москва. 2001 г. (с.179-194)

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

Вид создаваемого программой экрана.

Для перемещения изображений в программе будут использоваться:

клавиши управ­ления курсором,

клавиши Ноте, End, PgUp, PgDn (для перемещения по диагональным направлениям),

клавиша Tab для выбора перемещаемого объекта.

Выход из про­граммы - клавиша Esc.

Техническая реализация программы требует использования средств двух стан­дартных библиотек - CRT и GRAPH.

Для решения задачи создадим два модуля GraphObj и GraphApp.

В Модуле GraphObj описываются все используемые объекты. Модуль компилируется в библиотечный файл GraphObj.tpu.

Основная программа будет использовать модуль GraphObj с описанием объектов.(Далее текст рабочего модуля. Файл: GraphObj.pas. )

Unit GraphObj;

Interface

type

TGraphObj=object {объект – родитель в рамках ко­торого инкапсулированы поля и методы, общие для всех остальных объектов<=Свойство объектов-инкапсуляция }

Private { Поля объекта будут скрыты от пользователя. Объект не может менять координаты реперной точки и цвет фигуры. Описания полей ничем не отличаются от описания обычных переменных.}

x,y:integer; {Координаты реперной точки}

color:word; {Цвет фигуры}

Public {Методы объекта будут доступны пользователю. Директива public отменяет действие директивы private. Для описания методов используются процедуры и функции, конструкторы и деструкторы.}

Constructor Init(aX,aY:integer; aColor:word); { Конструк­торы предназначены для создания конкретного экземпляра объекта обращение к конструк­тору должно предшествовать обращению к любому виртуальному методу. Типичное действие, реализуемое конструктором, состоит в наполнении объектных полей конкретными значениями.}

Procedure Draw (aColor:word);virtual; {Вычерчивает объект заданным цветом aColor В объекте TGraphObj процедура Draw определена как вирту­альная («воображаемая»). Абстрактный объект TGraphObj не предназначен для выво­да на экран, однако наличие процедуры Draw в этом объекте говорит о том, что любой потомок TGraphObj должен иметь собственный метод Draw, с помощью которого он может показать себя на экране. (<=Свойство объектов – полиморфизм).При трансляции объекта, содержащего виртуальные методы, создается так называе­мая таблица виртуальных методов (ТВМ), количество элементов которой равно коли­честву виртуальных методов объекта. В этой таблице будут храниться адреса точек вхо­да в каждый виртуальный метод. В нашем примере ТВМ объекта TGraphObj хранит единственный элемент - адрес метода Draw.}

Procedure Show; {Показывает объект - вычерчивает его цветом Color. Для реализации своих действий и Hide, и Show обращаются к виртуальному методу Draw.}

Procedure Hide; {Прячет объект - вычерчивает его цветом фона}

Procedure MoveTo (dX,dY:integer); {Перемещает объект в точку с координатами X+dX и Y+dY. Если потомок TGraphObj (например, TLine) хочет переместить себя на экране, он обращается к родительскому методу MoveTo.

В этом методе сначала с помощью Hide объект стирается с экрана, а затем с помощью Show показывается в другом месте.}

end; {Конец описания объекта TGraphObj}

{Далее мы создадим несколько потомков объекта TGraphObj. Каждый из них будет иметь собственный конструктор, с помощью которого ТВМ каждого потомка настраивается так, чтобы ее единственный элемент содержал адрес нужного метода Draw.

Такая процедура называется поздним связыванием объекта.

Позднее связывание позволяет методам родителя обращаться к виртуальным методам своих потомков и использовать их для реализации специфичных для потомков действий. (Это опять - полиморфизм)(В нашем примере она совпадает с координатами точки в описываемом ниже объекте TPoint, с цен­тром окружности в объекте TCircle, первым концом прямой в объекте Liпе и с левым верхним углом пря­моугольника в объекте TRect.)}

{Сначала описываются все объекты (совокупность полей и методов (данные и процедуры) присущих только данному объекту), а далее обычно в разделе Implementation объектного модуля описываются соответствующие объектам процедуры и функции (т.е. соответствующие методы (действия над объектами)}

TPoint = object(TGraphObj) {Описание объекта TPoint. Потомки объекта TGraphObj: TPoint, TLine, TCircle наследуют поля и методы родительского объекта. TRect – потомок объекта TLine <=Свойство объектов – наследование. }

Procedure Draw (aColor:word);virtual;

end;

TLine= object(TGraphObj)

dx,dy:integer; {Приращения координат второго конца}

Constructor Init(X1,Y1,X2,Y2:integer; aColor:word); {Инициализируется новый объект TLine который является наследником объекта TGraphObj,но скоро будет «отцом» объекта TRect,а новый обьект будет по прежнему использовать «дедовскую» виртуальную процедуру Draw. По-этому вместо слова Procedure пишем Constructor }

Procedure Draw (aColor:word);virtual;

end;

{Поскольку вызов MoveTo ,будет происходить в рамках объекта TLine, используется ТВМ этого объекта и вызывается его метод Draw, вычерчивающий прямую. Если бы перемещалась окружность, ТВМ содержала бы адрес метода Draw объекта TCircle и визуализация-стирание объекта осуществлялась бы с помощью этого метода. (Следует выполняется третье свойство объектов - полиморфизм)}

TCircle = object(TGraphObj)

r:integer; {вводится новое поле объекта, которое отсутствует у предка - радиус}

Constructor Init(aX,aY,aR:integer; aColor:word);{Перед использованием «виртуальной» процедуры Draw при инициализации нового объекта всегда заменяем слово Procedure на слово Constructor. Так как выводиться на экран будет новый объект. То есть меняем ссылку с указанием параметров вывода предыдущего объекта на новые. В данном случае на следующем шаге Draw выведет на экран – окружность. }

Procedure Draw (aColor:word);virtual;

end;

TRect= object(TLine) {TRect – потомок объекта TLine}

Procedure Draw (aColor:word);virtual;

end;

{Описание методов (- «телодвижений» объектов) производится обычным для Паскаля способом в любом месте раздела описаний (обычно в разделе Implementation объектного модуля), но после описания объекта.}

Implementation

{Исполняемая часть содержит описания всех объектных методов}

Uses Graph;

Constructor TGraphObj.Init; {Инициализируется родительский объект TGraphObj. Далее используется виртуальный метод Draw, по-этому вместо слова Procedure используется слово Constructor }

Begin

X:=aX;

Y:=aY;

color:=aColor;

end;

Procedure TGraphObj.Draw; {Эта процедура в родительском объекте ничего не делает, поэто­му экземпляры TGraphObj не способны отображать себя на экране. Чтобы потомки объекта TGraphObj были способны отображать себя, они должны перекрывать этот метод (стоять раньше «телодвижений» потомков)}

Begin

end;

Procedure TGraphObj.Show; {Процедура вывода на экран «виртуального» объекта (нарисованного Draw-ом с соответствующими указаниями на вид обекта (окружность это или линия или точка и т.п.))соответствующим объекту цветом color }

Begin

Draw(color);

end;

Procedure TGraphObj.Hide; {Процедура вывода на экран виртуального объекта цветом фона }

Begin

Draw(GetBkcolor);

end;

Procedure TGraphObj.MoveTo; {Процедура перемещения виртуального объекта на dX и dY }

Begin

Hide;

X:=X+dX;

Y:=Y+dY;

Show;

end;

{ Отмечу два обстоятельства.

Во-первых, при описании методов имя метода допол­няется спереди именем объекта, т.е. используется составное имя метода. Это необхо­димо по той простой причине, что в иерархии родственных объектов любой из мето­дов может быть перекрыт в потомках. Составные имена четко указывают принадлеж­ность конкретной процедуры.

Во-вторых, в любом объектном методе можно исполь­зовать инкапсулированные поля объекта почти так, как если бы они были определены в качестве глобальных переменных.

Например, в-конструкторе TGraph.Init перемен­ные в левых частях операторов присваивания представляют собой объектные поля и не должны заново описываться в процедуре. Более того, описание

Constructor TGraphObj.Init;

var

X,Y: Integer; {Ошибка!}

Color: Word; {Ошибка!}

begin

…

…

end;

вызовет сообщение о двойном определении переменных X, Y и Color (в этом и состоит отличие в использовании полей от глобальных переменных: глобальные переменные можно переопределять в процедурах, в то время как объектные поля переопределять нельзя).

}

Procedure TPoint.Draw; {В новом объекте TPoint можно использовать любые методы объекта-родителя TGraphObj.

Например, вызвать метод MoveTo, чтобы переместить изображение точки на новое место. В этом случае родительский метод TGraphObj.MoveTo будет обра­щаться к методу TPoint.Draw, чтобы спрятать и затем показать изображение точки.

Такой вызов станет доступен после обращения к конструктору Init объекта TPoint, который нужным образом настроит ТВМ объекта.

Если вызвать TPoint.Draw до вызо­ва Init, его ТВМ не будет содержать правильного адреса и программа «зависнет».}

Begin

PutPixel (X,Y,Color);

end;

Constructor Tline.Init; {В конструкторе TLine.Init для инициации полей X, Y и Color, унаследованных oт родительского объекта, вызывается унаследованный конструктор TGraphObj.Init, для чего используется зарезервированное слово inherited (англ.- унаследованный).

Здесь слово Procedure заменено на Constructor так как далее при использовании Draw начальная точка линии будет выводиться как точка (или из точки) уже проинициализированной ранее при инициализации родительского объекта TGraphObj (т.е. используются «виртуальные» параметров вывода на экран «точки», на которую указывает ТВМ начальной установки родителя, при рисовании линии) }

Begin

Inherited Init (X1,Y1,aColor); {Инициируем поля dX и dY}

dX:=X2-X1;

dY:=Y2-Y1;

end;

Procedure TLine.Draw;

Begin

SetColor(Color); {Устанавливаем цвет Color}

Line(X,Y,X+dX,Y+dY); {Вычерчиваем линию}

end;

Constructor TCircle.Init; {Вызывает унаследованный конструктор TGraphObj для инициации полей X, Y и Color. Затем инициирует поля dX и dY}

{Далее используется виртуальный метод Draw, с начальными параметрами родителя и унаследованными полями при инициализации родителя, по - этому вместо слова Procedure используется слово Constructor }

Begin

Inherited Init (aX,aY,aColor); {Вызываем унаследованный конструктор}

R:=aR; {новое поле- радиус}

end;

Procedure TCircle.Draw;{Процедура – выводит окружность. Виртуальные параметры для центра окружности унаследованы от родителя, а при инициализации окружности добавлен еще и радиус aR}

Begin

SetColor(aColor);

Circle(X,Y,R);

end;

{ В объекте TRect, с помощью которого создается и перемещается прямоугольник, учтем то обстоятельство, что для задания прямоугольника требуется указать четыре целочисленных параметра, т.е. столько же, сколько для задания линии. Поэтому объ­ект TRect удобнее породить не от TGraphObj, а от TLine, чтобы использовать его кон­структор Init}

Procedure TRect.Draw; {Процедура рисования прямоугольника}

Begin

SetColor(aColor);

Rectangle(X,Y,X+dX,Y+dY); {Вычерчиваем прямоугольник}

end;

end. {окончание самостоятельного модуля GraphObj }

{Самостоятельный модуль GraphApp. Располагается в файле GraphApp.pas.

После компиляции расположить в каталоге Units под именем GraphApp.tpu.}

{ Идею инкапсуляции полей и алгоритмов можно применить не только к графиче­ским объектам, но и ко всей программе в целом.

Ничто не мешает нам создать объект-программу и «научить» его трем основным действиям: инициации (Init), выполнению основной работы (Run) и завершению (Done).

На этапе инициации экран переводится в графический режим работы и создаются и отображаются графические объекты (100 экземпляров TPoint и по одному экземпляру TLine, TCircle, TRect).

На этапе Run осу­ществляется сканирование клавиатуры и перемещение графических объектов. Нако­нец, на этапе Done экран переводится в текстовый режим и завершается работа всей программы.

Назовем объект-программу именем TGraphApp и разместим его в модуле GraphApp (пока не обращайте внимание на точки, скрывающие содержательную часть модуля - позднее будет представлен его полный текст)}

Unit GraphApp;

Interface

Uses GraphObj;

const

Npoints=100; {Количество точек}

Type

{Объект-программа}

TGraphApp=Object

Points:array [1..NPoints] of TPoint; {Массив точек} Line:Tline; {Линия}

Rect:TRect; {Прямоугольник}

Circ:TCircle; {Окружность}

ActiveObj:Integer; {Активный объект}

Procedure Init;

Procedure Run;

Procedure Done;

Procedure ShowAll;

Procedure MoveActiveObj(dX,dY:integer);

end;

Implementation

Uses Graph,CRT;

Procedure TGraphApp.Init; {Инициирует графический режим работы экрана. Создает и отобра­жает NPoints экземпляров объекта TPoint, а также экземпляры объектов TLine, TCircle и Trect}

Var

D,R,Err,k:integer;

Begin

{Инициируем графику}

D:=detect; {Режим автоматического определениятипа графического адаптера}

InitGraph(D,R,'d:\tp7\bgi'); {Инициируем графический режим. Текстовая строка должна задавать путь к каталогу с графически­ми драйверами}

Err:=GraphResult; {Проверяем успех инициации графики}

If Err<>0 then

begin

GraphErrorMsg(Err);

Halt;

end;

{Создаем точки}

for k:=1 to Npoints do

Points[k].Init(Random(GetMaxX),Random(GetMaxY),Random(15)+1);

Line.Init(GetMaxX div 3, GetMaxY div 3,2*GetMaxX div 3, 2* GetMaxY div 3, LightRed);

Circ.Init (GetMaxX div 2, GetMaxY div 2, GetMaxY div 5,White);

Rect.Init(2*GetMaxX div 5, 2*GetMaxY div 5,3*GetMaxX div 5, 3* GetMaxY div 5, Yellow);

ShowAll; {Показываем все графические объекты}

ActiveObj:=1; {Первым перемещаем прямоугольник}

end;

Procedure TGraphApp.Run;

{Выбирает объект с помощью Tab и перемещает его по экрану}

var

stop:Boolean; {Признак нажатия Esc}

const

D=5; {Шаг смещения фигур}

Begin

Stop:=False;

{Цикл опроса клавиатуры}

repeat

case ReadKey of {Читаем код нажатой клавиши}

#27: Stop:=True; {Нажата Esc}

#9:begin {Нажата Tab}

inc(ActiveObj);

if ActiveObj>3 then ActiveObj:=1

end;

#0: case ReadKey of

#71: MoveActiveObj(-D,-D); {Влево и вверх}

#72: MoveActiveObj(0, -D); {Вверх}

#73: MoveActiveObj(D, -D); {Вправо и вверх}

#75: MoveActiveObj(-D, 0); {Влево}

#77: MoveActiveObj(D, 0); {Вправо}

#79: MoveActiveObj(-D, D); {Влево и вниз}

#80: MoveActiveObj(0, D); {Вниз}

#81: MoveActiveObj(D, D); {Вправо и вниз}

end

end;

ShowAll;

Until Stop;

end; {TGraphApp.Run}

{————————}

Procedure TGraphApp.Done; {Закрывает графический режим}

begin

CloseGraph;

end; {TGraphApp.Done}

Procedure TGraphApp.ShowAll; {Показывает все графические объекты}

Var

k:integer;

begin

for k:=1 to Npoints do Points[k].Show;

Line.Show;

Rect.Show;

Circ.Show;

end;

Procedure TgraphApp.MoveActiveObj; {Перемещает активный графический объект}

begin

case ActiveObj of

1: Rect.MoveTo(dX,dY);

2: Circ.MoveTo(dX,dY);

3: Line.MoveTo(dX,dY);

end

end;

end.

{Основная программа будет предельно простой:}

Program Graph_Objects;

Uses GraphApp;

var

App: TGraphApp; { Получив это указание, компилятор зарезервирует нужный объем памяти для раз­мещения всех полей объекта TGraphApp. }

Begin

App.Init;

App.Run;

App.Done

end.

{Согласитесь, что введение лишь шести зарезервированных слов, из которых действительно необходимыми явля­ются три (object, constructor и virtual}, весьма небольшая плата за мощный инструмент создания современного программного обеспечения.}

7

Управление машиной, обработка данных осуществляется по алгоритмам, которые вводится в машину в виде программ.

Программы и данные хранятся в памяти машины.

Основное устройство, которое "понимает" программы – центральный процессор.

Во многих источниках синонимом термина "вычислительная машина" является термин компьютер.

В то же время, программа - это формализованная запись алгоритма на конкретном языке программирования.

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

На заре программирования так и делали, в настоящее время программу обычно пишут на языках высокого уровня, а затем переводят (транслируют) ее в машинные команды.

Программа на языке высокого уровня - это обычный текст, оформленный в соответствии с требованиями языка.

орлор

оро

пр

Формальный язык, обеспечивающий удобное описание конкретных проблем, которые формулируются человеком.

На языке программирования пишется программа, которая позволяет, при ее выполнении компьютером (вычислительной системой), получить конкретные результаты.

Язык программирования состоит из двух составляющих: синтаксиса и семантики.

Некоторые авторы включают в синтаксис и алфавит.

В языках программирования транслятор превращает синтаксические построения в команды, понятные операционной системе и процессору.

Смысловые ошибки транслятор не выявляет, их поиск осуществляет человек в процессе отладки, тестирования и даже эксплуатации.

От греч. semantikos - обозначающий.

Переход от языковых конструкций к машинным командам осуществляет транслятор языка.

Программа, производящая трансляцию программы с одного языка программирования в другой.

В языках программирования транслятор превращает синтаксические построения в команды, понятные операционной системе и процессору.

Смысловые ошибки транслятор не выявляет, их поиск осуществляет человек в процессе отладки, тестирования и даже эксплуатации.

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

Как правило, трансляция - это создание программы в машинных кодах, которую можно выполнять.

Различают два вида трансляции:

1) компиляцию, при которой результат получается в виде готовой программы, выполняемой независимо от исходного текста программы;

2) интерпретацию, при которой трансляция и выполнение программы происходит покомандно.

От лат. translatio - передача.

Теоретическая и практическая деятельность по созданию программного обеспечения.

Само программирование - итерационный процесс, который состоит из:

понимания задачи,

разработки алгоритма,

модулей, отладки модулей,

решения тестовой задачи,

сравнения результатов,

уточнения постановки задачи и последующей итерации.

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

Классификации языков программирования

Языки программирования имеют разные классификации.

Приведем только некоторые из них.

Классификация по уровням:

Языки программирования разделяются на языки высокого и низкого уровня в соответствии с тем, в каких терминах следует описывать задачу.

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

Например, языки: Си, Бейсик, Паскаль, Пролог относятся к языкам высокого уровня, а язык ассемблера - язык низкого уровня.

Классификация по стилю программирования:

Стиль - совокупность правил, лежащих в основе синтаксиса и семантики языка программирования.

Различают следующие стили:

неструктурный;

структурный;

логический;

объектно-ориентированный;

функциональный.

Рассмотрим перечисленные стили подробнее.

Неструктурное программирование - допускает использование в явном виде команды безусловного перехода (в большинстве языков GOTO). Типичные представители неструктурных языков - ранние версии Бейсика и Фортрана.

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

Однако в языках высокого уровня наличие команды перехода влечет за собой массу серьезных недостатков: программа превращается в "спагетти" с бесконечными переходами вверх-вниз, ее очень трудно сопровождать и модифицировать.

Фактически неструктурный стиль программирования не позволяет разрабатывать большие проекты.

Ранее широко практиковавшееся первоначальное обучение программированию на базе неструктурного языка (обычно Бейсика) приводило к огромным трудностям при переходе на более современные стили.

Как отмечал известный голландский ученый Э. Дейкстра, "программисты, изначально ориентированные на Бейсик, умственно оболванены без надежды на исцеление".

Структурный стиль (структурное программирование) был разработан в середине 60-х - начале 70-х гг.

В его основе лежат две идеи:

Задача разбивается на большое число мелких подзадач, каждая из которых решается своей процедурой или функцией (декомпозиция задачи).

2) проектирование программы идет по принципу сверху вниз: сначала определяются необходимые для решения программы модули, их входы и выходы, а затем уже эти модули разрабатываются.

Такой подход вместе с локальными именами переменных позволяет разрабатывать проект силами большого числа программистов.

Как доказал Э. Дейкстра, любой алгоритм можно реализовать, используя лишь три управляющие конструкции:

последовательное выполнение,

ветвление,

цикл.

Данное обстоятельство позволяет при наличии соответствующих операторов исключить из языка команду перехода GOTO.

Будем применять в основном структурный стиль.

Логическое программирование - представляет собой попытку возложить на программиста только постановку задачи, а поиски путей ее решения предоставить транслятору.

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

Например, если дано:

БРАТЬЯ ИМЕЮТ ОДНОГО ОТЦА

ДЖОН - ОТЕЦ ДЖЕКА

МАЙК - БРАТ ДЖЕКА

  то система логического программирования должна сделать вывод:

  ДЖОН - ОТЕЦ МАЙКА.

 Хотя работы по логическому программированию ведутся с 50-х гг., в настоящее время данное направление несколько потеряло свою актуальность в связи с отсутствием реальных результатов, поскольку большинство реализованных на принципах логического программирования систем оказались практически непригодными.

Объектно-ориентированное (ОО) программирование, разработанное в середине 70-х гг. Керниганом и Риччи и реализованное в ОО-версиях языков Си и Паскаль, представляет собой отображение объектов реального мира, их свойств (атрибутов) и связей между ними при помощи специальных структур данных.

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

Функциональный стиль

В основе функционального стиля лежит понятие функции как "черного ящика", имеющего вектор параметров (аргументов) на входе и результат r (скаляр) на выходе:

   Допустим случай , т.е. вектор параметров отсутствует.

В функциональных языках программирования отсутствуют операторы: все действия, в том числе и управляющие конструкции, выполняются при помощи вызовов функций.

Поскольку каждая функция возвращает значение, то:

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

Одним из первых функциональных языков стал язык Лисп, созданный в конце 50-х гг. как язык искусственного интеллекта.

К языкам искусственного интеллекта (сокращенно обозначается AI - artificial intelligence) относят такие языки, которые способны в зависимости от набора исходных данных модифицировать алгоритм работы, т.е. "на ходу" менять программу (поговорка гласит, что на языках искусственного интеллекта программируют те, кому не хватает интеллекта естественного).

Языки высокого уровня могут быть декларативными (например, Пролог, ЛИСП) и процедурно-ориетированными (например, Си, Бейсик, Паскаль, Ада). Процедурные языки развиваются в объектно-ориентированные.

Программное обеспечение

Совокупность программ для компьютера образует программное обеспечение (ПО).

По функциональному признаку различают следующие виды ПО:

системное;

прикладное.

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

Основные функции операционных систем (ОС) заключаются в управлении ресурсами (физическими и логическими) и процессами вычислительных систем.

Сетевое ПО - программное обеспечение для поддержки работы объедененных в сеть компьютеров.

К сервисным программам относятся:

утилиты,

драйверы,

файловые оболочки и т.п.

К средствам разработки программ относится среда программирования - Turbo Pascal 7.0 (подробнее рассмотрим на следующих лекциях и практических занятиях) и другие продукты создания ПО.

Прикладным называется ПО, предназначенное для решения определенной целевой задачи из проблемной области. Часто такие программы называют приложениями.

Спектр проблемных областей в настоящее время весьма широк и включает в себя по крайней мере следующие: промышленное производство, инженерную практику, научные исследования, медицину, управление (менеджмент), делопроизводство, издательскую деятельность, образование и т.д.

Приложения и системные программы могут создаваться и в среде программирования TP7.0.

Среда программирования Turbo Pascal 7.0

Среда программировании TurboPascal 7.0 представляет собой интегрированную среду разработки компьютерных программ с использованием языка программирования Pascal.

Следует отметить, что язык программирования, используемый этой системой, значительно шире и мощнее так называемого стандартного языка Pascal.

Turbo Pascal - это больше, чем просто быстрый компилятор Паскаль.

Turbo Pascal -это эффективный компилятор Паскаль с интегрированной

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

В среду программирования Turbo Pascal входят:

редактор,

компилятор,

редактор связей и отладчик

встроенная контекстно-ориентированная справочная система

(Подробнее среда программирования будет изучена в ходе лекционных и практических занятий в процессе создания программных продуктов)

Язык программирования TurboPascal 7.0 является процедурным языком высококо уровня.

Позволяет использовать:

- структурный стиль программирования,

средства ООП (Библиотека Turbo-Vision);

средства неструктурного программирования (подключаемые модули на языке Ассемблер).

Т.Е. среда программирования TP7.0. позволяет создавать как приложения, так и системные программы.

9

Программирование графики в среде Thrbo Pascal 7.0.

Базовые процедуры и функции.

В библиотеке Graph вывод точки осуществляется процедурой

PutPixel(X, Y: integer; Color:word), где X, Y - экранные координаты расположения точки, Color - ее цвет (от 0 до 15).

Для определения цвета точки в конкретной позиции экрана служит функция GetPixel(X, Y: integer): word.

Из точек возможно построение линий. Это выполняет процедура

Line(X1, Y1, X2, Y2), где X1, Y1 - координаты начала, X2, Y2 - координаты конца линии.

Например:

Line(1, 1, 200, 1).

Для черчения линий применяются также еще две процедуры:

LineTo(X, Y) - строит линию из точки текущего положения указателя в точку с координатами X, Y;

LineRel(dX, dY) - проводит линию от точки текущего расположения указателя в точку СРx+dX, CPy+dY, где CPx и CPy - текущие координаты СР.

Установка стиля (тонкие, широкие, штриховые пунктирные линии и т.д.) производится процедурой:

SetLineStyle (LineStyle: word; Pattern: word; Thickness: word). Параметр

LineStyle устанавливает тип строки, который может быть задан поименованной константой или соответствующим ей цифровым значением из Pattern - образец, Thickness - толщину линии, определяемую константами из Табл.2.

Таблица 1

Типы линий

Таблица 2

Толщина линии

Процедура GetLineSettings (Var lineInfo: LineSettingsType) возвращает текущий стиль, образ и толщину линии, установленные SetLineStyle.

В видеобуфере (видеопамяти) для хранения информации о цвете пиксела отводится фиксированное количество битов памяти. Размер палитры и ее организация зависят от типа используемого видеоадаптера.

При использовании видеокарты EGA/VGA для установки цвета пиксела используется 6 битов.

Для формирования цвета используется система RrGgBb, где RGB - красный, зеленный и голубой цвета нормальной яркости, а rgb - те же цвета, но яркость их в два раза меньше.

Для EGA/VGA-карт драйвер EGAVGA..BGI устанавливает 54 цвета.

В Таблице 4 приведены 16 основных цветов.

Таблица 3

Цвета видеокарты EGA/VGA

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

Для EGA и VGA адаптеров в качестве фона может быть задано любое целое число в диапазоне 0-63.

Любой цвет для создания фигур и вывода текста может быть установлен с помощью процедуры SetColor(Color: word).

Фон задается процедурой SetBkColor(Color: word).

Для проверки максимально допустимого количества используемых программой цветов служит процедура GetMaxColor: word, возвращающая максимальное значение кода цвета в палитре минус 1.

Процедуры

GetColor: word - возвращают номера текущего цвета для выводимых элементов

GetBKColor: word возвращают номера текущего цвета для фона.

Для вывода в графическом режиме на экран текста используются процедуры: OutText(TextString: string), выводящая строку текста с текущего положения СР, и OutText(X, Y, Text), где X, Y - координаты точки начала вывода текста, Text - константа или переменная типа string.

Определенные проблемы создает вывод численных данных, так как в модуле Graph нет специально предназначенных для этого процедур.

Установить нужный шрифт вывода можно процедурой

SetTextStyle(Font: word; Direction: word; CharSize: word),

где Font - выбранный шрифт, задаваемый константами из Табл. 5,

Direction - направление вывода (горизонтальное или вертикальное), задаваемое константами из Табл.6,

CharSize - размер выводимых символов.

Таблица 4

Типы шрифтов

Таблица 5

Ориентация текста

Для выравнивания текста необходимо использовать процедуру SetTextJastify (Horiz, Vert: word). Выравнивание относительно СР выполняется по вертикали и по горизонтали с помощью параметров Horiz и Vert (Табл.7).

Таблица 6

Типы линий

Пример:

В следующем примере приведена программа, выводящая заставку. Заставка представляет собой фразу "Демонстрация заставки", напечатанную коричневыми буквами обычного размера и синими буквами увеличенного размера; по периметру экрана нарисованы три разноцветных прямоугольника линиями различной толщины и стиля.

Program Zast;

Uses Graph, Crt;

Var DriverVar, ModeVar :integer;

xm,ym :integer;

c :char;

Begin

{Инициализация графического режима }

DriverVar:=Detect;

InitGraph(DriverVar, Modevar, ‘ ’);

xm:=GetMaxX; ym:=GetMaxY;

{ Вывод прямоугольника, нарисованного зеленой сплошной жирной линией }

SetColor(2); SetLineStyle(0,0,2);

Rectangle(0,0,xm,ym);

{ Вывод прямоугольника, нарисованного голубой сплошной тонкой линией }

SetColor(3); SetLineStyle(0,0,1);

Rectangle(20,20,xm-20,ym-20);

{ Вывод прямоугольника, нарисованного красной пунктирной тонкой линией }

SetColor(4); SetLineStyle(3,0,1);

Rectangle(40,40,xm-40,ym-40);

{ Вывод синего текста с увеличенным размером букв }

SetColor(1); SetTextStyle(0,0,2);

OutTextXY(100,60,'Демонстрация заставки');

{ Вывод коричневого текста с обычным размером букв }

SetColor(6); SetTextStyle(0,0,1);

OutTextXY(150,100,'Демонстрация заставки');

{ Ожидание нажатия клавиши }

c:=readkey;

{ Закрытие графического режима }

CloseGraph;

End.

Библиотека Graph содержит ряд процедур, которые на основе задаваемых параметров формируют различные геометрические фигуры.

Рассмотрим некоторые из них:

Для построения прямоугольных фигур существуют несколько процедур.

Rectangle (X1, Y1, X2, Y2: integer) - процедура вычерчивания одномерного прямоугольника,

где X1, Y1 - координаты левого верхнего угла, X2, Y2 - координаты правого нижнего угла прямоугольника.

Более удобные для восприятия закрашенные прямоугольники можно строить с использованием процедуры:

Bar(x1, y1, x2, y2: integer) - процедура рисует закрашенный столбец.

Цвет закраски устанавливается с помощью SetFillStyle.

Процедура Bar3D(x1, y1, x2, y2: integer; Depth: word; Top: boolean)

вычерчивает трехмерный закрашенный прямоугольник.

При этом используются тип и цвет закраски, установленные с помощью процедуры SetFillStyle. Параметр Depth представляет собой число пикселов, задающих глубину трехмерного контура.

Чаще всего его значение принимают равным четверти ширины прямоугольника:

Depth:=(X2 - X1) DIV 4.

Параметр Top определяет нужно ли строить над прямоугольником вершину (Top:=True) или нет (Top:=False).

Процедура вычерчивания окружности текущим цветом имеет следующий вид:

Circle(X,Y,Radius: word),

где X, Y - координаты центра окружности, а Radius - радиус.

Что бы создать закрашенный эллипс, используется процедура

FillEllipse(X,Y:integer;xR,yR:word),

где X, Y - центр эллипса, xR и yR - горизонтальная и вертикальная оси. Заполнитель устанавливается процедурой SetFillStyle.

В следующем примере приведена программа, рисующая на желтом фоне синего снеговика.

Program SnowMan;

Uses Graph, Crt;

Var DriverVar, ModeVar :integer;

c :char;

Begin

DriverVar:=Detect;

InitGraph(DriverVar, Modevar, ‘ ’);

SetBkColor(14); SetColor(1);

Circle(300,300,50);

Circle(300,215,35);

Circle(300,160,20);

Circle(300,180,5); Circle(290,140,5); Circle(310,140,5);

Line(335,215,370,200); Line(265,215,230,200);

c:=readkey;

SetBkColor(0); SetColor(GetMaxColor);

CloseGraph;

End.

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

В основе перемещения какого-либо объекта на экране лежит следующий алгоритм:

вывести объект на экран;

стереть объект с экрана;

вывести с некоторым смещением другой вариант объекта и т. д.

При частом выводе объекта с небольшими смещениями создается иллюзия движения.

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

- определенным цветом выводится рисунок;

- рисунок формируется на том же месте цветом, совпадающим с цветом фона. Это вызывает исчезновение рисунка;

- рисунок выводится на другом месте своим первоначальным цветом и т. д.

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

Program Ball;

Uses Graph, Crt;

Label 10,100;

Const bxi=300; byi=200; bri=10; bci=4;

Var DriverVar, ModeVar :integer;

xm,ym :integer;

bx,by,br,bc :integer;

dx :integer;

Begin

DriverVar:=Detect;

InitGraph(DriverVar, Modevar, ‘ ’);

xm:=GetMaxX; ym:=GetMaxY;

bx:=bxi; by:=byi; br:=bri; bc:=bci;

dx:=+1;

SetColor(bc);

Circle(bx,by,br);

10: SetColor(GetBKColor); Circle(bx,by,br);

bx:=bx+dx; by:=by;

if bx>=xm-br then dx:=-1;

if bx<=0+br then dx:=+1;

SetColor(bc); Circle(bx,by,br);

if KeyPressed then goto 100;

goto 10;

100:SetColor(GetMaxColor);

CloseGraph;

End.

Процедуры для рисования фигур.

PutPixel(X, Y:Integer; Pixel:Word);

Рисует на экране точку с координатами (X, Y) цветом Pixel.

Line(X1, Y1, X2, Y2:Integer);

Рисует на экране отрезок прямой от точки (X1, Y1) до точки (X2, Y2).

Rectangle(X1, Y1, X2, Y2:Integer);

Рисует на экране прямоугольник с верхним левым углом в точке (X1, Y1) и нижним правым углом в точке (X2, Y2).

Bar(X1, Y1, X2, Y2:Integer);

Рисует на экране залитый прямоугольник с верхним левым углом в точке (X1, Y1) и нижним правым углом в точке (X2, Y2). Стиль и цвет заливки задаются процедурой SetFillStyle.

Bar3D(X1, Y1, X2, Y2:Integer; Depth:Word; Top:Boolean);

Рисует на экране параллелепипед с залитой передней гранью. Глубина фигуры - Depth. Если Top равно TopOn , то параллелепипед рисуется с верхней гранью, если TopOff, то без верхней грани. Стиль и цвет заливки передней грани задаются процедурой SetFillStyle.

Circle(X, Y:Integer; Radius:Word);

Рисует на экране окружность с центром в точке (X, Y) радиусом Radius.

Ellipse(X, Y:Integer; StAngle, EndAngle:Word; XRadius, YRadius:Word);

Рисует на экране эллиптическую дугу с центром в точке (X, Y), радиусами XRadius, YRadius. StAngle, EndAngle - начальный и конечный углы.

Arc(X, Y:Integer; StAngle, EndAngle:Word; Radius:Word);

Рисует на экране дугу окружности с центром в точке (X,Y), радиусом Radius. StAngle, EndAngle - начальный и конечный углы.

FillEllipse(X, Y:Integer; XRadius,YRadius:Word);

Рисует на экране залитый эллипс с центром в точке (X, Y), радиусами XRadius, YRadius. Стиль и цвет заливки задаются процедурой SetFillStyle.

Sector(X, Y:Integer; StAngle, EndAngle:Word; XRadius, YRadius:Word);

Рисует на экране закрашенный сектор эллипса с центром в точке (X, Y), радиусами XRadius, YRadius. StAngle, EndAngle - начальный и конечный углы. Стиль и цвет заливки задаются процедурой SetFillStyle.

PieSlice(X, Y:Integer; StAngle, EndAngle:Word; Radius:Word);

Рисует на экране закрашенный сектор круга с центром в точке (X, Y), радиусом Radius. StAngle, EndAngle - начальный и конечный углы. Стиль и цвет заливки задаются процедурой SetFillStyle.

Другие процедуры.

ClearDevice;

Очищает экран в графическом режиме.

CloseGraph;

Закрывает графический режим.

SetColor(Color:Word);

Устанавливает новый цвет для рисования.

SetLineStyle(LineStyle:Word; Pattern:Word; Thickness:Word);

Устанавливает стиль и толщину линий. Если Thickness равно ThickWidth, то линии будут толстыми, если NormWidth, то обычными.

SetFillStyle(Pattern:Word; Color:Word);

Устанавливает стиль и цвет заливки. Если Pattern равно UserFill, то используется определенный пользователем стиль, описанный процедурой SetFillPattern.

SetFillPattern(Pattern:FillPatternType; Color:Word);

Устанавливает определяемый пользователем стиль и цвет заливки. FillPatternType=Array [1..8] of Byte;

FloodFill(X, Y:Integer; Border:Word);

Заливает область вокруг точки (X, Y) до линии цвета Border, используя текущий стиль и цвет заливки.

SetTextStyle(Font, Direction:Word; CharSize:Word);

Устанавливает используемый шрифт, его направление и размер. Направление соответствует значению переменной Direction и может быть горизонтальным (Direction=0) или вертикальным (Direction=1). Шрифт может быть как одним из стандартных, так и определенный пользователем (с помощью функции InstallUserFont).

SetUserCharSize(MultX, DivX, MultY, DivY:Word);

Устанавливает ширину букв используемого шрифта в MultX/DivX раз больше, а высоту в MultY/DivY раз больше.

OutTextXY(X, Y:Integer; TextString:String);

Выводит текст TextString на экран от точки (X, Y).

14

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

Длина сегмента определяется архитектурой процессора 8086 и составляет 64 Килобайта (65536 байт), что может вызвать определённые трудности при описании и обработке больших массивов данных.

С другой стороны объём стандартной памяти - 640 Килобайт. Выход - использовать динамическую память.
  Динамическая память - это оперативная память ЭВМ, предоставляемая Турбо-Паскалевой программе при её работе, за вычетом сегмента данных (64 К), стека (обычно 16 К) и собственно тела программы.
  По умолчанию размер динамической памяти определяется всей доступной памятью ЭВМ и, как правило, составляет не менее 200 - 300 Кбайт.
 

Динамическую память обычно используют при:

обработке больших массивов данных;

разработке САПР;

временном запоминании данных при работе с графическими и звуковыми средствами ЭВМ.

Размещение статических переменных в памяти осуществляется компилятором в процессе компиляции.
 

Динамические переменные - размещаются в памяти непосредственно в процессе работы программы.

При динамическом размещении заранее неизвестны ни тип, ни количество размещаемых данных, к ним нельзя обращаться по именам, как к статическим переменным.

Турбо-Паскаль представляет средство управления динамической памятью: указатели.
  Указатель - это переменная, которая в хранит качестве своего значения адрес байта памяти.

В 8086 адреса задаются совокупностью двух шестнадцатиразрядных слов - сегмента и смещения.

Сегмент - участок памяти, имеющий максимальную длину 64 К и начинающийся к физического адреса, кратного 16 (то есть 0, 16, 32, 48 и т.д.).

Смещение - указывает, сколько байт от начала сегмента нужно пропустить, чтобы обратиться по нужному адресу.

Фрагмент памяти в 16 байт называется параграфом.

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

Таким образом любой указатель по своей внутренней структуре представляет собой совокупность двух слов (типа Word), трактуемых как сегмент и смещение. Указатель адресует лишь первый байт типа данных.

Справка: процессор 8086.
8086 имеет 16 - битовые регистры, всего 14 штук, из них:

12 - регистры данных и адресов;

1 - указатель команд (регистр адреса команды);

1 - регистр состояния (регистр флагов).

Регистры данных и адресов делятся на три группы:

регистр данных;

регистр указателей и индексов;

регистр сегментов.

Процессор 8086 всегда генерирует 20-ти бытовые адреса за счёт добавления 16-ти битового смещения к содержимому регистра, умноженному на 16:
физический адрес = смещение + 16 * регистр сегмента.

Вместо умножения на 16 содержимое регистра сегмента используется так, как если бы оно имело четыре дополнительных нулевых бита:

пусть:

смещение = 10H

регистр сегмента = 2000H

тогда:

0000 0000 0001 0000 (смещение)

0010 0000 0000 0000 (0000) (номер блока)

0010 0000 0000 0001 0000 (физический адрес)

физический адрес = 20010H

У 8086 адрес ячейки задаётся номером блока и смещением, что обусловлено тем, что команды 8086 и её данные должны располагаться в разных частях памяти (в разных сегментах).

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

В дополнение к области памяти 1 Мбайт, 8086 может адресоваться к внешним устройствам через 65536 (64 К) портов ввода-вывода. Имеются специальные команды ввода-вывода, позволяющие иметь непосредственный доступ к первым 256 (от 0 до 255) портам. Другие команды позволяют получить косвенный доступ к порту с помощью занесения идентифицирующего его номера (0 - 65535) в определенный регистр данных. Подобно ячейке памяти любой порт может быть 8 или 16- битовым.

16 - старших байт - команды начальной загрузки системы.

Первые 1024 ячейки - вектора прерываний.

(Операционная система MS - DOS все адресуемое пространство делит на сегменты.

Сегмент - это участок памяти размером 64 К байт.

Для задания адреса необходимо определить адрес начала сегмента и смещение относительно начала сегмента.)

В TURBO PASCAL определен адресный тип Pointer - указатель.

Переменные типа Pointer

var p: Pointer;

содержат адрес какого - либо элемента программы и занимают 4 байта, при этом адрес хранится как два слова, одно из них определяет сегмент, второе - смещение.

Переменную типа указатель можно описать другим способом.

type NameType= ^T;

var p: NameType;

Здесь p - переменная типа указатель, связанная с типом Т с помощью имени типа NameType.

Описать переменную типа указатель можно непосредственно в разделе описания переменных:

var p: ^T;

Необходимо различать переменную типа указатель и переменную, на которую этот указатель ссылается.

Например если p - ссылка на переменную типа Т, то p^ - обозначение этой самой переменной.

Для переменных типа указатель введено стандартное значение NIL, которое означает, что указатель не ссылается ни к какому объекту. Константа NIL используется для любых указателей.

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

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

Переменные типа указатель не могут быть элементами списка ввода - вывода.

Статической переменной (статически размещенной) называется описанная явным образом в программе переменная, обращение к ней осуществляется по имени.

Место в памяти для размещения статических переменных определяется при компиляции программы.

В отличие от таких статических переменных в программах, написанных на языке ПАСКАЛЬ, могут быть созданы динамические переменные.

Основное свойство динамических переменных заключается в том, что они создаются и память для них выделяется во время выполнения программы.

Размещаются динамические переменные в динамической области памяти (heap - области).

Динамическая переменная не указывается явно в описаниях переменных и к ней нельзя обратиться по имени.

Доступ к таким переменным осуществляется с помощью указателей и ссылок.

См. разд мат-л 1.

// Работа с динамической областью памяти в TURBO PASCAL реализуется с помощью процедур и функций New, Dispose, GetMem, FreeMem, Mark, Release, MaxAvail, MemAvail, SizeOf.

Процедура New( var p: Pointer ) выделяет место в динамической области памяти для размещения динамической переменной p^ и ее адрес присваивает указателю p.

Процедура Dispose( var p: Pointer ) освобождает участок памяти, выделенный для размещения динамической переменной процедурой New, и значение указателя p становится неопределенным.

Проуедура GetMem( var p: Pointer; size: Word ) выделяет участок памяти в heap - области, присваивает адрес его начала указателю p, размер участка в байтах задается параметром size.

Процедура FreeMem( var p: Pointer; size: Word ) освобождает участок памяти, адрес начала которого определен указателем p, а размер - параметром size. Значение указателя p становится неопределенным.

Процедура Mark( var p: Pointer ) записывает в указатель p адрес начала участка свободной динамической памяти на момент ее вызова.

Процедура Release( var p: Pointer ) освобождает участок динамической памяти, начиная с адреса, записанного в указатель p процедурой Mark, то-есть, очищает ту динамическую память, которая была занята после вызова процедуры Mark.

Функция MaxAvail: Longint возвращает длину в байтах самого длинного свободного участка динамической памяти.

Функция MemAvail: Longint полный объем свободной динамической памяти в байтах.

Вспомогательная функция SizeOf( X ): Word возвращает объем в байтах, занимаемый X, причем X может быть либо именем переменной любого типа, либо именем типа.

//

Рассмотрим некоторые примеры работы с указателями.

var

p1, p2: ^Integer;

Здесь p1 и p2 - указатели или пременные ссылочного типа.

p1:=NIL; p2:=NIL;

После выполнения этих операторов присваивания указатели p1 и p2 не будут ссылаться ни на какой конкретный объект.

New(p1); New(p2);

Процедура New(p1) выполняет следующие действия:

в памяти ЭВМ выделяется участок для размещения величины целого типа;

адрес этого участка присваивается переменной p1:

Аналогично, процедура New(p2) обеспечит выделение участка памяти, адрес которого будет записан в p2:

После выполнения операторов присваивания

p1^:=2; p2^:=4;

в выделенные участки памяти будут записаны значения 2 и 4 соответственно:

В результате выполнения оператора присваивания

p1^:=p2^;

в участок памяти, на который ссылается указатель p1, будет записано значение 4:

После выполнения оператора присваивания

p2:=p1;

оба указателя будут содержать адрес первого участка памяти:

Переменные p1^, p2^ являются динамическими, так как память для них выделяется в процессе выполнения программы с помощью процедуры New.

Динамические переменные могут входить в состав выражений, например:

p1^:=p1^+8; Write('p1^=',p1^:3);

Пример. В результате выполнения программы:

Program DemoPointer;

var p1,p2,p3:^Integer;

begin

p1:=NIL; p2:=NIL; p3:=NIL;

New(p1); New(p2); New(p3);

p1^:=2; p2^:=4;

p3^:=p1^+Sqr(p2^);

writeln('p1^=',p1^:3,' p2^=',p2^:3,' p3^=',p3^:3);

p1:=p2;

writeln('p1^=',p1^:3,' p2^=',p2^:3)

end.

на экран дисплея будут выведены результаты:

p1^= 2 p2^= 4 p3^= 18

p1^= 4 p2^= 4

Вся динамическая память – пространство ячеек, называемое кучей.

Физически куча располагается в старших адресах, сразу за программой.

Указатель на начало кучи храниться в предопределенной переменной HeapOrg, конец - FreePtr, текущую границу незанятой динамической памяти указывает указатель HeapPtr.
Для выделения памяти под любую переменную используется процедура New. Единственным параметром является типизированный указатель:

(на доске)

//

Var

I,J: ^Integer;

R: ^Real;

Begin

New(I); {под I выделяется область памяти,}

{адрес первого байта этой области помещается в I}

End.

//

  После выполнения этого фрагмента указатель I приобретёт значение, которое перед этим имел указатель кучи HeapPtr, а HeapPtr увеличится на два (т.к. он типа Integer); New(R) - вызовет смещение указателя на 6 байт.

После того как указатель приобрёл некоторое значение, то есть стал указывать на конкретный байт памяти, по этому адресу можно разместить значения соответствующего типа:
(на доске)

I^:= 2;
R^:= 2*Pi;

Допустима запись: R^:= Sqr (R^) + I^ - 17;
Но недопустима запись: R:= Sqr (R^) + I^ - 17; так как указателю R нельзя присвоить значение вещественного выражения.

Возврат динамической памяти обратно в кучу осуществляется оператором Dispose:
Dispose(R);
Dispose(I); - вернут в кучу, ранее забранные 8 байт.
Dispose(Ptr) не изменяет значения указателя Ptr, а лишь возвращает в кучу память, связанную с этим указателем. Однако повторное применение процедуры к “свободному” указателю приведет к возникновению ошибки времени исполнения.

Чтобы указать, что указатель свободен, нужно использовать зарезервированное слово Nil.
  К указателям можно применять операции отношения, в том числе и сравнения с Nil:

(на доске)

//

Const

P:^Real = Nil;

. . . . . . . .

Begin

If P = Nil then

New (P);

. . . . . . . .

Dispose(P);

P:= Nil;

End.

//

  Использование указателей, которым не присвоено значение процедурой New или каким-либо другим способом, никак не контролируется системой и может привести к непредсказуемым результатам.

Многократное чередование New и Dispose приводит к “ячеистой” структуре кучи. Дело в том, что все операции с кучей выполняется под управлением особой программы, которая ведёт учёт всех свободных фрагментов в куче.

При выполнении оператора New( ) эта программа отыскивает минимальный свободный фрагмент, в котором может разместиться требуемая переменная.

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

Можно освободить целый фрагмент кучи следующим образом:

(на доске)

//

Перед началом выделения динамической памяти значения указателя HeapPtr запоминается в переменной-указателе с помощью процедуры Mark.

Выполнение программы.

Освобождение фрагмента кучи от заполненного адреса до конца динамической памяти с использованием процедуры Release.

Var

P, P1, P2, P3, P4, P5: ^Integer;

Begin

New(P1);

New(P2);