МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РОССИЙСКОЙ ФЕДЕРАЦИИПЕНЗЕНСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ

МНОГОПРОФИЛЬНЫЙ КОЛЛЕДЖ

КОНСПЕКТ ЛЕКЦИЙ

междисциплинарного курса

МДК 01.02 ПРИКЛАДНОЕ ПРОГРАММИРОВАНИЕ

профессионального модуля

ПМ.01 Разработка программных модулей программного обеспечения

для компьютерных систем

Специальность 09.02.03 Программирование в компьютерных системах

Квалификация выпускника – Техник-программист

Форма обучения – Очная

2015 г.

Содержание1. Прикладное программирование1.1 Введение в прикладное программирование1.2 Технология визуального программирования1.3 Средства отладки программ1.4.Документирование программного обеспечения.2. Решение типовых задач прикладного программирования 2.1 Стандартные компоненты среды Delphi и их применение при разработке прикладных приложений 2.2 Структурное и модульное программирование в Delphi2.3. Объектно-ориентированный подход к проектированию прикладных программ2.4 Отладка и тестирование программного продукта на уровне модулей3. Графические инструменты в прикладном программировании 3.1 Графическая подсистема Delphi. Графические возможности Delphi3.2 Анимация и мультимедиа в прикладном программировании4.Список использованных источников

1. Прикладное программирование1.1 Введение в прикладное программирование

В настоящее время весь комплекс программного обеспечения делится на

системные и пользовательские программы. Системное программное

обеспечение выполняет функции «организатора» всех частей ПК, а также

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

служат для выполнения каких – либо конкретных задач во всех сферах

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

обеспечению относятся компьютерные программы, написанные для

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

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

рассылки — пример прикладного программного обеспечения.

Программистов, которые пишут прикладное программное обеспечение,

называют прикладными программистами.

Вся совокупность программ входит в так называемое программное

обеспечение компьютера. Состав программного обеспечения ПК является

важнейшей его функциональной характеристикой. Программное обеспечение

(ПО) — это совокупность программ регулярного применения, необходимых

для решения задач пользователя, и программ, позволяющих наиболее

эффективно использовать вычислительную технику, обеспечивая

пользователям наибольшие удобства в работе и минимум затрат труда на

программирование задач и обработку информации. Следовательно, тема

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

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

самым многочисленным классом программных продуктов. В данный класс

входят программные продукты, выполняющие обработку информации

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

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

непосредственную их эксплуатацию осуществляют, как правило, конечные

пользователи - потребители информации, во многих случаях деятельность

которых весьма далека от компьютерной области. Данный класс

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

предметных областей. Прикладные программы предназначены для того,

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

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

разработчики прикладных программ большие усилия тратят на

совершенствование и модернизацию популярных систем, создание их новых

версий. Для работы с текстами на компьютере используются программные

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

процессорами. Существует большое количество разнообразных текстовых

редакторов, различающихся по своим возможностям, — от очень простых

учебных до мощных, многофункциональных программных средств,

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

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

пользователей IBM-совместимых компьютеров текстовые редакторы Lexicon

и Word for Windows.

Основное назначение текстовых редакторов — создавать текстовые

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

текстового документа, распечатывать его на принтере. Набираемый на

клавиатуре компьютера текст воспроизводится на экране дисплея в рабочем

поле редактора. Специальный значок — курсор указывает то место на экране,

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

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

текстовым редактором, можно получить на экране информацию о текущем

состоянии курсора, т. е. его координатах на экране (номер строки и позиции в

строке), а также о номере страницы текста, его формате, используемом

шрифте и т. д.

Интерфейс практически каждого текстового редактора позволяет иметь

на экране меню команд управления редактором — изменение режимов

работы, обращение за помощью, форматирование текста, печати и т. д. Как

правило, меню имеет не только текстовую форму, но и форму пиктограмм,

указывающих на выполняемую команду. Большинство редакторов текста

имеют также режим орфографического контроля текста. В этом случае в

памяти компьютера хранится достаточно большой словарь. Благодаря этому

становится возможным автоматический поиск орфографических ошибок в

тексте и последующее их исправление.

Табличными процессорами называют пакеты программ,

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

данными. Среди таких пакетов наибольшее распространение получили Lotus

1-2-3, SuperCalc и Microsoft Exсel.

Систе́ма управле́ния ба́зами да́нных (СУБД) — специализированная

программа (чаще комплекс программ), предназначенная для организации и

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

СУБД необходима в той же степени, как для разработки программы на

алгоритмическом языке необходим транслятор. Основные функции СУБД:

1.         управление данными во внешней памяти (на дисках);

2.         управление данными в оперативной памяти с использованием

дискового кэша;

3.         журнализация изменений, резервное копирование и

восстановление базы данных после сбоев;

4.         поддержка языков БД (язык определения данных, язык

манипулирования данными).

Обычно современная СУБД содержит следующие компоненты:

Ø   ядро, которое отвечает за управление данными во внешней и

оперативной памяти и журнализацию;

Ø   процессор языка базы данных, обеспечивающий оптимизацию

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

машинно-независимого исполняемого внутреннего кода;

Ø   подсистему поддержки времени исполнения, которая интерпретирует

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

с СУБД;

Ø   а также сервисные программы (внешние утилиты), обеспечивающие

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

системы.

Графический редактор— это программа, предназначенная для создания,

редактирования и просмотра графических изображений.

Графические редакторы делятся на две группы — растровые и

векторные.

Интегрированные пакеты, как правило, содержат некоторое ядро,

обеспечивающее возможность тесного взаимодействия между

составляющими.

Наиболее известные интегрированные пакеты:

Microsoft Office. В этот мощный профессиональный пакет вошли такие

необходимые программы, как текстовый редактор WinWord , электронная

таблица Excel, программа создания презентаций PowerPoint, СУБД Access,

средство поддержки электронной почты Mail. Мало того, все части этого

пакета составляют единое целое, и даже внешне все программы выглядят

единообразно, что облегчает как их освоение, так и ежедневное

использование.

Microsoft Works — это очень простой и удобный пакет, объединяющий в

себе текстовый редактор, электронные таблицы и базы данных, а также

телекоммуникационные средства для соединения с другими компьютерами

по телефонным линиям. Пакет ориентирован на людей, не имеющих времени

осваивать сложные продукты, на начинающих пользователей, а также на

домашних пользователей.

2 Технология визуального программирования

Визуальное программирование является одной из наиболее

популярных парадигм программирования. Визуальное программирование

состоит в автоматизированной разработке программ с использованием

особой диалоговой оболочки. Рассматривая системы визуального

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

ориентированном программировании и являются его логическим

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

для создания интерфейса программ и систем управления базами данных. С

объектно-ориентированными системами ассоциируется

программа Browser (рис.1). Это средство вместе с системой экранных

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

части программного окружения и видеть весь проект уже созданной

программы. Под проектом программы здесь понимается структура

программы — состав файлов, объектов и их порождающих классов, которые

слагают программу в целом.

Рисунок 1

Одну из ключевых возможностей программы Browser предоставляет

окно, в котором находится список всех классов системы. При выборе одного

из классов в специальных окнах отображаются его локальные функции и

переменные. Затем при выборе одного из методов на отдельной панели

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

добавления и удаления классов из проекта. Программа Browser — это не

просто визуализатор. Это основной, интегрирующий инструмент, который

помогает одновременно рассматривать существующую систему и

разрабатывать документацию программного проекта.

Структурной единицей визуального программирования в Delphi

является компонента. Компонента представляет собой разновидность

объекта, который можно перенести (агрегировать) в приложение из

специальной Палитры компонент (рис. 2). Компонента имеет набор свойств,

которые можно изменять, не изменяя исходный код программы. Компоненты

бывают визуальными и невизуальными. Первые предназначены для

организации интерфейса с пользователем. Это различные кнопки, списки,

статический и редактируемый текст, изображения и многое другое. Эти

компоненты отображаются при выполнении разрабатываемого приложения.

Невизуальные компоненты отвечают за доступ к системным ресурсам:

драйверам баз данных, таймерам и т. д. Во время разработки они

отображаются своей пиктограммой, но при выполнении приложения, как

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

компоненте, либо форме. Формой называется визуальная компонента,

обладающая свойством окна Windows (рис. 3). При разработке на форме

помещаются необходимые компоненты (например, элементы требуемого

диалога). Форм в приложении может быть несколько — по требуемому числу

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

Рисунок 2

Рисунок 3В Delphi разработчик из меню палитры компонент выбирает

необходимую компоненту, например кнопку, и буксирует ее при помощи

мыши в нужное место окна разрабатываемой формы. При этом кнопке

автоматически присваивается название (имя или идентификатор), и она

описывается в модуле формы (рис. 4).

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

активной. Затем, перемещая при помощи мыши границы кнопки и работая в

окне Inspector, можно задать надпись (например, ОК) и/или графическую

пиктограмму на кнопке, задать цвета и другие настроечные параметры

кнопки. Двойной щелчок по кнопке — и в исходном тексте формы появится

шаблон подпрограммы (метода) нужного типа реакции на щелчок (рис. 5).

Работая в окне редактора текста, можно оформить тело подпрограммы

реакции кнопки на щелчок.

Рисунок 4

Рисунок 5

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

(подпрограммы обработки событий, названных Events), например, на

нажатие Enter, а также задавать начальные значения полям данных,

названных Properties (рис. 6).

Рисунок 6

Начальные шаги технологии визуального программирования

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

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

инспекторе объектов производится настройка их свойств путем заполнения

отдельных полей. На главную форму помимо визуальных компонент

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

проект. Далее в соответствии со сценарием диалога программируются

методы события основной и подчиненных форм. Программы "пустых"

методов событий появляются в окне редактора после нажатия

соответствующих клавиш или действий мыши. "Пустые" методы

дополняются определенными операторами активации и дезактивации форм.

По окончании начальных шагов получается работающий "скелет" программы

с источниками данных из файловых баз данных и со сгенерированными

формами документов, выводимых на печать. Исследователь (Browser)

обеспечивает визуализацию схемы иерархии классов полученного "скелета"

программы. Другими словами, технический проект реализованной части

программы формируется автоматически. Дальнейшая разработка программы

ведется по технологии объектно-ориентированного программирования.

Можно часть программы реализовать по технологии структурного

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

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

прототипов имеющихся компонент. Рекомендуется новые компоненты

помещать в палитру компонент. Это облегчит их повторное использование в

данной или последующих разработках. Код, относящийся только к данной

разработке, набирается по тексту программы.

Визуальное программирование во многом автоматизирует труд

программиста по написанию программ. Визуальное программирование —

одна из самых популярных парадигм программирования на данный момент.

Оно базируется на технологии ООП. Среда визуального программирования

поддерживает работу браузеров (Browser), при помощи которых можно

автоматически получить документацию по структуре программы. Основным

элементом в средствах визуального программирования является компонент.

Компоненты бывают визуальными и невизуальными. Технология

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

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

событий и методов оконных форм.

1.3 Средства отладки программ

Разработку программы можно разбить на следующие этапы:

Составление алгоритма решения задачи. Алгоритм — это описание

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

поставленной задачи.

Написание текста программы. Текст программы пишут на каком-либо языке

программирования (например на Free Pascal) и вводят его в компьютер с

помощью текстового редактора.

Отладка программы. Отладка программы — это процесс устранения ошибок

из текста программы. Все ошибки делятся на синтаксические и логические.

При наличии синтаксических ошибок (ошибок в написании операторов)

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

Логические ошибки — это ошибки, при которых программа работает, но

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

ожидает разработчик или пользователь. Логические ошибки исправить

сложнее, чем синтаксические, иногда для этого придётся переписывать

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

Тестирование программы. Тестирование программы — процесс выявления

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

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

Процесс запуска программы может быть осуществлён только после того, как

введённая в компьютер программа на алгоритмическом языке Pascal1будет

переведена в двоичный машинный код и создан исполняемый файл. Процесс

перевода текста программы в машинный код называют трансляцией. Все

трансляторы делятся на два класса: интерпретаторы — трансляторы, которые

переводят каждый оператор программы в машинный код, и по мере перевода

операторы выполняются процессором; компиляторы переводят всю

программу целиком, и если перевод всей программы прошёл без ошибок, то

полученный двоичный код можно запускать на выполнение. Если в качестве

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

машинный код называют компиляцией. При переводе программы с языка

Pascal в машинный код используются именно компиляторы. Рассмотрим

основные этапы обработки компилятором программы на языке Delphi.

Компилятор анализирует, какие внешние библиотеки3 нужно

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

проверяет синтаксические ошибки и в случае их отсутствия формирует

объектный код (в Windows — файл с расширением .obj, в Linux — файл с

расширением.o). Получаемый на этом этапе двоичный файл (объектный код)

не включает в себя объектные коды подключаемых библиотек.

На втором этапе компоновщик подключает к объектному коду

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

программы. Этот этап называется компоновкой или сборкой программы.

Полученный на этом этапе исполняемый код программы можно запускать на

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

языка Pascal, среди которых можно выделить Borland Pascal, Delphi, а также

свободно распространяемый кроссплатформенный компилятор языка Free

Pascal и среду визуального программирования Lazarus.

Интегрированная среда разработки Delphi предоставляет

программисту мощное средство поиска и устранения ошибок в программе -

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

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

данные. 

Трассировка программы. Во время работы программы ее инструкции

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

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

в данный момент, и, следовательно, определить, соответствует ли реальный

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

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

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

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

по шагам (step-by-step), инструкция за инструкцией. Во время трассировки

программист дает команду: выполнить очередную инструкцию программы.

Delphi обеспечивает два режима трассировки: без захода в процедуру

(Step over) и с заходом в процедуру (Trace into). Режим трассировки без

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

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

выполняется за один шаг. В режиме трассировки с заходом в процедуру

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

только главная программа, но и все подпрограммы. Для того чтобы начать

трассировку, необходимо из меню Run выбрать команду Step over или Trace

into. В результате в окне редактора кода будет выделена первая инструкция

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

необходимо из меню Run выбрать команду Step over (нажать

клавишу <F8>) или Trace into (нажать клавишу <F7>). После выполнения

инструкции будет выделена следующая. Таким образом, выбирая нужную

команду из меню Run, можно выполнить трассировку

программы. Активизировать и выполнить трассировку можно при помощи

функциональной клавиатуры. Команде Step overсоответствует клавиша <F8>,

а команде Trace into — клавиша <F7>. В любой момент времени можно

завершить трассировку и продолжить выполнение программы в реальном

темпе. Для этого надо из меню Run выбрать команду Run.  При

необходимости выполнить трассировку части программы следует установить

курсор на инструкцию программы, с которой надо начать трассировку, и из

меню Run выбрать команду Run to cursor или нажать клавишу <F4>. Затем,

нажимая клавишу <F7>или клавишу <F8>, выполнить трассировку нужного

фрагмента программы.

Во время трассировки можно наблюдать не только порядок

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

Тестирование является органической частью процесса отладки программ,

которая включает: собственно тестирование, диагностику и локализацию

ошибок, а также корректировку отлаживаемых программ и контроль

правильности устранения обнаруженных ошибок. В соответствии с этими

стадиями процесса отладки изменяются цели и задачи тестирования. Целями

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

ошибок в программе; тестирование для диагностики и локализации причин

обнаруженных искажений результатов; тестирование правильности

выполненных корректировок и устранения обнаруженных ошибок в

программе. Различие целей влияет на выбор наиболее эффективных методов

тестирования для их реализации. Наиболее широкий спектр методов

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

тестирования является выявление отклонений результатов

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

При этом задача состоит в обнаружении максимального числа ошибок, в

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

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

существования ошибок. Если в результате тестирования ошибка не выявлена,

то проведенные операции не дали сведений, позволяющих повысить качество

программ, и тем самым не оправдали затрат. В этом случае эффективными

являются операции тестирования, обладающие высокой способностью по

обнаружению ошибок в программе. С этих позиций тесты, не

способствующие обнаружению ошибок и только подтверждающие

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

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

Цель тестирования для диагностики и локализации ошибок — точно

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

причиной отклонения результатов от эталонных, выявленного при

тестировании для обнаружения ошибок. Эффективными являются тесты,

способствующие быстрой и точной локализации первичных ошибок. На этой

стадии затраты оправданы, и тестирование можно считать успешным, если

оно привело к определению элементов программы, подлежащих

корректировке.

После локализации и устранения обнаруженных ошибок применяется

контрольное тестирование, цель которого состоит в подтверждении

правильности выполненной корректировки программы и в отсутствии

проявления ранее обнаруженной ошибки. Успешность тестирования

определяется отсутствием устранявшейся ошибки, а также отсутствием

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

корректировки.

В соответствии с этими целями процесс тестирования проходит этапы:

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

основной цели его выполнения; планирование тестирования в соответствии с

выбранным методом с учетом ограниченных ресурсов отладки, имеющихся

для достижения заданного качества программы; разработка или

моделирование наборов конкретных тестовых значений и соответствующих

им эталонов; составление отладочных заданий с указанием контролируемых

параметров, исходных данных и эталонов; реализация процесса тестирования

и получение результатов функционирования объекта отладки при

подготовленных тестах и отладочных заданиях; сравнение результатов

тестирования с эталонами и обнаружение отклонений для принятия решений

о проведении дополнительного тестирования с целью диагностики и

локализации ошибок, а также для контроля правильности корректировки

программ; оценка полноты проведенного тестирования выбранным методом

и необходимости применения другого метода тестирования; оценка наличия

ресурсов для продолжения отладки и момента ее завершения, а также

определение достигнутого качества программ. Представленные этапы

тестирования для обнаружения ошибок и оценки достигнутого качества

программ в процессе отладки дополняются этапами диагностики и

локализации ошибок, а также контроля проведенных корректировок. На этих

этапах выполняются основные работы по совершенствованию программ и

устранению ошибок. Для этого разрабатываются изменения текстов

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

откорректированной программы для продолжения тестирования. Важной

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

локализации ошибок и контроля выполненных корректировок. Черный

ящик - это подход к тестированию, при котором тестировщик не обладает

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

Данная стратегия производится на основании внешних проявлений работы

программного обеспечения или сайта. Другими словами, специалист по

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

пользователя. Под тестированием «черного ящика» обычно подразумевают

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

коду).Тестирование черного ящика также известно как функциональное

тестирование. Преимущества тестирования «черного ящика»: анализ

проводится с точки зрения пользователя, а не дизайнера тестировщику сайта

или ПО не требуются знания каких-либо специальных языков

программирования тестирование является объективным, так как дизайнер

и тестировщик ПО независимы друг от друга тест кейсы могут быть

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

«белого ящика» необходимы знания структуры данных, логики ПО,

алгоритмов работы программы, архитектуры программного кода. Данный

анализ проводится с точки зрения разработчика. Тестирование «белого

ящика» и тестирование «черного ящика» являются неотъемлемой частью

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

они не дают предельно хороших результатов для сбалансированной

работы компании по тестированию. Тестирование «черного ящика» может

быть менее эффективным при поиске ошибок, связанных с потоком данных

на уровне исходного кода. А тестирование «белого ящика» менее

эффективно в нахождении макро-уровневых ошибок в операционной

системе, а также ошибок совместимости. Тестирование «серого ящика» - это

сочетание тестирования «черного» и «белого ящика». Тестирование «серого

ящика» используется для оценки проекта в рамках взаимодействия его

индивидуальных компонентов. Тестирование «серого ящика» наиболее

подходит для тестирования веб-приложений, потому что для него

необходимы высокоуровневая разработка, операционное окружение и

условия совместимости.

Во время проведения анализа черного или белого ящика более сложно

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

Специфические контекстные проблемы тестирования веб сайтов легче всего

найти во время проверки серого ящика. Веб-приложения состоят из

множества элементов, как на программном, так и аппаратном уровне. Эти

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

оценивания их взаимодействия и функциональности. Для тестирования

«серого ящика» используются инструменты, нацеленные на понимание

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

подход может быть использован для проверки «черного ящика» с целью

увеличения продуктивности тестирования и производительности анализа

багов. С другой стороны, проверка «серого ящика» - это использование

неполной или предполагаемой информации о структуре или дизайне для

дальнейшей концентрации или расширения анализа «черного ящика».

Помните, что тестирование программного обеспечения более эффективно с

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

разработки продукта, требований приложения, типов ошибок.

1.4.Документирование программного обеспечения.

Документирование программного обеспечения– важный этап в процессе

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

начинает свое знакомство с программным продуктом с программной

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

программный продукт, как начать с ним работать – это первые вопросы, на

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

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

отечественных и международных стандартов, включающих стандарты на

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

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

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

составляет комплекс стандартов Единой системы программной

документации (ЕСПД). Единая система программной документации-

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

правила разработки, оформления и обращения программ и программной

документации. Стандарты ЕСПД в основном охватывают ту часть

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

средств. Эти стандарты носят рекомендательный характер. В соответствии с

Законом РФ «О техническом регулировании» они становятся обязательными

на контрактной основе, то есть при ссылке на них в договоре на разработку

или поставку программных средств. В состав ЕСПД входят:

§ основополагающие и организационно-методические стандарты;

§ стандарты, определяющие формы и содержание программных документов,

применяемых при обработке данных;

§ стандарты, обеспечивающие автоматизацию разработки программных

документов.

Несмотря на то, что большая часть стандартов ЕСПД морально устарела и

нуждается в полном пересмотре на основе стандарта ИСО/МЭК 12207-99 на

процессы жизненного цикла программных средств, многие стандарты могут

применяться в практике документирования программных средств. Эта

позиция основана на следующем:

§ стандарты ЕСПД вносят элемент упорядочения в процессе

документирования программных средств;

§ предусмотренный стандартами ЕСПД состав программных документов

может быть изменен в конкретных проектах;

§ стандарты ЕСПД позволяют мобильно изменять структуру и содержание

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

заказчика и пользователя.

Перечень документов ЕСПД обширен. Одним из основных стандартов

является ГОСТ 19.101-77 ЕСПД. Виды программ и программных

документов. В Российской Федерации действует ряд стандартов на

документирование программного обеспечения, разработанных на основе

прямого применения международных стандартов ИСО и МЭК.

ГОСТ Р ИСО/МЭК ТО 9294-93 Информационная технология. Руководство

по управлению документированием программного обеспечения. Стандарт

полностью соответствует стандарту ISO/IEC 9294:1990 и устанавливает

рекомендации по эффективному управлению документированием

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

стандарта является оказание помощи в определении стратегии

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

документированию, выборе процедур документирования, определении

необходимых ресурсов, составлении планов документирования. ГОСТ Р

ИСО/МЭК 12119-2000. Информационная технология. Пакеты программ.

Требования к качеству и тестирование. В этом стандарте установлены

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

соответствие заданным требованиям. Стандарт определяет требования к

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

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

документ «Описание продукта» должен помочь пользователю или

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

документация должна содержать всю информацию, необходимую для

применения продукта. В данном стандарте требования к качеству продукта

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

«Описании продукта» и пользовательской документации. Требования к

программам и данным в основном сводятся к утверждению необходимости

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

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

продукту:

§ требования, согласно которым каждый пакет должен содержать описание

продукта и документацию пользователя;

§ требования к описанию продукта; в частности, требование, согласно

которому описание продукта должно содержать конкретную информацию, а

все приводимые в нем формулировки должны быть проверяемыми и

корректными;

§ требования к документации пользователя;

§ требования к любым программам и данным, входящим в состав пакета

программ.

ГОСТ Р ИСО 9127-94. Системы обработки информации. Документация

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

пакетов. Стандарт полностью соответствует международному стандарту

ИСО 9127:1989. В контексте настоящего стандарта подпотребительским

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

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

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

как единое целое». Документация пользователя- документация, которая

обеспечивает конечного пользователя информацией по установке и

эксплуатации программного пакета. Обычно эту документацию

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

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

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

программного пакета. Ее целью является предоставление потенциальным

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

программного средства в соответствии с их потребностями

2. Решение типовых задач прикладного программирования

2.1 Стандартные компоненты среды Delphi и их применение при

разработке прикладных приложений.

Среда программирования Delphi предоставляет возможность разработки

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

приложений, работающих как с использованием графического интерфейса

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

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

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

вводимые пользователем с клавиатуры и выводимые программой. Позицию

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

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

в режиме замены. По умолчанию длина строки равна 80 знакам, а количество

строк. Изменить эти и другие параметры окна программы позволяет

диалоговое окно, открывающееся при вводе команды Свойства в системном

меню.

При вводе пользователь имеет возможность редактировать последние

вводимые данные, используя символьные клавиши, а также клавиши

BackSpace (удаление последнего введенного символа), Delete (удаление

символа справа от курсора), Insert (переключение режимов вставки и

замены), Стрелка вверх (удаление всех введенных символов), Стрелка влево

(перемещение курсора в предыдущую позицию), Стрелка вправо

(перемещение курсора в следующую позицию). Если в диалоговом окне

команды Свойства установить на вкладке Общие флажок Выделение мышью,

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

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

вставлять в позицию курсора щелчком правой кла виши. Завершается ввод

нажатием клавиши Enter, при этом курсор перемещается в начало новой

строки. Максимальная длина вводимой последовательности символов равна

254. Вывод данных из программы выполняется в виде текста, сим вол за

символом при автоматическом перемещении курсора в очередную позицию

строки, а при достижении ее конца . в начало новой строки.

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

минимизировать время счета и расход оперативной памяти. Кроме того,

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

алгоритмов. Так как данный практикум ориентирован на развитие начальных

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

использование консольного режима.

На первой странице Палитры Компонент размещены 14 объектов

определенно важных для использования. Мало кто обойдется длительное

время без кнопок, списков, окон ввода и т.д. Все эти объекты такая же часть

Windows, как мышь или окно. Набор и порядок компонент на каждой

странице являются конфигурируемыми. Так, Вы можете добавить к

имеющимся компонентам новые, изменить их количество и порядок. Это

можно сделать, вызвав всплывающее меню (нажать правую кнопку мыши,

когда указатель над Палитрой).

Стандартные компоненты Delphi перечислены ниже с некоторыми

комментариями по их применению. При изучении данных компонент было

бы полезно иметь под рукой компьютер с тем, чтобы посмотреть, как они

работают и как ими манипулировать.

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

какого-либо объекта. TMainMenu позволяет Вам поместить главное меню в

программу. При помещении TMainMenu на форму это выглядит, как просто

иконка. Иконки данного типа называют "невидимыми компонентом",

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

включает три шага: (1) помещение TMainMenu на форму, (2) вызов

Дизайнера Меню через свойство Items в Инспекторе Объектов, (3)

определение пунктов меню в Дизайнере Меню.

TPopupMenu позволяет создавать всплывающие меню. Этот тип меню

появляется по щелчку правой кнопки мыши на объекте, к которому

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

PopupMenu, где и указывается нужное меню. Создается PopupMenu

аналогично главному меню. TLabel служит для отображения текста на

экране. Вы можете изменить шрифт и цвет метки, если дважды щелкнете на

свойство Font в Инспекторе Объектов. Вы увидите, что это легко сделать и во

время выполнения программы, написав всего одну строчку кода.

TEdit - стандартный управляющий элемент Windows для ввода. Он может

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

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

форма TEdit. Подразумевает работу с большими текстами. TMemo может

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

их, и другие основные функции редактора. TMemo имеет ограничения на

объем текста в 32Кб, это составляет 10-20 страниц. (Есть VBX и "родные"

компоненты Delphi, где этот предел снят).

TButton позволяет выполнить какие-либо действия при нажатии кнопки во

время выполнения программы. В Delphi все делается очень просто. Поместив

TButton на форму, Вы по двойному щелчку можете создать заготовку

обработчика события нажатия кнопки. Далее нужно заполнить заготовку

кодом:

procedure TForm1.Button1Click(Sender: TObject);

begin

MessageDlg('Are you there?',mtConfirmation,mbYesNoCancel,0);

end;

TCheckBox отображает строку текста с маленьким окошком рядом. В окошке

можно поставить отметку, которая означает, что что-то выбрано. Например,

если посмотреть окно диалога настроек компилятора (пункт меню Options |

Project, страница Compiler), то можно увидеть, что оно состоит

преимущественно из CheckBox'ов.

TRadioButton позволяет выбрать только одну опцию из нескольких. Если Вы

опять откроете диалог Options | Project и выберете страницу Linker Options, то

Вы можете видеть, что секции Map file и Link buffer file состоят из наборов

RadioButton.

TListBox нужен для показа прокручиваемого списка. Классический пример

ListBox'а в среде Windows - выбор файла из списка в пункте меню File | Open

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

ListBox'е.

TComboBox во многом напоминает ListBox, за исключением того, что

позволяет водить информацию в маленьком поле ввода сверху ListBox. Есть

несколько типов ComboBox, но наиболее популярен спадающий вниз (drop-

down combo box), который можно видеть внизу окна диалога выбора файла.

TScrollbar - полоса прокрутки, появляется автоматически в объектах

редактирования, ListBox'ах при необходимости прокрутки текста для

просмотра.

TGroupBox используется для визуальных целей и для указания Windows,

каков порядок перемещения по компонентам на форме (при нажатии

клавиши TAB). TRadioGroup используется аналогично TGroupBox, для

группировки объектов TRadioButton.

TPanel - управляющий элемент, похожий на TGroupBox, используется в

декоративных целях. Чтобы использовать TPanel, просто поместите его на

форму и затем положите другие компоненты на него. Теперь при

перемещении TPanel будут передвигаться и эти компоненты. TPanel

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

Это полный список объектов на первой странице Палитры Компонент. Если

Вам нужна дополнительная информация, то выберите на Палитре объект и

нажмите клавишу F1 - появится Справочник с полным описанием данного

объекта.

Страница Additional

На странице Standard представлены управляющие элементы, появившиеся в

Windows 3.0. На странице Additional размещены объекты, позволяющие

создать более красивый пользовательский интерфейс программы.

Список компонент:

TBitBtn - кнопка вроде TButton, однако на ней можно разместить картинку

(glyph). TBitBtn имеет несколько предопределенных типов (bkClose, bkOK и

др), при выборе которых кнопка принимает соответствующий вид. Кроме

того, нажатие кнопки на модальном окне (Form2.ShowModal) приводит к

закрытию окна с соответствующим модальным результатом

(Form2.ModalResult).

TSpeedButton - кнопка для создания панели быстрого доступа к командам

(SpeedBar). Пример - SpeedBar слева от Палитры Компонент в среде Delphi.

Обычно на данную кнопку помещается только картинка (glyph).

TTabSet - горизонтальные закладки. Обычно используется вместе с

TNoteBook для создания многостраничных окон. Название страниц можно

задать в свойстве Tabs. Но проще это сделать в программе при создании

формы (OnCreate) :

TabSet1.Tabs := Notebook1.Pages;

А для того, чтобы при выборе закладки страницы перелистывались нужно в

обработчике события OnClick для TTabSet написать:

Notebook1.PageIndex := TabSet1.TabIndex;

TNoteBook - используется для создания многостраничного диалога, на

каждой странице располагается свой набор объектов. Используется

совместно с TTabSet.

TTabbedNotebook - многостраничный диалог со встроенными закладками, в

данном случае - закладки сверху.

TMaskEdit - аналог TEdit, но с возможностью форматированного ввода.

Формат определяется в свойстве EditMask. В редакторе свойств для EditMask

есть заготовки некоторых форматов: даты, валюты и т.п. Спец. символы для

маски можно посмотреть в Справочнике.

TOutline - используется для представления иерархических отношений

связанных данных. Например - дерево директорий.

TStringGrid - служит для представления текстовых данных в виде таблицы.

Доступ к каждому элементу таблицы происходит через свойство Cell.

TDrawGrid - служит для представления данных любого типа в виде таблицы.

Доступ к каждому элементу таблицы происходит через свойство CellRect.

TImage - отображает графическое изображение на форме. Воспринимает

форматы BMP, ICO, WMF. Если картинку подключить во время дизайна

программы, то она прикомпилируется к EXE файлу.

TShape - служит для отображения простейших графических объектов на

форме: окружность, квадрат и т.п.

TBevel - элемент для рельефного оформления интерфейса.

THeader - элемент оформления для создания заголовков с изменяемыми

размерами для таблиц.

TScrollBox - позволяет создать на форме прокручиваемую область с

размерами большими, нежели экран. На этой области можно разместить свои

объекты.

Страница Dialogs

На странице Dialogs представлены компоненты для вызова стандартных диалогов Windows. Внешний вид диалогов зависит от используемой версии Windows. Объекты, представленные на данной странице невидимы во время выполнения и вызов диалогов происходит программно, например:if OpenDialog1.Execute thenImage1.Picture.LoadFromFile(OpenDialog1.FileName);Диалоги Windows в порядке появления на странице Dialogs:OpenDialog; выбрать файлSaveDialog; сохранить файлFontDialog; настроить шрифтColorDialog; выбор цветаPrintDialog; печать

PrinterSetupDialog; настройка принтераFindDialog; поиск строкиReplaceDialog; поиск с заменойСтраница SystemСтраница представляет набор компонент для доступа к некоторым

системным сервисам типа таймер, DDE, OLE и т.п.

TTimer - таймер, событие OnTimer периодически вызывается через

промежуток времени, указанный в свойстве Interval. Период времени может

составлять от 1 до 65535 мс.

TPaintBox - место для рисования. В обработчики событий, связанных с

мышкой передаются относительные координаты мышки в TPaintBox, а не

абсолютные в форме.

TFileListBox - специализированный ListBox, в котором отображаются файлы

из указанной директории (св-во Directory). На названия файлов можно

наложить маску, для этого служит св-во Mask. Кроме того, в св-ве FileEdit

можно указать объект TEdit для редактирования маски.

TDirectoryListBox - специализированный ListBox, в котором отображается

структура директорий текущего диска. В св-ве FileList можно указать

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

директорию.

TDriveComboBox - специализированный ComboBox для выбора текущего

диска. Имеет свойство DirList, в котором можно указать TDirectoryListBox,

который будет отслеживать переход на другой диск.

TFilterComboBox - специализированный ComboBox для выбора маски имени

файлов. Список масок определяется в свойстве Filter. В свойстве FileList

указывается TFileListBox, на который устанавливается маска.

С помощью последних четырех компонент (TFileListBox, TDirectoryListBox,

TDriveComboBox, TFilterComboBox) можно построить свой собственный

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

строчки кода.

TMediaPlayer - служит для управления мултимедйными устройствами (типа

CD-ROM, MIDI и т.п.). Выполнен в виде панели управления с кнопками Play,

Stop, Record и др. Для воспроизведения может понадобиться как

соответствующее оборудование, так и программное обеспечение.

Подключение устройств и установка ПО производится в среде Windows.

Например, для воспроизведения видео, записанного в формате AVI, в

потребуется установить ПО MicroSoft Video (в Windows 3.0, 3.1, WFW 3.11).

 TOLEContainer - контейнер, содержащий OLE объекты. Поддерживается

OLE 2.02 Подробнее об этом - в последующих уроках.

TDDEClientConv,TDDEClientItem, TDDEServerConv, TDDEServerItem - 4

объекта для организации DDE. С помощью этих объектов можно построить

приложение как DDE-сервер, так и DDE-клиент. Подробнее - в следующих

уроках.

Графические компоненты

В стандартную библиотеку визуальных компонент Delphi входит несколько

объектов, с помощью которых можно придать своей программе совершенно

оригинальный вид. Это - TImage (TDBImage), TShape, TBevel.

TImage позволяет поместить графическое изображение в любое место на

форме. Этот объект очень прост в использовании - выберите его на странице

Additional и поместите в нужное место формы. Собственно картинку можно

загрузить во время дизайна в редакторе свойства Picture (Инспектор

Объектов). Картинка должна храниться в файле в формате BMP (bitmap),

WMF (Windows Meta File) или ICO (icon). (TDBImage отображает картинку,

хранящуюся в таблице в поле типа BLOB. При этом доступен только формат

BMP.) Как известно, форматов хранения изображений гораздо больше трех

вышеназванных (например, наиболее известны PCX, GIF, TIFF, JPEG). Для

включения в программу изображений в этих форматах нужно либо перевести

их в формат BMP, либо найти библиотеки третьих фирм, в которых есть

аналог TImage, "понимающий" данные форматы (есть как VBX объекты, так

и "родные" объекты для Delphi).

При проектировании следует помнить, что изображение, помещенное на

форму во время дизайна, включается в файл .DPR и затем прикомпилируется

к EXE файлу. Поэтому такой EXE файл может получиться достаточно

большой. Как альтернативу можно рассмотреть загрузку картинки во время

выполнения программы, для этого у свойства Picture (которое является

объектом со своим набором свойств и методов) есть специальный метод

LoadFromFile. Это делается, например, так:

if OpenDialog1.Execute then

Image1.Picture.LoadFromFile(OpenDialog1.FileName);

Важными являются свойства объекта Center и Stretch - оба имеют булевский

тип. Если Center установлено в True, то центр изображения будет

совмещаться с центром объекта TImage. Если Stretch установлено в True, то

изображение будет сжиматься или растягиваться таким образом, чтобы

заполнить весь объект TImage.

TShape - простейшие графические объекты на форме типа круг, квадрат и т.п.

Вид объекта указывается в свойстве Shape. Свойство Pen определяет цвет и

вид границы объекта. Brush задает цвет и вид заполнения объекта. Эти

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

программы.

TBevel - объект для украшения программы, может принимать вид рамки или

линии. Объект предоставляет меньше возможностей по сравнению с TPanel,

но не занимает ресурсов. Внешний вид указывается с помощью свойств

Shape и Style.

Свойство объектов Canvas

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

(канва), которое предоставляет простой путь для рисования на них. Эти

объекты - TBitmap, TComboBox, TDBComboBox, TDBGrid, TDBListBox,

TDirectoryListBox, TDrawGrid, TFileListBox, TForm, TImage, TListBox,

TOutline, TPaintBox, TPrinter, TStringGrid. Canvas является в свою очередь

объектом, объединяющим в себе поле для рисования, карандаш (Pen), кисть

(Brush) и шрифт (Font). Canvas обладает также рядом графических методов :

Draw, TextOut, Arc, Rectangle и др. Используя Canvas, Вы можете

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

многоугольники, текст и т.п. без использования компонент TImage,TShape и

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

Вы должны обрабатывать событие OnPaint того объекта, на канве которого

Вы рисуете. Рассмотрим подробнее свойства и методы объекта Canvas.

Свойства Canvas :

Brush -кисть, является объектом со своим набором свойств:

Bitmap- картинка размером строго 8x8, используется для заполнения

(заливки) области на экране.

Color - цвет заливки.Style - предопределенный стиль заливки; это свойство

конкурирует со свойством Bitmap - какое свойство Вы определили

последним, то и будет определять вид заливки.

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

вызовах процедур Windows API .ClipRect - (только чтение) прямоугольник,

на котором происходит графический вывод.CopyMode- свойство определяет,

каким образом будет происходить копирование (метод CopyRect) на данную

канву изображения из другого места: один к одному, с инверсией

изображения и др.Font - шрифт, которым выводится текст (метод

TextOut).Handle - данное свойство используется для прямых вызовов

Windows API.Pen - карандаш, определяет вид линий; как и кисть (Brush)

является объектом с набором свойств:Color - цвет линии 

Handle - для прямых вызовов Windows API Mode - режим вывода: простая

линия, с инвертированием, с выполнением исключающего или и др. 

Style - стиль вывода: линия, пунктир и др. 

Width - ширина линии в точкахPenPos - текущая позиция карандаша,

карандаш рекомендуется перемещать с помощью метода MoveTo, а не

прямой установкой данного свойства.

Pixels - двухмерный массив элементов изображения (pixel), с его помощью

Вы получаете доступ к каждой отдельной точке изображения (см. пример к

данному уроку).

Методы Canvas:Методы для рисования простейшей графики

- Arc, Chord, LineTo, Pie, Polygon, PolyLine, Rectangle,RoundRect. При

прорисовке линий в этих методах используются карандаш (Pen) канвы, а для

заполнения внутренних областей - кисть (Brush).

Методы для вывода картинок на канву - Draw и StretchDraw, В качестве

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

(это может быть TBitmap, TIcon или TMetafile). StretchDraw отличается тем,

что растягивает или сжимает картинку так, чтобы она заполнила весь

указанный прямоугольник (см. пример к данному уроку).

Методы для вывода текста - TextOut и TextRect. При выводе текста

используется шрифт (Font) канвы. При использовании TextRect текст

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

можно узнать с помощью функций TextWidth и TextHeight.

Объект TPaintBox

На странице System Палитры Компонент есть объект TPaintBox, который

можно использовать для построения приложений типа графического

редактора или, например, в качестве места построения графиков (если,

конечно, у Вас нет для этого специальных компонент третьих фирм).

Никаких ключевых свойств, кроме Canvas, TPaintBox не имеет, собственно,

этот объект является просто канвой для рисования. Важно, что координаты

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

(OnMouseMove и др.), являются относительными, т.е. это смещение мыши

относительно левого верхнего угла объекта TPaintBox, а не относительно

левого верхнего угла формы.

Примеры

В первом примере (проект SHAPE.DPR, рис.1) показано, как во время

выполнения программы можно изменять свойства объекта TShape.

Изменение цвета объекта (событие OnChange для ColorGrid1):

procedure TForm1.ColorGrid1Change(Sender: TObject);

begin

Shape1.Brush.Color:=ColorGrid1.ForeGroundColor;

end;

Рис.A: Пример с TShapeВо втором примере (проект PIXELS.DPR, рис.2) показано, как осуществить доступ к отдельной точке на изображении (на канве). По нажатию кнопки "Fill" всем точкам изображения присваивается свой цвет:procedure TForm1.Button1Click(Sender: TObject);var i, j : Longint;begin Button1.Enabled:=False; with Canvas do for i:=1 to Width do begin Application.ProcessMessages; for j:=1 to Height do Pixels[i,j]:=i*j; end; Button1.Enabled:=True;end;

Рис.B: Работа с точками на канве.

В третьей программе (проект DRAW.DPR, рис.3) приведен пример использования методов, выводящих изображение - Draw и StretchDraw:

Рис.C: Вывод изображений на канву.Прорисовка изображений происходит в обработчике события OnPaint для формы:procedure TForm1.FormPaint(Sender: TObject);begin with Canvas do begin Draw(0,0, Image1.Picture.BitMap); StretchDraw(Rect(250,0,350,50),Image1.Picture.BitMap) end;end;

2.2 Структурное и модульное программирование в Delphi Подпрограмму можно определить как относительно самостоятельный

фрагмент программы, оформленный таким образом, чтоего можно выполнять

многократно, передавая ему управление из

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

подпрограмм позволяет уменьшить размер про-граммы (если в различных

частях программы необходимо выполнять обработку данных по одному

алгоритму) и сделать ее исход-ный текст более удобным для понимания

процесса обработки дан-ных (если алгоритм подпрограммы обладает

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

назначение, как,например, у стандартных подпрограмм Sin(X) или Abs(X)).

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

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

распараллелить процесс создания программного продукта, поручив

разработку отдельных подпрограмм разным исполнителям, и, что

более важно, . упростить процесс написания и отладки. Разбиение

программы на подпрограммы производится прежде всего по

функциональному признаку: подпрограмма должна реализовывать одну, но

законченную функцию. При этом надо стремиться к сокращению количества

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

Рекомендуемый размер подпрограммы составляет 10.60 строк текста.

Нецелесообразно создавать слишком короткие подпрограммы, а размещение

подпрограммы в пределах одной страницы позволит программисту охватить

весь текст одним взглядом и не тратить время на переключение внимания с

одной страницы на другую. В языке Object Pascal используются два вида

подпрограмм . функции и процедуры. При общих принципах оформления

функции обладают дополнительными возможностями. Поэтому сна-

чала рассмотрим объявление и использование процедур, а затем особенности

функций.

Процедуры. При работе с подпрограммами следует различать термины

объявление подпрограммы (описание подпрограммы) и обращение к

подпрограмме (вызов подпрограммы). Объявление подпрограммы содержит

ее имя и описывает процесс обработки данных, представленных параметрами

(пока будем считать так, следуя рекомендациям структурного

программирования). В объявлении подпрограммы параметры называют

формальными. Имя подпрограммы задает ее разработчик, и оно должно быть

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

имени и описывает данные (фактические параметры), обработку которых она

должна выполнить. Выполнение обращения приводит к передаче управления

подпрограмме. Вызовов одной подпрограммы может быть несколько, а

фактические параметры в них . разными. Объявления подпрограмм и их

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

представлены в виде синтаксических диаграмм. Имя процедуры (рис. 6.1)

строится так же, как и прочие имена в языке Object Pascal. Блок процедуры,

как и блок основной программы, может содержать объявления меток,

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

оператор (begin .... end), представляющий алгоритм. Список формальных

параметров содержит имена, используемые в теле подпрограммы для

описания процесса обработки данных.

Обращение к процедуре является отдельным оператором программы. Список

фактических параметров представляет реально существующие данные.

Соответствие фактических параметров формальным устанавливается

порядком их следования в списках. При вызове подпрограммы фактические

параметры как бы занимают в алгоритме места соответствующих

формальных (уточнение будет дано позже), после чего алгоритм

выполняется.

Пример объявления и вызова процедуры, выводящей на экран

первое из двух значений, представленных параметрами, кратное 5,

или сообщение, что кратных нет:

//Объявление процедурыprocedure PutMod5(I,J:Integer);// I и J . формальные параметрыbeginif I mod 5 = 0 thenWriteLn(I)else if J mod 5 = 0 thenWriteLn(J)elseWriteLn('Нет параметров, кратных 5');end;. . . . .begin // РАЗДЕЛ ОПЕРАТОРОВ ПРОГРАММЫ. . . . .//Вызов процедурыPutMod5(A+3, B);//A+3 и B . фактические параметры. . . . .end.Рассмотрим на конкретных значениях переменных A и B, что будет выведено подпрограммой:при A = 2 и B = 10 будет выведено значение 5;при A = 3 и B = 10 будет выведено значение 10;при A = 3 и B = 11 будет выведен текст «Нет параметров, крат-ных 5».

Тип в объявлении формального параметра пока будем считать обязательным

и задавать только именем ранее объявленного или стандартного типа (другие

возможности будут рассмотре-

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

параметров, введем в рассмотрение два термина: входной параметр и

выходной параметр. Параметр считается входным,

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

подпрограммы (в рассмотренном примере оба параметра являются

входными). Параметр считается выходным, если он представляет результаты

счета по подпрограмме. Допускается, что один и тот же параметр может

одновременно представлять и исходные данные, и результат, т. е. быть

одновременно и входным, и выходным.

В языке Object Pascal рассмотренное функциональное деление параметров

(на входные, выходные, входные-выходные) дополнено механизмами

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

параметров. Сначала рассмотрим два вида объявлений параметров:

параметры-значения и параметры-переменные.Параметры-значения всегда

являются только входными параметрами. Соответствующими фактическими

параметрами могут быть выражения (в частности, константы и переменные).

При вызове подпрограммы выражения вычисляются и полученные значения

заносятся (а значения констант и переменных просто копируются) в ячейки

памяти, представленные соответствующими формальными параметрами,

значения которых внутри подпрограммы можно изменять. Механизм

параметров-значений таков, что эти изменения никак не отразятся на

значениях фактических параметров, т. е. после выхода из подпрограммы они

останутся неизменными. Таким образом, формальный параметр-значение

можно рассматривать как переменную, известную внутри подпрограммы,а

механизм таких параметров . как защиту фактических параметров, если они

переменные, от непреднамеренного изменения.Объявление параметров-

значений дается просто их именем (списком имен через запятую) и типом

(без предшествующих слов var, const, out). В рассмотренной процедуре

PutMod5 оба параметра представляют собой параметры-значения.

Параметры-переменные являются одновременно и входными, и выходными

параметрами. Соответствующими фактическими параметрами могут быть

только переменные. Механизм параметров-переменных таков, что

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

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

эти изменения сохранятся после выхода из подпрограммы. Достигается это

за счет того, что в подпрограмму передается не сама переменная, а ссылка на

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

данным фактического параметра. Объявление параметров-переменных дается

с предшествующим их имени (списку имен) словом var и типом.

Пример процедуры, умножающей данные в первых n ячейках массива Mas на дробную часть числа R (все участвующие в обработке данные должны передаваться через параметры):type tMas=array[1..8] of Real;. . . . .//Объявление процедурыprocedure MasMulR(R:Real; N:Integer; var Mas:tMas);vari:Integer;beginR:=Frac(R);//Получить дробную часть Rfor i:=1 to N doMas[i]:=Mas[i]*R;end;//MasMulR . конец текста процедуры. . . . .varX:tMas=(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);Z:Real=3.4;. . . . .begin // РАЗДЕЛ ОПЕРАТОРОВ ПРОГРАММЫ. . . . .MasMulR(Z,5,X);//Вызов процедуры. . . . .end.В этом примере Mas является и входным, и выходным, поэтому он объявлен

как параметр-переменная (с предшествующим словом var). Параметр R .

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

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

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

опасаясь, что изменится значение соответствующего фактического

параметра. При указанных в примере начальных значениях переменных

после выполнения процедуры переменная Z сохранит свое значение 3.4, а в

массиве будут следующие данные: 0.4, 0.8, 1.2, 1.6, 2.0, 6.0, 7.0, 8.0.

Параметры-значения обладают одним недостатком, который может оказаться

очень существенным, если параметром является

структурная переменная, занимающая большой объем памяти, например,

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

такой же объем памяти, как фактический

параметр, и скопировать в нее данные из фактического параметра. Таким

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

память и происходит потеря времени на

копирование данных перед началом их обработки по алгоритму

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

параметра, получивший название «параметр-константа».

Параметр-константа, как и параметр-значение, служит для представления

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

ссылка на фактический параметр (как

и для параметра-переменной), но для исключения непреднамеренного

изменения во время работы программы уже на этапе компиляции выполняют

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

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

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

констант дается с предшествующим

их имени (списку имен) словом const и типом. Последний вид параметра

следует использовать для параметров, представляющих только результаты

работы подпрограммы. По аналогии с параметрами других видов ему

подошло бы название параметр-результат или по предшествующему его име-

ни слову out в объявлении . параметр-выходная переменная. Этот параметр

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

качестве источника исходных данных. За этим

должен следить программист, а слово out перед именем в списке формальных

параметров призвано облегчить понимание алгоритма подпрограммы,

напоминая, что параметр не представляет

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

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

должна вычислять сумму положительных элементов массива X(100, 100) и

их количество:

typetMas=array[1..100,1..100] of Extended;. . . . .//Объявление процедурыprocedure SumCol(const X:tMas,out S: Extended;out K:Integer);vari,j: Integer;beginS:=0;K:=0;for i:=1 to 100 dofor j:=1 to 100 doif X[i,j]>0 thenbeginS:=S+X[i,j];K:=K+1;end;end;. . . . .varY:tMas; Sum: Extended; Col: Integer;. . . . .begin // РАЗДЕЛ ОПЕРАТОРОВ ПРОГРАММЫ. . . . .SumCol(Y,Sum,Col);

. . . . .end.

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

параметр является только входным, а два последних. только выходными.

Первый параметр объявлен параметром-кон-

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

100 000 байт и копирования в нее данных из фактического параметра .

массива Y. 6.2. Пример выполнения задания Составить процедуру,

копирующую из матрицы A(m, n), m Ј 10, n Ј 14 положительные элементы в

массив Pol и подсчитывающую их количество kPol, а отрицательные

элементы . в массив Otr и подсчитывающую их количество kOtr.

Использовать эту процедуру для матрицы В в основной программе. Если

окажется, что положительных и/или отрицательных элементов в матрице нет,

то вывести соответствующие сообщения, иначе скопированные в массивы

данные:

program Project1;{$APPTYPE CONSOLE}usesSysUtils;constmMax=10; nMax=14;179typetMatr=array[1.. mMax,1.. nMax] of Real;tMas=array[1.. mMax * nMax] of Real;procedure PolOtr(const A:tMatr;m,n:Integer;out Pol, Otr:tMas;out kPol, kOtr:Integer);vari,j:Integer;beginkPol:=0;kOtr:=0;for i:=1 to m dofor j:=1 to n dobeginif A[i,j]>0 then

beginkPol:= kPol +1;Pol[kPol]:=A[i,j];endelse if A[i,j]<0 thenbeginkOtr:= kOtr +1;Otr[kOtr]:=A[i,j];end;end;end;varB:tMatr; P,O:tMas;m,n,i,j,kP,kO:Integer;begin // РАЗДЕЛ ОПЕРАТОРОВ ПРОГРАММЫWriteLn('Введите количество строк и столбцов');ReadLn(m,n);WriteLn('Введите матрицу по строкам');for i:=1 to m dobeginfor j:=1 to n doRead(B[i,j]);6ReadLn;end;PolOtr(B,m,n,P,O,kP,kO);if kP>0 thenbeginWriteLn(' Массив положительных');for i:=1 to kP doWrite(P[i]:6:1,' ');endelseWriteLn('Положительных элементов нет');WriteLn;if kO>0 thenbeginWriteLn(' Массив отрицательных');for i:=1 to kO doWrite(O[i]:6:1,' ');endelseWriteLn('Отрицательных элементов нет');ReadLn;end.

Функции.Отличие функции от процедуры состоит в том, что: в заголовке после списка

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

результата) . имя ранее объявленного или стандартного типа; . в вызывающей

программе обращение к функции можно записывать в правой части

оператора присваивания и в выражениях, если тип результата простой (но

присваивать значение имени функции в вызывающей программе запрещено);

. в объявлении функции ее имя (не обращение, делающее подпрограмму

рекурсивной) не должно встречаться в правой части операторов

присваивания или в выражениях; . в объявлении функции должен быть хотя

бы один оператор, присваивающий ее имени или объявленной по умолчанию

локальной (известной только внутри функции) переменной Result того же

типа, что и тип функции, результат вычислений; . в отличие от имени

переменную Result можно использовать в правых частях операторов

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

представляющую результат вычислений. Обращение к функции, как и к

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

расширенного синтаксиса, используемом в Delphi по умолчанию. Обращение

к функции отдельным оператором имеет смысл, когда интересующий нас

результат представлен параметрами, а не именем функции. Отключить

режим расширенного синтаксиса можно директивой {$X-} или

{$EXTENDEDSYNTAX OFF}, но тогда не будет объявлена по умолчанию

локальная переменная Result и при попытке ее

использования компилятор сообщит об ошибке. Пример 1. Составить и использовать функцию, возвращающуюмаксимальный из первых N элементов массива X(N), N Ј 100:typetMas=array[1..100] of Real;. . . . .function MaxMas(N:Integer; const X:tMas):Real;vari:Integer;beginResult:=X[1];

for i:=2 to N doif X[i]>Result thenResult:=X[i];end;. . . . .varY:tMas;begin // РАЗДЕЛ ОПЕРАТОРОВ ПРОГРАММЫ. . . . .//Вызов функции в операторе выводаWriteLn('Максимальный из сорока ','элементов массива Y = ',MaxMas(40, Y));. . . . .end.Если отключить режим расширенного синтаксиса, то в объявлении функции

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

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

В результате получили бы следующее объявление функции:

function MaxMas(N:Integer; const X:tMas):Real;vari:Integer;R:Real;//Дополнительная переменнаяbeginR:=X[1];for i:=2 to N doif X[i]>R thenR:=X[i];//Чтобы функция возвратила вычисленное значение,//оно должно быть присвоено ее имениMaxMas:=R;end;Использование функций позволяет не только сделать текст программы более удобным для понимания алгоритма, но и уменьшить его при необходимости повторных вычислений в разных частях программы.Приложение Delphi помимо стандартных модулей может использовать

модули, создаваемые пользователями. Каждый модуль пользователя является

отдельно подготовленной и хранящейся в

отдельном файле с расширением .pas программной единицей, которая может

быть использована любой программой. В Delphi реализован модульный

принцип программирования, причем модули играют роль наборов заранее

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

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

основной программе и модулях).

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

указанные части программы, и код, выполняемый после возврата управления

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

interface и implementation опускать нельзя. Если в модуле

не требуются части инициализации и финализации, то не нужно записывать

слова initialization и finalization, но если часть финализации необходима, то

должна присутствовать и часть инициализации, даже если в ней нет ни

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

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

которому подключен данный модуль, причем именованные константы, типы

и переменные объявляют как обычно, а процедуры и функции . своими

заголовками. Эти имена будут известны и в остальных частях модуля.

Полное объявление подпрограмм, заголовки которых представлены в

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

части реализации могут объявляться другие подпрограммы, метки, а также, в

дополнение к объявлениям в интерфейсной части, именованные константы,

типы и переменные, недоступные вне модуля. Они могут иметь

вспомогательное значение при реализации подпрограмм интерфейсной части

или использоваться в частях инициализации и финализации. Часть

инициализации предназначена для размещения операторов, выполнение

которых предшествует выполнению операторов основной программы (той

части программы, которая ис-

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

выполняемых после окончания основной (указанной части) программы.

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

хранения данных только во время выполнения программы, а в части

финализации удалить эти файлы. Такое решение позволит упростить

разработку программы и избежать засорения дискового пространства

ненужными файлами при возникновении исключений в основной программе,

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

модуль Unit1, в котором создается файл 'TempFile.txt':

unit Unit1;interfacevar//Файловая переменная f будет представлять//временный файл в программе,//использующей данный модульf: TextFile;implementationinitialization//Связать файловую переменную f//с внешним именем файла 'TempFile.txt'Assign(f, 'TempFile.txt');Rewrite(f); //создать файлfinalizationif FileExists('TempFile.txt') then//Если файл не был уничтожен,begin //тоtryCloseFile(f); //Закрыть файлexcept//Сообщения не будет,//если файл был закрыт в основной программеend;Erase(f); //Уничтожить закрытый файлendend.. присоединить к программе Project1:program Project1;{$APPTYPE CONSOLE}usesSysUtils,Unit1;//Использовать модуль Unit1 в этой программе. . . . . . .

то файл 'TempFile.txt' будет создан до передачи управления в основную

программу и с ним можно будет работать, используя файловую переменную f

(открывать, закрывать, открывать для до-

бавления текста, записывать текст в файл, читать из файла, уничтожать

файл), а после выхода из основной программы при любом ее завершении

(нормальном или аварийном) управление

будет передано операторам части финализации модуля Unit1, и файл

'TempFile.txt' будет уничтожен.

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

последовательности и чередоваться при соблюдении правила использования

имен: при объявлении нового имени (констан-

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

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

узнает о подключенных модулях, анализируя

предложения использования в основной программе или в самих модулях.

Предложение использования строится из ключевого слова uses и следующего

за ним списка имен подключаемых модулей. В основной программе и в

интерфейсной части модуля формы, создаваемых в среде Delphi,

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

модулей следует просто

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

пользователь при необходимости должен сам добавить предложения

использования. Например, в модуль, создаваемый для решения

вычислительных задач, следует в интерфейсную часть или в часть

реализации включить предложение использования со стандартным модулем

Math:

uses Math;

Присутствие имени модуля в предложении использования основной

программы (или другого модуля) означает, что объявленные в его

интерфейсной части константы, типы, переменные и подпрограммы

доступны для использования. Существует отличие в назначении

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

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

возникало взаимных ссылок модулей непосредственно или через другие

модули. Только в этом случае компилятор сможет определить порядок

использования объявлений из интерфейсных частей.Для части реализации

такого ограничения нет. Это позволяет строить взаимно рекурсивные

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

взаимную рекурсию и внут-

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

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

размещены в интерфейсной части. При разработке программы в среде Delphi

вновь создаваемый модуль (по команде File/New/Unit) добавляется в

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

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

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

Project/Add to Project..., в диалоге выбрать папку с модулем и в ней . сам

модуль с расширением .pas (при разработке приложения с формой текст

основной программы можно отобразить командой Project/View Source).

После добавления в проект модулей программист уже в них должен

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

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

основной программы командой Project/View Source, где должна быть ссылка

на модуль в предложении uses, или открыв окно диалога Project Manager

командой View/Project Manager... Пример 1. Составить консольное

приложение, выполняющее обработку матриц по формуле (A + B) ЧC + D.

Приложение должно использовать модули Unit1 и Unit2, подготовленные в

проекте и хранящиеся в одной папке с основной программой. Модуль Unit1

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

матрицы, участвующие в вычислениях, и две процедуры: ReadMatr ввода

матрицы и WriteMatr вывода. Модуль Unit2 также должен содержать

процедуры AddMatr сложения матриц и MulMatr умножения. Требования к

модулю Unit1. Для хранения матриц следует использовать двумерные

динамические массивы. Первый параметр процедуры ReadMatr должен

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

параметрами, а четвертый параметр целого типа с начальным значением 0

указывать режим работы процедуры. Процедура ReadMatr должна

обеспечить ввод матрицы с клавиатуры в виде матрицы по строкам, если

четвертый параметр при ее вызове опущен. Этот параметр предназначен для

отладки программ, использующих модуль Unit1. При задании в вызове

процедуры ReadMatr четвертого параметра, не равного 0, процедура должна

генерировать матрицу случайных чисел от нуля до абсолютного значения

этого параметра включительно, причем если он меньше нуля, то при

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

ина-

че . одни и те же. Сгенерированные матрицы следует выводить в виде

матрицы по строкам. роцедура WriteMatr должна иметь один параметр,

представляющий матрицу, и обеспечивать ее вывод в виде матрицы по

строкам с пробелом между числами не менее одного. Требования к модулю

Unit2. Для хранения матриц следует использовать двумерные динамические

массивы типа, объявленного в модуле Unit1. В процедурах AddMatr и

MulMatr два первых параметра должны представлять только входные данные

(матрицы, представляющие только исходные данные), а третий . только

выходные данные (результирующую матрицу). Требования к основной

программе. Использовать условную ком-

пиляцию, обеспечивающую при объявлении имени Debug директивой

{$IFDEF Debug} генерацию случайных чисел для матриц, представляющих

исходные данные, иначе ввод матриц с кла-

виатуры.

//Модуль Unit1 объявления типа двумерного

//динамического массива//и процедур ввода и вывода матриц.unit Unit1;interface

usesMath;typetm1=array of Integer;//тип двумерного динамического массиваtm2=array of tm1;procedure ReadMatr(out x:tm2;m,n:Integer;r:Integer=0);procedure WriteMatr(const x:tm2);implementationprocedure ReadMatr(out x:tm2;m,n:Integer;r:Integer=0);{Ввод матрицы m*n по строкам в динамическиймассив типа tm2: при r=0 - ввод с клавиатуры,иначе - от датчика случайных чисел,причем при r>0 - без Randomize,иначе - с Randomize}var i,j:Integer;begin//Установить размеры массива x//равными размерам вводимой матрицыSetLength(x,m,n);if r=0 then begin//Ввод матрицы с клавиатурыfor i:=0 to m-1 do beginfor j:=0 to n-1 doRead (x[i,j]);ReadLnend;end231elsebegin//Генерация матрицы случайных целых чисел,//из интервала 0..r+1if r<0 then //При r<0 будет создан//новый набор случайных чисел для матрицыRandomize;r:=Abs(r)+1;for i:=0 to m-1 dofor j:=0 to n-1 dox[i,j]:=Random(r);WriteMatr(x);

end;end;//ReadMatrprocedure WriteMatr(const x:tm2);{Вывод матрицы m*n по строкамиз динамического массива}var i,j,m,n,xmax:Integer;beginm:=High(x);n:=High(x[0]);xmax:=Abs(x[1,1]);for i:=0 to m dofor j:=0 to n doif Abs(x[i,j])>xmax thenxmax:=Abs(x[i,j]);for i:=0 to m do beginfor j:=0 to n doWrite (x[i,j]:Trunc(Log10(xmax))+2);WriteLn;end;end;//WriteMatrend.//Модуль Unit2 объявления процедур//сложения и умножения матрицunit Unit2;interfaceusesUnit1;{Фактические параметры обеих процедур не могутбыть одновременно и входными, и выходными}procedure AddMatr(const x,y:tm2; out z:tm2);7. МОДУЛИ ПОЛЬЗОВАТЕЛЕЙ232 ПРАКТИКУМ ПО ПРОГРАММИРОВАНИЮprocedure MulMatr(const x,y:tm2; out z:tm2);implementationprocedure AddMatr(const x,y:tm2; out z:tm2);{Процедура сложения матриц Z=X+Y}vari,j,m,n:Integer;beginm:=High(x); //m+1 - число строк в X, Y и Zn:=High(x[0]);//n+1 - число столбцов в X, Y и Z//Установить размеры массива z//равными размерам матрицы ZSetLength(z,m+1,n+1);for i:=0 to m do

for j:=0 to n doz[i,j]:=y[i,j]+x[i,j];end;//AddMatrprocedure MulMatr(const x,y:tm2; out z:tm2);{Процедура умножения матриц Z=X*Y}vari,j,m,n,l,k:Integer;begin// m+1 - число строк в X и Z столбцов в Ym:=High(x);// n+1 - число столбцов в Xn:=High(x[0]);// l+1 - число столбцов в Yl:=High(y[0]);//Установить размеры массива z//равными размерам матрицы ZSetLength(z,m+1,l+1);for i:=0 to m dofor j:=0 to l do beginz[i,j]:=0;for k:=0 to n doz[i,j]:=z[i,j]+x[i,k]*y[k,j];end;end;//MulMatrend.//Основная программа вычисления матрицы E=(A+B)*C+Dprogram Project1;{$APPTYPE CONSOLE}233usesSysUtils,Unit1 in 'Unit1.pas',Unit2 in 'Unit2.pas';//Объявление имени Debug,//используемого при условной компиляции.{$DEFINE Debug}//Отменить объявление имени Debug можно,//удалив строку с директивой {$DEFINE Debug}//или превратив ее в комментарий: //{$DEFINE Debug}.vara,b,c,d,e,f,g:tm2;begin{$IFDEF Debug}//Если имя Debug объявлено директивой//{$DEFINE Debug}, то в исполняемую программу

//будут включены следующие операторы, обеспечивающие//генерацию матриц случайных чисел и их выводWriteLn(' Mатрица A 2х3 целых случайных чисел ','в диапазоне 0..7');ReadMatr(a,2,3,8);WriteLn(' Mатрица B 2х3 целых случайных чисел ','в диапазоне 0..5');ReadMatr(b,2,3,6);WriteLn(' Mатрица C 3х4 целых случайных чисел ','в диапазоне 0..8');ReadMatr(c,3,4,-9);WriteLn(' Mатрица D 2х4 целых случайных чисел ','в диапазоне 0..8');ReadMatr(d,2,4,9);{$ELSE} //иначе, то есть если имя Debug//не объявлено, то в исполняемую программу//будут включены следующие операторы,//обеспечивающие ввод матриц с клавиатуры.WriteLn(' Введите матрицу A 2х3');ReadMatr(a,2,3);WriteLn(' Введите матрицу B 2х3');ReadMatr(b,2,3);WriteLn(' Введите матрицу C 3х4');ReadMatr(c,3,4);WriteLn(' Введите матрицу D 2х4');ReadMatr(d,2,4);{$ENDIF}7. МОДУЛИ ПОЛЬЗОВАТЕЛЕЙ234 ПРАКТИКУМ ПО ПРОГРАММИРОВАНИЮРис. 7.2//Вычисление и вывод матрицAddMatr(a,b,f);WriteLn(' Mатрица F=(A+B)');WriteMatr(f);MulMatr(f,c,g);WriteLn(' Mатрица G=(A+B)xC');WriteMatr(g);AddMatr(g,d,e);WriteLn(' Mатрица E=(A+B)xC+D');WriteMatr(e);ReadLn;end.При запуске программы с директивой, объявляющей имя Debug, в окно

программы сразу будут выведены результаты построения матриц случайных

чисел с поясняющими текстами и вычисления (A + B)ЧC + D по шагам, как

показано на рис. 7.2. При повторных запусках программы матрицы A и B не

изменятся, а C и D будут создаваться всякий раз новые, так как генерация

новых случайных чисел стандартной функцией Random начинается с вызова

ReadMatr(c,3,4,-9) для построения матрицы C, где отрицательное значение

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

отладки программы строку с директивой {$DEFINE Debug} следует

превратить в комментарий.

К Unit1 должен подключаться стандартный модуль Math, так как в процедуре

WriteMatr используется стандартная процедура Log10, но поскольку

объявления интерфейсной части Unit1 не требуют подключения Math, то

предложение использования uses Math; размещено в его части реализации.

Модуль Unit1 должен быть под ключен к Unit2 в интерфейсной части, так как

объявленный в Unit1 тип tm2 двумерного динамического массива

используется при объявлении заголов-

ков процедур AddMatr и MulMatr. Следует обратить внимание на одну

особенность динамичес-

ких массивов при работе с матрицами, использованную в процедурах

WriteMatr, AddMatr и MulMatr, . размеры массивов всегда совпадают с

размерами матриц, что исключает необходимость указания их в качестве

параметров подпрограмм. В соответствии с условиями примера 1 входные

параметры

объявлены как const-параметры, а выходные . как out-параметры.

При наличии в разных модулях одинаковых имен, объявленных в их

интерфейсных частях, использование их подчиняетсяследующему правилу:

для избежания ошибок перед именем в ка-

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

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

использования последним, где это имя было объяв-

лено. Так, в основной программе последним в предложении использования

был модуль Unit3, поэтому вызовы его процедурыMulMatr записаны без

префиксов (например, MulMatr(a,b,b)), а

вызовы процедур модуля Unit2 . с префиксом

(например,Unit2.MulMatr(a,d,c)).

2.3. Объектно-ориентированный подход к проектированию прикладных

программ

Объектно-ориентированное программирование (ООП) — это технология,

основанная на представлении программ в виде совокупности объектов,

каждый из которых является реализацией собственного класса, которые в

свою очередь образуют иерархию на принципах наследования.

Основное достоинство ООП — сокращение количества межмодульных

вызовов и уменьшение объемов информации, передаваемой между

модулями, по сравнению с модульным программированием. Это достигается

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

подпрограммами обработки, что позволяет вести практически независимую

разработку отдельных частей (объектов) программы.

Объектная декомпозиция

При использовании технологии ООП решение представляется в виде

результата взаимодействия отдельных элементов некоторой системы,

имитирующей процессы, происходящие в предметной области поставленной

задачи. Каждый элемент системы, получая сообщение, выполняет заранее

определенную последовательность действий (например, обрабатывает полу-

ченные данные, изменяет свое состояние, пересылает полученные данные

другому элементу системы). Передавая сообщения от одного элемента

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

Элементы системы, параметры и поведение которой определяются

условием задачи, обладающие самостоятельным поведением (т. е.

«умеющие» выполнять некоторые действия, зависящие от полученных

сообщений и состояния элемента), получили название объектов .

Процесс представления предметной области в виде совокупности

объектов, обменивающихся сообщениями, называется объектной

декомпозицией.

Упражнение 1. Выполните объектную декомпозицию программы,

которая по запросу пользователя рисует точку, окружность или квадрат. По

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

программы. Для этого необходимо проанализировать все происходящие в

системе процессы и выделить элементы, обладающие собственным

поведением, воздействующие на другие элементы и/или являющиеся

объектами такого воздействия.

Основная цель системы — нарисовать фигуру, выбранную пользователем.

Действия пользователя — это либо выбор фигуры, либо изменение

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

выбранную фигуру с заданными параметрами. Для выполнения этих команд

можно воспользоваться следующими объектами: Менеджер (получает,

анализирует и обрабатывает команды пользователя) и три объекта — фигуры

(каждая со своими параметрами).

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

контура, изменить размер, изменить координаты. Все эти сообщения

инициируются Менеджером в соответствии с командой пользователя.

Получив от пользователя команду Завершить, Менеджер прекращает

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

В объектно-ориентированном программировании разрабатываемая

система состоит из объектов, которые взаимодействуют через передачу

сообщений.

Каждый объект, получив сообщение, должен определенным образом

реагировать на них, выполняя заранее определенные для каждого типа

сообщения действия. Например, если объект ОбработатьЗапись будет

активизирован, то он должен будет проанализировать, какое именно

действие нужно выполнить. Если принято сообщение Редактировать, то объ-

ект должен сохранить запись в файл, на место, указанное курсором.

Состояние объекта характеризуется набором конкретных значений

некоторого перечня всех возможных свойств данного объекта; например,

состояние объекта Файл характеризуется значениями «активизирован» —

«не активизирован». Это состояние объекта необходимо для выполнения

всех действий над записной книжкой: если Файл находится в состоянии «не

активизирован», то ни одно сообщение не сможет быть обработано.

Набор значений свойств задается на этапе проектирования и не

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

значения.

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

получаемые сообщения и зависит от состояния объекта.

Если объект может обладать некоторым состоянием, то, соответственно,

может возникнуть необходимость в получении информации об этом

состоянии. Для получения такой информации объекту посылается

сообщение-запрос. В ответ на запрос объект должен переслать отправителю

требуемую информацию. В таких случаях говорят, что над объектом

выполнена операция селекции.

Обращение к объекту для изменения его состояния возбуждает

выполнение операции модификации. Отправитель сообщения-команды,

реакцией на которую должна быть модификация объекта, может ожидать

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

Если объект содержит несколько однотипных компонент, например

массив чисел, то операция, требующая последовательной обработки этих

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

операции селекции, так и операции модификации.

Основные элементы ООП

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

(абстрагирование, инкапсуляция, модульность, иерархия) и тремя

дополнительными (типизация, параллелелизм, сохраняемость).

Абстрагирование — это один из главных способов решения сложных

задач.

В результате объектной декомпозиции были выделены объекты.

Абстракция предназначена для выделения существенных характеристик

каждого объекта, отличающих его от всех других видов объектов и, таким

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

наблюдателя.

Для представления абстракций объектов используется специальный

определяемый программистом тип данных — класс.

Класс — это структурный тип данных, который включает описание

полей данных, а также процедур и функций, работающих с этими полями

данных. Процесс объединения данных с действиями над этими данными в

единый пакет при наличии специальных правил доступа к элементам пакета

получил название инкапсуляция.

Итак, сочетание данных с допустимыми действиями над этими данными

приводит к «рождению» нового «кирпичика» программирования — класса.

Действия — это процедуры и функции, описанные в классе, они получили

название методов.

Класс представляет собой структуру, динамически размещаемую в

памяти. Экземпляр класса называется объектом. Прежде чем программа

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

Объекты создаются и уничтожаются с помощью специальных методов,

которые называются constructor (конструктор) и destructor (деструктор).

«Рожденный ползать летать не может» — и объект действует только так,

как это в нем заложено, и только над тем, что в нем описано. Обращение к

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

Для корректной работы абстракции доступ к ее внутренней структуре

должен быть ограничен. Для этого вводятся две части в описании

абстракции.

Интерфейс — это совокупность доступных извне элементов реализации

абстракции, т. е. основные характеристики состояния и поведения.

Реализация — это совокупность недоступных извне элементов

реализации абстракции, т. е. внутренняя организация абстракции и

механизмы реализации ее поведения.

Наличие интерфейса обеспечивает уменьшение возможности

«разрушения» (несанкционированного изменения значений полей) объекта

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

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

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

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

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

через специальный интерфейс.

Для описания нового класса в языке Object Pascal определен следующий

синтаксис:

Туре <имя_объявляемого_класса>=с1аss(<имя_класса_родителя>) Private

<скрытые_элементы_класса> Protected

<защищенные_элементы_класса> Public

<общедоступные_элементы_класса> Published

<опубликованные_элементы_класса> end;

Директивы private, protected, public, published предназначены для

ограничения доступа к элементам класса.

Секция private содержит внутренние элементы, обращение к которым

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

Секция protected содержит защищенные элементы, которые доступны в

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

потомков.

Секция public содержит общедоступные элементы, к которым возможно

обращение из любой части программы.

Секция published содержит опубликованные элементы, которые по

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

(внесенных на панель компонент), информация об элементах, размещенных в

этой секции, становится доступной через инспектор объектов.

Потомки класса могут менять область доступности всех элементов

родительского класса, кроме элементов, объявленных в секции private, так

как последние им недоступны.

Все объекты Delphi являются динамическими, т. е. размещаемыми в

динамической области памяти. Соответственно переменная типа класса по

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

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

размещение объекта в памяти, а деструктор — выгрузку из нее.

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

описания положения геометрической фигуры на экране.

Решение

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

элемента на экране — координаты местоположения х и у, при этом

возможными действиями являются инициализация элемента, получение

координат, разрушение объекта.

Определим класс Position:

Для хранения значений координат введем два поля Fx и Fy (в языке

Object Pascal принято соглашение названия полей начинать с символа F (от

слова Field — поле)). Это внутренние данные класса, чтобы обеспечить их

целостность, опишем их в разделе private.

Constructor Create предназначен для создания экземпляра класса

(объекта), а также для определения начальных значений его полей.

Destructor Destroy предназначен для удаления объекта из динамической

памяти.

Подчеркнем, выделим мысль о том, что согласно идеологии объектно-

ориентированного программирования все действия с данными,

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

методов объекта. Методы GetX и GetY по запросу обращаются к

соответствующему полю объекта и возвращают координаты положения

объекта.

Итак, объединение данных с действиями над этими данными порождает

новый тип, а процесс называется инкапсуляцией.

Создавая объекты типа TPosition, инициализируя их в соответствии с

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

храниться внутри объектов.

Каждая переменная типа class включает набор полей, объявленных в

классе. Совокупность значений, содержащихся в этих полях, моделирует

конкретное состояние объекта предметной области. Изменение этих

значений в процессе работы отражает изменение состояния моделируемого

объекта.

Воздействие на объект выполняется посредством изменения его полей

или вызова его методов. Доступ к полям и методам объекта осуществляется,

за исключением специальных случаев, с указанием имени объекта (при этом

используются составные имена):

<имя_объекта>.<имя_поля>; ИЛИ

<имя_объекта>.<имя_метода>;

Все методы объекта обязательно имеют доступ ко всем полям своего

объекта. В языке Object Pascal это достигается через неявную передачу в

метод специального параметра Self — адреса области данных конкретного

объекта. Таким образом, уменьшается количество параметров, явно

передаваемых в метод.

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

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

могут устанавливать связи между собой. Связи между модулями — это их

представление друг о друге.

Доступ к данным объекта не через его методы запрещен! Кроме того,

объекты должны ограничивать свои операции только их собственными

данными и не должны быть связанными ни с какими глобальными

переменными, а также не должны изменять их.

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

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

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

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

Для описания небольших задач допустимо описание всех классов и объектов

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

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

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

другим модулям.

В традиционном структурном программировании модульность — это

искусство раскладывать программы на части так, чтобы в один контейнер

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

В ООП ситуация несколько иная: необходимо физически разделить классы и

объекты, составляющие логическую структуру проекта.

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

отдельном модуле. В качестве межмодульных можно использовать только те

элементы, вероятность изменения которых мала. Все структуры данных

должны быть обособлены в модуле; доступ к данным из модуля должен

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

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

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

Модульность — это свойство системы, которая была разложена на

внутренне связные, но слабо связанные между собой модули.

Правила разделения системы на модули.

Распределение классов и объектов по модулям должно учитывать то, что

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

Многие компиляторы создают отдельный сегмент кода для каждого

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

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

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

виртуальной памяти.

Иерархия. Значительное упрощение в понимании сложных задач

достигается за счет образования из абстракций иерархической структуры.

Иерархия — расположение частей или элементов целого от высшего к

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

Одним из важных видов иерархии является наследование.

Программист для решения определенного класса задач может строить

иерархию классов, в которой, и это самое главное, каждый следующий

производный класс имеет доступ (наследует) к данным и действиям всех

своих предшественников (прародителей). Потомок получает в свое

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

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

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

методы предка доступны его потомку. Если в потомке создается

одноименное поле или метод, можно говорить о перекрытии полей и

методов.

В ООП используют два вида иерархии.

Иерархия «целое-часть» показывает, что некоторые абстракции

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

описывается следующими частями: цветоложе, пестик, тычинки, цветоножка,

завязь, лепестки. Этот вариант иерархии используется в процессе разбиения

системы на разных этапах проектирования (на логическом уровне — при

декомпозиции предметной области на объекты, на физическом уровне — при

декомпозиции системы на модули и при выделении отдельных процессов в

мультипроцессорной системе).

Иерархия «общее—частное» — показывает, что некоторая абстракция

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

разновидность хвойных деревьев, а деревья — это часть растительного мира

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

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

характеристик и, возможно, уточнения имеющихся.

Разработайте класс Точка.Решение

Определим новый класс TPoint (точка). Точка определяется

координатами х и у. Объекты типа TPoint можно сделать видимыми или

невидимыми, задать цвет изображения, переместить и т. д.

Полная структура класса TPoint имеет вид:

TPosition, указанный в скобках после зарезервированного слова class,

сообщает компилятору, что TPoint является «потомком» класса TPosition и

соответственно наследует все поля и методы этого класса (в частности, поля

Fx и Fy, методы GetX и GetY).

Класс TPoint описывает новые поля, определяющие видимость (FVisible)

и цвет (FColor), и методы определить видимость (IsVisible), отобразить

(Show), спрятать (Hide), переместить (Move).

Конструктор Create и деструктор Destroy переопределяются.

Отметим, что новый класс автоматически получает все данные и методы

своих предков, то есть экземпляр класса TPoint содержит все данные (поля) и

методы типа TPosition. Таким образом, в иерархичном дереве классов по

мере удаления от корня будут встречаться все более сложные классы,

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

поведением.

Доступ к полям и методам, описанным в классе-родителе,

осуществляется так же, как к собственным.

Типизация. Напомним, тип — это точная характеристика свойств, включая

структуру и поведение, относящуюся к некоторой совокупности объектов.

Типизация — это ограничение, которое накладывается на класс объектов и

препятствует взаимозаменяемости различных классов или сильно сужает воз-

можность такой замены.

Использование принципа типизации обеспечивает:

раннее обнаружение ошибок, связанных с недопустимыми операциями над

программными объектами (ошибки обнаруживаются на этапе компиляции

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

программным объектом);

упрощение документирования;

возможность генерации более эффективного кода.

 ООП возможна статическая и динамическая связь имени объекта и его типа.

В первом случае это означает определение типов переменных во время

компиляции. Во втором — тип выражения определяется во время исполнения

приложения. Из принципов динамической связи и наследования вытекает

очень важное свойство, присущее объектам — полиморфизм. Полиморфизм

— это выделение некоторого действия, т. е. действие должно иметь имя, и

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

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

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

свойства объектов, сохраняя название, изменяются по сути.

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

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

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

ООП такой полиморфизм называется простым, а методы, имеющие

одинаковое название, — статическими полиморфными. В ранее рассмотрен-

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

конструктор Create.

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

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

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

аспект.

Сложный полиморфизм. Полиморфными объектами, или полиморфными

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

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

переменной.

В языках со строгой типизацией такая ситуация может возникнуть

при передаче объекта типа класса-потомка в качестве фактического

параметра подпрограмме, в которой этот параметр описан как параметр типа

класса-родителя (явно — в списке параметров или неявно — в качестве

внутреннего параметра, используемого при вызове методов — Self);

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

адрес объекта класса-потомка.

Тип полиморфного объекта становится известным только на этапе

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

для такого объекта нужный аспект также должен выполняться на этапе

выполнения. Для этого в языке должен быть реализован механизм позднего

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

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

С помощью механизма позднего связывания реализуется оперативная

перестройка программы в соответствии с типами используемых объектов.

Рассмотрим это свойство на практике.

Упражнение. Разработайте класс Окружность. Решение

Определим новый класс TCircle (окружность). Окружность определяется

центром с координатами х, у и радиусом г. Объекты этого типа можно

сделать видимыми или невидимыми, задать цвет изображения, переместить и

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

TPoint:

TCircle = class (TPoint)

Private

Fr: Integer; {радиус}

Public

Constructor Create(InitX, InitY, InitR: Integer); Destructor Destroy;

Function GetR: Integer; {возвращает значение радиуса}

Procedure Show; {спрятать}

Procedure Hide; {отобразить}

Procedure Move (NewX, NewY: Integer); {переместить}

End;

Классы TPoint и TCircle связаны отношением наследования и содержат

методы Hide (спрятать), Show (отобразить) и Move (переместить). Очевидно,

что методы Show и Hide для каждого класса свои, но логика метода Move

совпадает:

Переместить:

Спрятать объект; {вызов метода Hide}

Изменить координаты объекта; {x:=NewX; y:=NewY}

Отобразить объект; {вызов метода Show}

Поэтому естественным было бы желание определить метод Move только в

TPoint так, чтобы класс-потомок TCircle унаследовал его без определения. Но

в методе Move ссылки на методы Hide и Show формируются на стадии

компиляции. Это жесткая, статическая связь, и без ее «разрыва», т. е.

реализации механизма более позднего формирования ссылок на методы не на

стадии компиляции, а на стадии выполнения (динамическое связывание),

реализовать это невозможно. Добавление к заголовку метода

зарезервированного слова virtual объявляет его виртуальным, т. е. связь с

этим методом устанавливает на стадии выполнения программы. Перепишем

описание классов следующим образом:

TPoint = class (TPosition)

Procedure Show; virtual; Procedure Hide; virtual;

end;

TCircle = class (TPoint)

Procedure Show; override; Procedure Hide; override;

end;

Директива override используется для переопределения функциональности

метода-предка, она необходима для поддержки полиморфной иерархии.

Реализация динамической связи для объектов, имеющих хотя бы один

виртуальный метод, осуществляется с помощью таблицы виртуальных

методов (ТВМ). Она содержит адреса виртуальных методов. Для каждого

класса во время компиляции программы строится одна ТВМ (рис. 1.3.2).

Формирование связи между экземпляром класса (объектом) и ТВМ

осуществляет конструктор.

Отметим, что методы, работающие с полиморфными объектами — это всегда

методы классов-предков, описывающие общие моменты поведения объектов.

В сложной иерархии, таким образом, можно выделить семейство классов со

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

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

Итак, мы смогли исключить метод Move из описания класса TCircle, сделав

его полиморфным. Все объекты классов TPoint и TCircle будут использовать

его, причем так, как им это необходимо.

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

виртуальными методами:

если в некотором классе метод описан как виртуальный, то все производные

классы, включающие метод с тем же именем, должны описать этот метод как

полиморфный (override). Нельзя заменить виртуальный метод статическим;

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

одноименных виртуальных методах должны оставаться неизменными.

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

Object Pascal используются динамические методы. По возможностям

наследования и перекрытия они аналогичны виртуальным методам, но

доступ к ним выполняется через таблицу динамических методов (ТДМ).

ТДМ хранит адреса только тех динамических методов, которые определены в

данном классе. Такой подход позволяет снизить расход памяти при большом

количестве этих методов и самих классов.

На каждый динамический метод приходится только одна ссылка,

представленная индексом, по которому и происходит поиск метода для

вызова.

Для объявления метода динамическим используется директива dynamic.

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

— с использованием ключевого слова override.

Абстрактные методы

Абстрактные методы используются при объявлении методов, реализация

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

словом abstract и обязательно переопределяются в потомках класса.

Класс, в состав которого входят методы с отложенной реализацией,

называется абстрактным. Создавать объекты абстрактных классов

запрещается.

Упражнение 1.3.4. Разработайте родительский класс для рисования

геометрических фигур.

Решение

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

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

определяться положение фигуры на экране. Во-вторых, это цвет

отображаемой геометрической фигуры. Кроме того, определим методы:

скрыть, отобразить, переместить геометрическую фигуру. Суть метода

переместить остается прежней:

Скрыть;

Задать новое расположение геометрической фигуры;

Отобразить;

Методы скрыть и отобразить для каждой геометрической фигуры будут

определять по-своему, поэтому необходимо объявить их виртуальными и

абстрактными:

Туре

TPosition = class private

Fx, Fy : integer; public

constructor Create (InitX, InitY: Integer);

function GetX: integer;

function GetY: integer;

destructor Destroy; end;

TGeometricalFigure = class (TPosition) private

Fcolor: word; public

constructor Create(InitX, InitY: integer; InitColor: word);

destructor Destroy;

function GetColor: word;

procedure SetColor(NewColor: word);

procedure Show; virtual; abstract;

procedure Hide; virtual; abstract;

Procedure Move(NewX, NewY: integer); end;

Параллелизм — свойство нескольких абстракций одновременно находиться в

активном состоянии, т. е. выполнять некоторые операции.

Есть задачи, в которых автоматические системы должны обрабатывать много

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

мощности превышает ресурсы одного процессора. В каждой из таких

ситуаций естественно использовать несколько компьютеров для решения

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

компьютере.

Процесс — это фундаментальная единица действия в системе. Каждая

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

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

недолго, а другие живут в течение всего сеанса работы системы. Реальная

параллельность достигается только на многопроцессорных системах, а

системы с одним процессором имитируют параллельность за счет

алгоритмов разделения времени.

Сохраняемость — это способность абстракции существовать во времени,

переживая породивший его процесс, и (или) в пространстве, перемещаясь из

своего первоначального адресного пространства.

Любой программный объект существует в памяти и живет в течение

некоторого времени. Спектр сохраняемости объектов охватывает:

временные объекты, хранящие промежуточные результаты вычисления

выражений;

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

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

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

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

сеансами выполнения программы.

Композиция и наполнение

В результате объектной декомпозиции второго и далее уровней могут

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

Классы для реализации таких объектов могут строиться двумя способами: с

использованием наследования или композиции.

Наследование применяется тогда, когда разрабатываемый класс имеет с

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

сходное поведение не просматривается или наследование по каким-то

причинам нецелесообразно, можно использовать композицию классов.

Композицией называется такое отношение между классами, когда один

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

являющегося объектом другого класса. Такие поля называют объектными.

Включение объектов в некоторый класс можно реализовать и с

использованием указателей на объекты, что позволяет включить 0 или более

объектов (если они собраны в массив или списковую структуру). Такая

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

пражнение 1.4.1. Приложение «Бильярд». Спроектируйте классы для

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

Решение

Для реализации объектов потребуются классы: TBilliardTab-1е (бильярдный

стол) и TCircle (шар).

Для описания шаров воспользуемся классом TCircle (упр. 1.3.3), дополнив

его новыми характеристиками: color (цвет) и dx, dy — шаг смещения:

Туре

TBall = class (TCircle) private

dx, dy : integer; color: word; public

procedure SetColor(NewColor: word); function GetColor: word;

onstrucror Create(InitX, InitY, InitR, Initdx, Initdy: integer; InitColor: word); end;

Бильярдный стол — это прямоугольник, из которого вырезали по сторонам

шесть окружностей (луз). На форме располагаются N окружностей (шаров),

образующих первоначальную к онфигурацию:

Туре

TCollection = array[1..100] of TBall; TBilliardTable = class private x, y, width,

height: word;

{координаты верхнего левого угла и размеры бильярдного стола}

color: word; {цвет стола}

N: byte; {количество шаров}

Balls: TCollection; {массив указателей на шары}

Pockets: array [1.. б] of TCircle; {массив указателей на лузы} procedure

SetConfiguration; abstract;

{начальная расстановка шаров} public

constructor Create(InitX, InitY, InitWidth, InitHeight, NewColor: word; InitN:

byte); {конструктор определяет размеры бильярдного стола, расположение

луз, вызывает процедуры SetConfiguration и Draw для первоначальной

расстановки шаров и изображения стола}

procedure Draw; {изображение бильярдного стола}

procedure Test; {проверка шаров на столкновение шаров между собой и со

стенками стола, направление движения шаров при этом изменяется, а также

проверка на попадание шаров в лузы}

procedure Solve; {выполняет перемещение шаров,

уменьшая скорость движения шаров; вызывает процедуру Test} destructor

Destroy; end;

Таким образом, используя механизм наполнения, в класс TBilliardTable

включены объектные поля Balls и Pockets

2.4 Отладка и тестирование программного продукта на уровне модулей

Тестирование и отладка идут рука об руку, так что большинство

программистов просто не воспринимают их как отдельные этапы разработки

программ. Однако путь к успеху лежит через разделение процесса отладки и

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

четко представлять себе, что цель тестирования — определить наличие (или

отсутствие) ошибок, В то время как цель отладки — определить

местоположение ошибок и устранить их. Поскольку цели этих  двух этапов

разработки программ различны, различны и используемые для этого методы

и инструменты. Создание надежного приложения 

    Лучший путь исключить ошибки в программе — защититься от них еще

при написании кода. Надежное приложение — приложение, создаваемое с

возможностью легко и просто отлаживать его. Вот основные советы, которые

помогут уменьшить количество ошибок при разработке программ.

Приложение должно быть хорошо организовано. Разделите программу на

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

если код, создающий отчет, разнесен по десяти модулям, время отладки

такого кода увеличится даже более чем в десять раз (хотя бы за счет поиска

нужной строки в десяти модулях). Конечно же, вы можете вызывать

подпрограммы из других модулей, но они должны быть созданы для

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

выполняемой операции в процедуре в одном модуле, а вторую половину— в

другой процедуре (тем более— в другом модуле). Если процедура не может

переварить некорректные данные и вызвать тем самым крах всей системы,

проверьте целостность входных данных, прежде чем работать с ними.

Однако помните: если системой сможет воспользоваться любой дурак,

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

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

для выполнения более важных задач.

Используйте отладочный вариант вашей программы. В отладочной версии

программы содержится дополнительный код, цель которого — отследить

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

отладку вашего приложения. Именно об этом и рассказывается в следующем

подразделе. Отладочная и коммерческая версии кода.    Те, кто участвовали в

"полевых испытаниях" (известных как бета-тестрирование) коммерческих

программ, наверняка обратили внимание, что такие версии программ более

медлительны, гораздо более "разговорчивы" и размером побольше

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

выпустил "сырой" продукт, который будет улучшать перед выпуском

окончательного варианта? Так тоже бывает, но главная причина в другом: в

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

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

    Delphi позволяет очень легко внести тестовый и отладочный коды в

приложение. Например, вы хотите создать приложение работы с базой

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

алгоритм сортировки данных. Как же убедиться в корректности его работы?

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

(быстрый, но рискованный, и медленный, но проверенный), затем сравнить

результаты работы обоих алгоритмов. Конечно же, этот вариант

используется только в бета-версии, и после всестороннего тестирования, если

все работает отлично и без сбоев, в конечной версии продукта останется

только быстрый (и после такого тестирования — уже не рискованный) метод

сортировки. 

Для этого вам вовсе не надо использовать два разных текста программ —

воспользуйтесь возможностью условного компилирования. Вы можете

определить символ (я обычно использую Debug, но вы свободны в вашем

выборе) для переключения между коммерческой и отладочной версиями

вашего кода с использованием директив $IFDEF, $IFNDEF, $ELSE и

$ENDIF. Вот пример использования "медленного" алгоритма в отладочной

версии.

DataSet:= GetData; //Получение данных для сортировки. 

    {$ifdef Debug} 

    TestResultSet:= Sort_Tortoise(DataSet); //Медленно и надежно. 

    {$endif} 

    ResultSet:= Sort_Hare(DataSet); //Быстро и рискованно. 

    {$ifdef Debug} 

    if not CompareData(ResultSet, TestResultSet) then 

        //Результаты совпали? 

    Raise Exception.Create('Сортировка в DataSorting некорректна'); 

    {$endif}

    Если определен символ Debug, код принимает следующий вид.

DataSet:= GetData; //Получение данных для сортировки. 

    TestResultSet:= Sort_Tortoise(DataSet); //Медленно и надежно. 

    ResultSet:= Sort Hare(DataSet); //Быстро и рискованно. 

    if not CompareData(ResultSet, TestResultSet) then 

        //Результаты совпали? 

    Raise Exception.Create('Сортировка в DataSorting некорректна');

    Если же символ Debug не определен при создании коммерческого

варианта программы, код вырождается в алгоритм быстрой сортировки без

дополнительных проверок

DataSet:= GetData; //Получение данных для сортировки. 

    Re5ultSet:= Sort_Hare(DataSet); //Быстро и рискованно.

    Как видите, использование условной компиляции — простои способ

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

определить символ условной компиляции двумя путями. Первый —

глобальное определение символа в опциях проекта. Выберите команду

Project/Options и в диалоговом окне Project Options, во вкладке

Directories/Conditionals, введите символ в поле Conditional defines. На рис 2.1

показано определение двух символов (Debug и Alpha) Щелкните на кнопке

ОК для подтверждения вашего ввода

Изменив символы условной компиляции, перекомпилируйте проект с

помощью команды Project/Build All для того, чтобы учесть внесенные

изменения. 

    Другой метод определения символа условной компиляции — вставить

в ваш исходный код директиву.

    {$define Debug}

    Вероятно, вы не захотите возиться с каждым файлом, входящим в проект,

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

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

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

директиву

    {$undef Debug}

    Она отключает действие директивы Debug до тех пор, пока не встретится

соответствующая директива $DEFINE или  конец текущего файла. Конечно,

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

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

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

приложения. Я говорю "могут", поскольку эти директивы могут внести

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

будьте осторожны при их применении. Эти опции перечислены во вкладке

Compiler диалогового окна Project Options, приведенного на рисунке.

 

Использование диалогового окна Project Options для определения символов

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

Ниже приведено описание этих опций.

Optimization. Эта опция управляет оптимизацией компилятора.

Рекомендуется оставить эту опцию включенной и выключать ее, если вы

полагаете, что оптимизация вносит ошибки в вашу программу. Управлять

оптимизацией локально вы можете с помощью директив компилятора $0+ и

$0-.

Stack Frames. Если эта установка включена, компилятор всегда

включает в функцию код для генерации кадра стека, даже если код не

использует стек. Как и в случае оптимизации, вам вряд ли стоит изменять эту

установку. Локальные директивы компилятора— $W-t и $W-.

Range Checking. Проверка диапазона перехватывает ошибки,

вызванные выходом за пределы массива или строки. Однако дополнительный

код сдерживает выполнение программы и, по всей видимости, вы отключите

эту опцию в коммерческой версии. Директивы компилятора для включения и

отключения проверки— $R+ и $R-.

Assertions (С). Эта опция более полно описана в следующем разделе.

Использование данного типа проверок позволяет быстро и просто добавить

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

эту возможность. Директивы компилятора— $С+ и $С-.

Overflow checking (Q). Проверка на переполнение позволяет

выяснить, не является ли результат выполнения целочисленной операции

слишком большим для размещения его в переменной. Подобно опции Range

Checking, данная опция полезна только при отладке, и в коммерческой

версии, как правило, отключается. Директивы компилятора— $Q+ и $Q-.

    Отладочная версия вашего кода, вероятно, будет больше по размеру и

медленнее коммерческой версии. Поэтому не передайте случайно конечному

пользователю отладочную версию!

Использование директивы Assert 

    Оператор Assert— новый оператор в Delphi 4. В действительности это

просто тест на логическую истину/ложь. При использовании этого оператора

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

выражение становится ложным, генерируется исключительная ситуация.

Синтаксис использования оператора таков:

Assert (<логическое выражение)

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

выяснения корректности параметров, как показано ниже.

    procedure Foo(Count: Cardinal); 

    begin 

        Assert(Count < SizeOf(Word)); 

    end.

Модульное тестирование 

    Тема модульного тестирования обширна и многообразна, и писать о ней

можно много, но я ограничусь буквально несколькими словами. Кстати,

когда речь идет о модульном тестировании, слово модуль не имеет

отношения к концепции модулей Delphi и подразумевает функцию,

подсистему или другой хорошо определенный программный модуль. 

    Коротко говоря, идея модульного тестирования состоит в разбивке

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

отдельности. Это часто означает написание одного или нескольких

небольших приложений-оболочек, цель создания которых — отработать

один из модулей вашего приложения. Ваша задача — выявить все

возможные ошибки, так как сообщения о внутренних ошибках программы,

допустимые в тестовых версиях, недопустимы в коммерческих. 

Настройка IDE для отладки.   Для работы со встроенным отладчиком Delphi

его интегрированная среда разработки (IDE) предлагает целую серию

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

есть (по умолчанию). Однако если вы все-таки решили изменить установки,

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

Environment Options щелкните на вкладке Preferences.    Ниже перечислены

опции вкладки Preferences и их функции.

Integrated Debugging. Позволяет включать и отключать встроенный

отладчик. Если вы отключите отладчик, отладочные команды в меню

Run станут недоступными.

Использование вкладки Preferences для настройки интегрированного

отладчика Delphi.

 

Step Program Block. Эта опция определяет, должен ли отладчик

останавливаться перед началом выполнения основного блока begin. . .

end при трассировке программы. Обычно данная опция отключена, и

включать ее имеет смысл при добавлении кода в основной блок

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

Hide Designers on Run. Когда эта опция включена, окно Object Inspector

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

программы на выполнение закрываются. Отключение опции позволяет

запускать программу быстрее, но эффект перекрывается

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

ли выбрана эта опция, зависит от пользователя.

Break on Exception. При включенной опции IDE всегда перехватывает

исключительные ситуации и выводит окно сообщения, даже если в

программе исключительная ситуация обрабатывается блоком

try. . .except. Включение этой опции упростит отладку, так как

выводимые сообщения при этом будут более информативными, чем

сообщения обработчика, установленные по умолчанию (сравните рис.

2.6 и 2.7). Помимо этого, IDE размещает окно редактора поверх

остальных и выделяет строку, вызвавшую исключительную ситуацию.

 

 

Сообщение об исключительной ситуации при включенной опции Break on

Exception

 

Включение в код отладочной информации .

    Перед началом отладки следует убедиться, что в приложение включена

отладочная информация Delphi. 

    Для компиляции проекта с отладочной информацией следует выполнить

команду Project/Options и в диалоговом окне Project Options выбрать вкладку

Compiler.

 

Окно редактора с отладочными значками

 

Вкладка Compiler диалогового окна Project Options

    Включение отладочной информации регулируется следующими

установками

Debug Information. Опция контролирует включение отладочной

информации. При отключении этой опции вы не сможете трассировать

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

эквивалентна директивам компилятора $D и $DEBUGINFO

Local Symbols. Опция контролирует включение информации о

локальных переменных, декларированных, например, внутри функций,

процедур и раздела implementation. Вряд ли у вас возникнет

необходимость в отключении этой опции, тем более что она

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

директивы компилятора— $L и $LOCALSYMBOLS.

Symbol Info. Эту опцию нельзя целиком отнести к разряду отладочных,

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

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

выводить информацию для объектов, определенных в модулях Опция

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

Эквивалентные директивы компилятора — $Y и $REFERENCEINFO

    Обычно вы будете включать опции Debug Information и Local Symbols для

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

можете отключить отладочную информацию для некоторых модулей (просто

используйте соответствующую директиву в начале модуля).

    unit MyUnit; 

    {$D-} 

    interface 

    ...

    Использование директивы $D- автоматически отключает опции Local

Symbols и Symbol Info, так что вам не надо отключать их отдельно.

Пошаговая отладка 

    Одна из самых распространенных задач отладки — выполнение

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

выполнения. При пошаговом прохождении кода отладчик выводит окно

редактирования с выполняемой программой. Точка выполнения,

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

в виде зеленой стрелки, расположенной слева от области исходного текста в

окне редактирования. 

    После успешной компиляции модуля на полосе отладочной информации

каждая строка кода, внесшая свой вклад в модуль, будет отмечена

маленьким, синим кружком. Если же строка не помечена, значит, здесь

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

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

    Интегрированная среда Delphi предоставляет пользователю несколько

команд пошаговой отладки доступных в меню Run (рис 2.10) 

 

 

Используйте меню Run для выполнения команд отладки

    Ниже перечислены команды отладки.

Run. Выбор этой команды запускает приложение на выполнение в

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

приложения, так и для продолжения его работы после какого-либо

прерывания выполнения (например, по точке останова). Если включена

опция Break on Exception, используйте команду для продолжения

работы после получения сообщения об исключительной ситуации

Step Over. Когда точка выполнения находится на строке содержащей

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

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

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

перемещается при выполнении на следующую строку

Trace Into. В отличие от предыдущей команды, эта опция отработает

пошаговую отладку вызываемых процедур и функций. Другими

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

выполнении этой команды точка выполнения перейдет на первую

строку процедуры. Однако если в строке нет таких вызовов, значит,

последние две команды идентичны. Будьте осторожны при пошаговой

трассировке обработчика события OnPaint. Поскольку при пошаговой

отладке окно редактора размещается поверх других окон, требуется

перерисовка окна приложения, для чего вызывается обработчик

события OnPaint... Вы попадаете в замкнутый круг, точнее— в

бесконечный цикл вызовов одного и того же обработчика. Тем не

менее, стоит лишь проследить, чтобы окна приложения и редактора не

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

Trace to Next Source Line. Иногда ваш код вызывает другой код

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

обработчик события, или при вызове функции Windows API, которая, в

свою очередь, запускает функцию косвенного вызова. Поскольку такие

вызовы косвенные, отладчик не видит вызова и не отслеживает

пошагового выполнения таких вызовов. Однако использование

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

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

функции или процедуры.

I Run to Cursor. Зачастую вам вовсе не хочется в поисках ошибки,

местоположение которой с какой-то точностью вам известно, пошагово

добираться до нужного места через сотни, а то и тысячи строк кода. В

таком случае просто поместите курсор на нужную вам строку

программы в окне редактирования и используйте команду Run to

Cursor. Эти действия эквивалентны временному помещению точки

останова в необходимую вам строку программы, и после выполнения

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

Show Execution Point. Эта команда заставляет среду разработки

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

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

закрыли или свернули окно редактора во время отладки (обычно при

нормальном состоянии окна отладчик делает это автоматически).

Program Pause. Выбор этой команды немедленно останавливает

выполнение программы. Она особенно полезна при зацикливании

программы.

Program Reset. Если вы достаточно "наотлаживались" и хотите

завершить работу своей программы или запустить ее заново,

используйте эту команду. Она немедленно прекратит выполнение

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

    Многие команды имеют связанные с ними комбинации клавиш, например

<F9 для Run. Однако назначения клавиш могут быть изменены во вкладке

Editor диалогового окна Options. Например, команде Step Over назначена

клавиша <F8, но при выборе назначений клавиш в стиле редактора BRIEF

назначенной комбинацией клавиш становится <Ctrl+Fl1. Помимо этого, на

панели инструментов есть кнопки, вызывающие некоторые из этих команд

(вы имеете возможность также удалить некоторые из них или добавить

новые).

Просмотр значений переменных.

    При пошаговом прохождении программы в отладчике вы, несомненно,

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

использовать окно просмотра переменных Watch List, которое предоставляет

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

переменных, или диалоговое окно Evaluate/Modify, позволяющее работать

только с одной переменной (в нем можно не только просмотреть, но и

изменить ее содержимое). 

    Для просмотра значения переменной используйте команду Run/AddWatch

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

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

Add Watch at Cursor. После этого появится диалоговое окно Watch Properties,

показанное на рис. 2.12. Введите имя переменной в поле Expression (если оно

не появилось там автоматически). Обратите внимание на то, что вы можете

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

х*(y+z). Единственное ограничение— выражение не может содержать

вызовов функций, поскольку это может вызвать побочный эффект,

связанный с незапланированным вызовом функции, описанный выше, в

подразделе ''Использование директивы Assert". Допускается также просмотр

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

    Поле Repeat Count используется в том случае, если у вас есть большой

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

значения элементов 826-833 следующего массива

    var 

        BigArray: array[1..1000] of Integer;

    Вы не можете просмотреть массив BigArray, так как 1 000 элементов

просто не поместятся в окне (да и пролистать ненужные вам 825 элементов

— работенка немалая!) Вместо этого вы просите показать вам значение

BigArray [826] и устанавливаете параметр Repeat Count равным 8. При этом

вам будут показаны значения восьми элементов массива— от 826 по 833. 

    Использование поля Digits позволяет определить количество значащих

цифр при выводе числа с плавающей точкой. 

    Отключенная опция Enabled предотвращает вывод значения переменной,

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

вы можете временно убрать с экрана информацию о переменной, которая в

настоящий момент вам не нужна, и быстро восстановить ее на экране при

необходимости без повторного ввода характеристик просмотра. 

    В диалоговом окне имеется также набор переключателей для выбора

способа представления переменной. Значение Default позволяет среде

разобраться с типом переменной самостоятельно. Как правило, такое

решение оптимально, однако в любой момент вы можете представить

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

Memory dump представляет информацию как набор байтов, что бывает

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

переменной. 

На рис отображены значения нескольких переменных в окне Watch List.

Кроме того, в некоторых случаях отладчик выводит информацию о

причинах, по которым содержимое переменной недоступно. 

 

 

Использование диалогового окна Watch Properties для добавления или

изменения набора переменных в окне просмотра.

Просмотр переменных.

    Смысл приведенных сообщений поясняется ниже

Variable 'X' inaccessible here due to optimization(Переменная 'X'

недоступна из-за оптимизации). В этой точке значение переменной

просмотреть невозможно (иногда это можно сделать в другом месте

программы), так как для нее не выделена память из-за оптимизации

программы компилятором.

Symbol was eliminated by linker (Переменная удалена компоновщиком).

Переменная удалена из кода программы компоновщиком, так как на

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

    Отладчик также выводит сообщение об ошибке, если имя переменной

написано неправильно, например вы запросили значение Foo [5], в то время

как переменная Foo массивом не является.

Диалоговое окно Evaluate/Modify 

    Для вывода диалогового окна Evaluate/Modify выберите команду

Run/Evaluate/Modify (рис 2.14). Другой способ вызова диалогового окна —

установить курсор в окне редактирования на необходимой вам переменной,

щелкнуть правой кнопкой мыши и в контекстном меню выбрать команду

Evaluate/Modify. 

    Введите выражение в поле Expression так же, как в диалоговом окне Watch

Properties (см рис 2.12). Затем щелкните на кнопке Evaluate для того, чтобы

увидеть результат в поле Result. Если выражение состоит только из имени

простой переменной (не массива или структуры!), можете ввести новое

значение для переменной в поле New Value и, щелкнув на кнопке Modify,

присвоить переменной новое значение. Это позволяет корректировать

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

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

возможность, найдя одну ошибку, искать другие, а исправлением первой

ошибки заняться чуть позже. 

 

 

Использование диалогового окна Evaluate/Modify для проверки изменения

отдельной переменной.

    Диалоговое окно Evaluate/Modify — немодальное, т. е. вы можете не

закрывать его, продолжая отладку. Однако учтите, что в отличие от окна

Watch List диалоговое окно Evaluate/Modify не отслеживает изменения

значений переменных и для получения информации о текущем состоянии

переменной вам необходимо воспользоваться кнопкой Evaluate. 

    Так же, как и окно Watch List, диалоговое окно Evaluate/Modify может

выводить сообщения об ошибках, если отладчик не в состоянии вывести

информацию о переменных. И точно так же не выводится информация о

выражениях, содержащих вызов функций. 

    Как видите, окно Watch List и диалоговое окно Evaluate/Modify очень

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

Обратите внимание на одно существенное отличие диалогового окна

Evaluate/Modify его вывод выполняется в поле с несколькими строками, а

потому оно более удобно для просмотра структур и объектов.

Установка точек останова 

    Точка останова (breakpoint) — своеобразный знак STOP для отладчика (на

полосе слева в окне редактора она и выглядит как маленький красный

значок). Когда ваше приложение запущено под отладчиком и доходит до

строки, в которой находится точка останова, оно прекращает работу и ждет

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

безусловными. Отладчик всегда останавливается на точке безусловного

останова и может останавливаться в точке условного останова, когда

выполнено условие. Интегрированный отладчик Delphi поддерживает два

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

оба типа. 

    Установить точки останова можно следующими способами:

Поместите курсор редактирования на выбранную строку программы и

нажмите клавишу команды Toggle Breakpoint (по умолчанию это

клавиша <F5>) для установки или удаления точки останова в этой

строке. То же самое можно выполнить и с помощью контекстного

меню.

Выберите команду Run/Add Breakpoint, и откроется диалоговое окно

Edit breakpoint (рис 2.15). Для установки простейшей точки останова

просто щелкните на кнопке New. Вы также можете использовать поля

Filename и Line Number для установки точек останова в другом файле

или строке за пределами текущей позиции курсора. Поля Condition и

Pass count используются для установки точки условного останова.

    После установки одной или нескольких точек останова можете

использовать окно Breakpoint List для управления ими. Для вызова окна

Breakpoint List выберите команду View/Breakpoints (рис. 2.16). В этом окне

можете щелкнуть на строке конкретной точки правой кнопкой мыши и в

контекстном меню отключить точку останова с помощью команды Disable

(вновь включить точку останова можно с помощью команды Enable) или

удалить ее с помощью команды Delete. Команды View Source и Edit Source

активизируют окно с текущим файлом исходного текста, при этом команда

Edit Source устанавливает курсор в строку с точкой останова. Команда

Properties выводит диалоговое окно Edit breakpoint, показанное на рис. 2.15,

позволяя тем самым изменять параметры точки останова.

 

 

Использование диалогового окна Edit breakpoint для установки новой точки

останова.

 

Использование окна Breakpoint list для управления точками останова.

    После щелчка правой кнопкой мыши в окне при невыбранной точке

останова выводится контекстное меню, в котором команда Add служит для

добавления новой точки, Delete All удаляет все точки останова, а команды

Disable All и Enable All отключают или включают все точки останова в

списке. 

    Для превращения безусловной точки останова в условную, необходимо

вызвать диалоговое окно Edit breakpoint (см. рис. 2.15) и ввести условное

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

    Условное выражение, введенное в поле Condition, может быть любым

логическим выражением. По достижении точки останова отладчик вычисляет

значение выражения и, если результат ложен, продолжает выполнение

программы. Если выражение истинно, выполнение программы

приостанавливается. Как обычно, выражение не должно использовать вызов

функции. Такие точки останова полезны, если вы можете попасть в

интересующий вас фрагмент кода различными путями, но вы хотите

остановить выполнение программы только при достижении каких-либо

конкретных условий. 

    Ненулевое значение, введенное в поле Pass count, дает отладчику задание

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

пока через нее не будет выполнено соответствующее количество проходов.

При каждом проходе через точку останова отладчик уменьшает значение

счетчика на единицу и по достижении нулевого значения программа

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

если вы знаете, что ошибка происходит после определенного количества

циклов. 

    Сейчас, когда вы изучили основы технологии отладки, вероятно, у вас

возникло желание поставить точку останова у себя в голове и поработать с

точками останова в программах. Кстати, один из отличных методов понять, 

как работает та или иная программа, — проследить за ее пошаговым

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

изменение переменных не изменяют текста программы, вы можете работать

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

целях приложение.    В предыдущих версиях Delphi для отладки библиотек

динамической компоновки требовался внешний отладчик (Turbo Debugger for

Windows). Delphi 4 внесла возможность отладки DLL в список своих

возможностей. Windows не может загрузить DLL без предварительной

загрузки использующего ее ЕХЕ, поэтому вам с начало придется набросать

простенькую программку, использующую интересующую вас DLL. В

главном меню выберите команду Run/Parameters для вывода диалогового

окна Run Parameters. Если текущий проект— DLL (DPR-файл начинается

ключевым словом library, а не program), поле Host Application будет

доступно, и в нем вам надо либо ввести имя использующей DLL программы,

либо выбрать его с помощью кнопки Browse. 

    После выбора приложения запуск и отладка DLL становятся обычной

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

программ, — установкой точек останова, просмотром значений переменных

и т.д.     Точно так же вы будете отлаживать и свои компоненты ActiveX, и

объекты автоматизации OLE.   Окно CPU предоставляет возможность

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

использовали отладчик Turbo Debugger for Windows, должны знать

возможности, предоставляемые таким окном. Эффективное его

использование предполагает знание ассемблера Intel x86 и архитектуры

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

пропустить этот раздел.   Окно CPU требуется крайне редко, но если в нем

возникла необходимость, значит, это действительно необходимость. Это —

ultima ratio, последний довод, и используется он в безвыходных положениях,

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

ошибки. Только в таких случаях окно CPU и проход по ассемблерным

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

ошибок. 

Чтобы использовать окно CPU необходимо его включить (по умолчанию оно

отключено). Для этого придется использовать программу RegEdit из поставки

Windows 95 (Windows NT). Запустите RegEdit и пробирайтесь по

иерархическому дереву папок. Сначала откройте папку

HKEY_CURRENT_USER. Во вложенной ветви зайдите в папку Software,

затем — в Borland, Delphi и, наконец, в 4. 

    Одна из папок называется Debugging. Щелкните на ней и, когда она

откроется, появится список пар Имя/Данные в окошке справа. Добавьте

новое значение с именем EnableCPU и значением 1. 

    При следующем запуске Delphi вы увидите новый подпункт меню

View/CPU Window. 

    Для вывода окна выберите View/CPU Window.Перечислим панели

Code pane Панель кода представляет дизассемблированный код в

окрестности текущей точки выполнения (если вы не отлаживаете

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

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

редактирования точка выполнения индицируется маленьким зеленым

значком. При пошаговом проходе значок точки выполнения синхронно

перемещается по окну CPU и окну редактирования.

Register pane. В панели регистров отображается содержимое 16

регистров процессора. Значения регистров, изменившиеся в результате

выполнения последней операции, выделены красным цветом.

Flags pane. Панель флагов показывает состояние 14 флагов процессора.

Установленный флаг представляется значением 1, сброшенный флаг

значением 0. В зависимости от процессора некоторые флаги могут

быть недоступными.

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

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

контекстного меню.

Data pane. По умолчанию в панели данных выводится содержимое

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

же, как и вид панели стека.

    Каждая из панелей в окне CPU имеет собственное контекстное меню. Вы

можете поэкспериментировать с пунктами меню и получить более полное

представление о возможностях манипулирования панелями.    Окна Thread

Status, Modules и Call Stack предоставляют дополнительную информацию,

которая может быть полезна при отладке приложения. 

    В окне Thread Status перечислены все активные подзадачи текущего

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

View/Threads, и на экране появится окно Thread Status.

    В четырех колонках окна представлена следующая информация:

Thread ID. Уникальный идентификатор подзадачи, присвоенный ей

операционной системой.

State. Состояние подзадачи, обычно — Running или Stopped. Если ваше

приложение запущено, но ожидает ввода от пользователя, состояние

выводится как Runnable.

Status. Статус подзадачи может иметь одно из четырех значений.

Breakpoint означает, что поток остановлен в точке останова. Stepped—

подзадача находится в режиме пошагового выполнения. Faulted—

остановка подзадачи из-за исключительной ситуации и Unknown —

статус неизвестен.

Location. В этой колонке выводится строка исходного кода,

соответствующего текущей точке выполнения подзадачи. Если

отладчик не в состоянии определить строку исходного текста,

выводится 32-битовый адрес точки выполнения.

    Если вами разработано приложение с несколькими подзадачами, и вы

хотите отладить одну из подзадач, можете сделать ее основной с помощью

окна Thread Status. Выберите подзадачу, которою вы хотите сделать текущей,

и щелкните на ней правой кнопкой мыши. Выберите из контекстного меню

команду Make Current. При этом фокус выполнения будет передан

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

контекстном меню окна содержатся две команды — View Source и Go to

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

выполнения другой подзадачи без передачи ей фокуса.  В окне Modules

отображаются все модели (ЕХЕ-файл вашего приложения и все

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

адресном пространстве приложения. В него входят непосредственно

подключенные DLL и библиотеки, подключенные через другие библиотеки, а

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

окно, изображенное на рис 2.18. выберите команду View/Modules. В окне

информация выводится в трех столбцах Name (имя модуля), Address (адрес

начала кода модуля) и Path (полный путь каталога, из которого был загружен

модуль). Информация о каталоге может быть важна, если возможна загрузка

модуля не из того каталога, из которого ожидалась, например, в более старой

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

CPU.    В этом окне представлен список всех функций и процедур,

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

приостановлена. Для открытия этого окна, показанного на рис 2.19,

используйте команду View/Call Stack.    В верхней строке окна выводится

имя текущей процедуры (DontHitMe в приведенном примере). В следующей

строке указывается имя процедуры, вызвавшей данную процедуру (Ouch) и

т.д. Это окно может быть очень полезным, когда надо определить, каким

путем вы достигли точки останова. Дополнительные возможности

предоставляет контекстное меню окна, которое можно вызвать, щелкнув

правой кнопкой мыши.

    Если вы используете соответствующую версию поставки Delphi 4, значит,

в нее входят исходные тексты VCL (Visi Component Library). В поставку VCL

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

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

трассировать код VCL, но если вы хотите убедиться, что ошибка не в VCL,

или посмотреть, как работает функция, придется перекомпилировать модули,

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

отладкой (brute-force debugging), отладкой "в лоб", понимаются методы

отладки, основанные не на возможностях отладчиков, а на трюках,

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

создававших первые ЭВМ по обе стороны океана.     При разработке

программ часто нет необходимости в полной отладке, просто хочется

убедиться в том, что какая-либо функция работает так, а не иначе (я весьма

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

функции API или плохо или вовсе недокументированные методы объектов, и

мне надо провести эксперимент, чтобы выяснить, так ли я представляю

работу функции). 

    В этих случаях проще забыть об отладчике и просто добавить пару строк

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

них будет рассказано ниже.

    Один из способов вывода такой информации — ее вывод непосредственно

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

для непосредственного вывода информации. В таком случае выведенная

информация не потеряется даже при перерисовке формы. 

    Посмотрите на описания функций ExtractFileDir и ExtractFilePath в

справочной системе Delphi 4. Я не берусь точно судить по документации о

различии между этими функциями, но я знаю, что мне делать. Я создаю

новое приложение (выбрав пункт меню File/New Application) и помещаю в

главную форму элемент TButton и два элемента TLabel (форма будет

выглядеть так, как на рис. 2.20). 

    Дважды щелкните на кнопке TButton и добавьте код к обработчику

события OnClick.

    procedure TFormI.ButtonlClick(Sender: TObject); 

    begin 

        Labell.Caption:= ExtractFileDir(Application.ExeName); 

        Label2.Caption:= ExtractFilePath(Application.ExeName); 

    end;

    (Application. ExeName возвращает полное имя файла приложения).

Нажмите клавишу <F9> для компиляции и запуска приложения и щелкните

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

функции. Недавно у меня возникла проблема с чужой DLL, исходного кода

которой я, естественно, не имел. Странным было то, что эта DLL выцелела

при загрузке и не освобождала большой фрагмент виртуальной памяти. Я

создал маленькое приложение, в котором после каждого щелчка на кнопке

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

предыдущие результаты, а потому, я использовал элемент управления

TMemo и добавлял в него новые строки с результатами.      Чтобы

посмотреть, как это делается, создадим новое приложение и разместим в

форме элементы управления TMemo и TButton (и не забудем установить

значение свойства TMemo.ScrollBars равным ssVertical).     В обработчик

события OnClick добавьте следующий код.

    procedure TFormI.ButtonlClick(Sender: TObject); 

    var 

        MemStat: TMemoryStatus; 

    begin 

        VirtualAlloc(nil, 1000000, MEM_RESERVE, PAGE_READWRITE);// 1 

        MemStat.dwLength:= SizeOf(TMemoryStatus);              // 2 

        GlobalMemoryStatus(MemStat);                            // 3 

        Memol.Lines.Add(IntToStr(MemStat.dwAvailVirtual));      // 4 

    end;

Не беспокойтесь о деталях вызова API-функции VirtualAlloc в строке 1. Здесь

ее вызов требует от операционной системы зарезервировать миллион байтов

памяти для дальнейшего использования. API-функция GlobalMemoryStatus

возвращает информацию об использовании памяти приложением и системой

в целом. Информация возвращается в переменной MemStat, представляющей

собой запись типа TMemoryStatus. Перед вызовом GlobalMemoryStatus вы

передаете системе информацию о размере структуры, как в строке 2, а затем

вызываете функцию (строка 3) и выводите информацию в TMemo в строке

4.   Скомпилируйте и запустите программу, щелкните несколько раз на

кнопке - и увидите, что виртуальная память уменьшается примерно на один

мегабайт при каждом щелчке, как и ожидалось. На рис. 2.23 показана форма

после нескольких щелчков на кнопке.    Кроме вывода информации в форму,

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

отличие этого метода, в первую очередь, состоит в том, что модальное

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

закроете. Таким образом, у вас имеется достаточно времени, чтобы прочесть

и осмыслить полученную информацию. 

    Процедура ShowMessage (из модуля Dialogs) идеально подходит для этой

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

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

ее процедуре (можно также использовать MessageDIg, но в нем слишком

много шашечек и бантиков, которые требуют немалых усилий для

достижения того же эффекта.

3. Графические инструменты в прикладном программировании

3.1 Графическая подсистема Delphi. Графические возможности Delphi

Delphi позволяет программисту разрабатывать программы, которые

могут выводить графику: схемы, чертежи, иллюстрации.

Программа выводит графику на поверхность объекта (формы или

компонента Image). Поверхности объекта соответствует свойство canvas. Для

того чтобы вывести на поверхность объекта графический элемент (прямую

линию, окружность, прямоугольник и т. д.), необходимо применить к

свойству canvas этого объекта соответствующий метод. Например,

инструкция Form1.Canvas.Rectangle (10,10,100,100) вычерчивает в окне

программы прямоугольник.

Холст

Как было сказано ранее, поверхности, на которую программа может

выводить графику, соответствует свойство Canvas. В свою очередь, свойство

canvas — это объект типа TCanvas. Методы этого типа обеспечивают вывод

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

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

примитивов: цвет, толщину и стиль линий; цвет и вид заполнения областей;

характеристики шрифта при выводе текстовой информации.

Методы вывода графических примитивов рассматривают свойство

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

могут рисовать (canvas переводится как "поверхность", "холст для

рисования"). Холст состоит из отдельных точек — пикселов. Положение

пиксела характеризуется его горизонтальной (X) и вертикальной (Y)

координатами. Левый верхний пиксел имеет координаты (0, 0). Координаты

возрастают сверху вниз и слева направо (рис. 10.1). Значения координат

правой нижней точки холста зависят от размера холста.

Размер холста можно получить, обратившись к свойствам Height и

width области ллюстрации (image) или к свойствам формы: ClientHeight и

Clientwidth. Карандаш и кисть. Художник в своей работе использует

карандаши и кисти. Методы, обеспечивающие вычерчивание на поверхности

холста графических примитивов, тоже

используют карандаш икисть. Карандаш применяется для вычерчивания

линий и контуров, а кисть — для закрашивания областей, ограниченных

контурами.

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

соответствуют свойства Реn (карандаш) и Brush (кисть), которые

представляют собой объекты типа треп и TBrush, соответственно. Значения

свойств этих объектов определяют вид выводимых графических элементов.

Карандаш используется для вычерчивания точек, линий, контуров

геометрических фигур: прямоугольников, окружностей, эллипсов, дуг и др.

Свойство Color задает цвет линии, вычерчиваемой карандашом. В табл. 10.2

перечислены именованные константы (тип TCoior), которые можно

использовать в качестве значения свойства color. Свойство width задает

толщину линии (в пикселах). Например, инструкция Canvas. Pen. width: =2

устанавливает толщину линии в 2 пиксела.

Свойство style определяет вид (стиль) линии, которая может быть

непрерывной или прерывистой, состоящей из штрихов различной длины. В

табл. 10.3 перечислены именованные константы, позволяющие задать стиль

линии. Толщина пунктирной линии не может быть больше 1. Если значение

свойства Pen.width больше единицы, то пунктирная линия будет выведена

как сплошная.

Свойство Mode определяет, как будет формироваться цвет точек линии в

зависимости от цвета точек холста, через которые эта линия прочерчивается.

По умолчанию вся линия вычерчивается цветом, определяемым значением

свойства Pen.Color.Однако программист может задать инверсный цвет линии

по отношению к цвету фона. Это гарантирует, что независимо от цвета фона

все участки линии будут видны, даже в том случае, если цвет линии и цвет

фона совпадают.Кисть (canvas.Brush) используется методами,

обеспечивающими вычерчивание замкнутых областей, например

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

объект, обладает двумя свойствами, перечисленными в табл. 10.5.

Область внутри контура может быть закрашена или заштрихована. В первом

случае область полностью перекрывает фон, а во втором — сквозь

незаштрихованные участки области будет виден фон. В качестве значения

свойства Color можно использовать любую из констант типа TColor .

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

свойства Font соответствующего объекта canvas. Свойство Font представляет

собой объект типа TFont. В табл. 10.7 перечислены свойства объекта TFont,

позволяющие задать характеристики шрифта, используемого методами

TextOut и TextRect для вывода текста.

Область вывода текста закрашивается текущим цветом кисти. Поэтому перед

выводом текста свойству Brush.Color нужно присвоить значение bsClear или

задать цвет кисти, совпадающий с цветом поверхности, на которую

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

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

with Form1.Canvas do begin

// установить характеристики шрифта

Font.Name := 'Tahoma';

Font.Size := 20;

Font.Style := [fsltalic, fsBold] ;

Brush.Style := bsClear; // область вывода текста не закраши-

TextOut(0, 10, 'Borland Delphi 7');

end;

После вывода текста методом Textout указатель вывода (карандаш)

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

Иногда требуется вывести какой-либо текст после сообщения, длина

которого во время разработки программы неизвестна. Например, это может

быть слово "руб." после значения числа, записанного прописью. В этом

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

текста. Координаты правой границы текста, выведенного методом Textout,

можно получить, обратившись к свойству PenPos.Следующий фрагмент

программы демонстрирует возможность вывода строки текста при помощи

двух инструкций Textout.

with Form1.Canvas do begin

TextOut(0, 10, 'Borland ') ;

TextOut(PenPos.X, PenPos.Y, 'Delphi 7');

end;

Любая картинка, чертеж, схема могут рассматриваться как совокупность

графических примитивов:  точек, линий, окружностей, дуг и др. Таким

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

должна обеспечить вычерчивание (вывод) графических примитивов,

составляющих эту картинку.

Вычерчивание графических примитивов на поверхности компонента

(формы или области вывода иллюстрации) осуществляется применением

соответствующих методов к свойству Canvas этого компонента.

Вычерчивание прямой линии осуществляет метод LinеТо, инструкция

вызова которого в общем виде выглядит следующим образом:

Компонент.Canvas.LineTo(x,у)

Метод LinеТо вычерчивает прямую линию от текущей позиции

карандаша в точку с координатами, указанными при вызове метода.

Начальную точку линии можно задать, переместив карандаш в нужную

точку графической поверхности. Сделать это можно при помощи метода

MoveTo, указав в качестве параметров координаты нового положения

карандаша.

Вид линии (цвет, толщина и стиль) определяется значениями свойств объекта

Реп графической поверхности, на которой вычерчивается линия.

Довольно часто результаты расчетов удобно представить в виде графика. Для

большей информативности и наглядности графики изображают на фоне

координатных осей и оцифрованной сетки. Особенность приведенной

программы заключается в том, что она позволяет задавать шаг сетки и

оцифровку. Кроме того, программа дает возможность оцифровывать не

каждую линию сетки оси х, а через одну, две, три и т. д. Сделано это для

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

оцифровки друг на друга в случае, если эти числа состоят из нескольких

цифр.

Метод polyline вычерчивает ломаную линию. В качестве параметра метод

получает массив типа TPoint. Каждый элемент массива представляет собой

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

Метод Polyline вычерчивает ломаную линию, последовательно соединяя

прямыми точки, координаты которых находятся в массиве: первую со

второй, вторую с третьей, третью с четвертой и т. д.

В качестве примера использования метода Polyline в листинге 10.3 приведена

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

Предполагается, что исходные данные находятся в доступном процедуре

массиве Data (тип Integer).Метод Polyline можно использовать для

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

последний элементы массива содержали координаты одной и той же точки. В

качестве примера использования метода Polybine для вычерчивания

замкнутого контура в листинге 10.4 приведена программа, которая на

поверхности диалогового окна, в точке нажатия кнопки мыши, вычерчивает

контур пятиконечной звезды (рис. 10.5). Цвет, которым вычерчивается

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

обработки нажатия кнопки мыши (событие MouseDown) вызывает процедуру

рисования звезды starLine и передает ей в качестве параметра координаты

точки, в которой была нажата кнопка. Звезду вычерчивает процедура

starLine, которая в качестве параметров получает координаты центра звезды

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

координаты концов и впадин звезды, которые записываются в массив р.

Затем этот массив передается в качестве параметра методу Polyline. При

вычислении координат лучей и впадин звезды используются функции sin и

cos. Так как аргумент этих функций должен быть выражен в радианах, то

значение угла в градусах домножается на величину pi/18о, где pi — это

стандартная именованная константа равная числу л.

Окружность и эллипс

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

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

следующим образом:

Объект.Canvas.Ellipse(x1,y1, х2,у2]

где:

объект — имя объекта (компонента), на поверхности которого

выполняется вычерчивание;

x1, y1, х2, у2 — координаты прямоугольника, внутри которого

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

окружность (рис. 10.6).

Цвет, толщина и стиль линии эллипса определяются значениями

свойства Реп, а цвет и стиль заливки области внутри эллипса — значениями

свойства Brush поверхности (canvas), на которую выполняется

вывод.Вычерчивание дуги выполняет метод Arc, инструкция вызова

которого в общем виде выглядит следующим образом:

Объект.Canvas.Arc(x1,y1,х2,у2,х3,у3,х4,у4)

где:

x1, y1, х2, у2 — параметры, определяющие эллипс (окружность),

частью которого является вычерчиваемая дуга;

х3, у3 — параметры, определяющие начальную точку дуги; П х4, у4 —

параметры, определяющие конечную точку дуги.

Начальная (конечная) точка — это точка пересечения границы эллипса

и прямой, проведенной из центра эллипса в точку с координатами х3 и у3

(х4, у4). Дуга вычерчивается против часовой стрелки от начальной точки к

конечной (рис. 10.7).

Цвет, толщина и стиль линии, которой вычерчивается дуга,

определяются значениями свойства Реп поверхности (canvas), на которую

выполняется вывод.

Прямоугольник вычерчивается методом Rectangle, инструкция вызова

которого в общем виде выглядит следующим образом:

Объект.Canvas.Rectangle(x1, y1,x2, y2)

где:

объект — имя объекта (компонента), на поверхности которого

выполняется вычерчивание;

x1, y1 и х2, у2 — координаты левого верхнего и правого нижнего углов

прямоугольника.

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

углами. Инструкция вызова метода RoundRec выглядит так:

Объект.Canvas.RoundRec(x1,y1,х2, у2, х3, у3)

где:

x1, y1, х2, у2 -- параметры, определяющие положение углов

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

скругленными углами;

х3 и у3 — размер эллипса, одна четверть которого используется для

вычерчивания скругленного угла.

Вид линии контура (цвет, ширина и стиль) определяется значениями

свойства Реп, а цвет и стиль заливки области внутри прямоугольника —

значениями свойства Brush поверхности (canvas), на которой прямоугольник

вычерчивается.

Есть еще два метода, которые вычерчивают прямоугольник, используя в

качестве инструмента только кисть (Brush). Метод FillRect вычерчивает

закрашенный прямоугольник, а метод FrameRect — только контур. У

каждого из этих методов лишь один параметр — структура типа TRect. Поля

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

быть заполнены при помощи функции Rect.Ниже в качестве примера

использования методов FillRect и FrameRect приведена процедура, которая на

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

прямоугольник с зеленым контуром.

Метод Polygon вычерчивает многоугольник. В качестве параметра метод

получает массив типа TPoint. Каждый элемент массива представляет собой

запись, поля (х,у) которой содержат координаты одной вершины

многоугольника. Метод Polygon вычерчивает многоугольник,

последовательно соединяя прямыми линиями точки, координаты которых

находятся в массиве: первую со второй, вторую с третьей, третью с четвертой

и т. д. Затем соединяются последняя и первая точки.

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

Реп, а цвет и стиль заливки области, ограниченной линией границы, —

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

текущего цвета и стиля кисти.

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

треугольник:

Метод pie вычерчивает сектор эллипса или круга. Инструкция вызова

метода в общем виде выглядит следующим образом:

Объект. Canvas.Pie(x1,y1,x2,y2,х3,у3,х4,у4)

где:

x1, y1, х2, у2 — параметры, определяющие эллипс (окружность),

частью которого является сектор;

х3, у3, х4, у4 — параметры, определяющие координаты конечных

точек прямых, являющихся границами сектора.

Начальные точки прямых совпадают с центром эллипса (окружности).

Сектор вырезается против часовой стрелки от прямой, заданной точкой с

координатами (хЗ, уз), к прямой, заданной точкой с координатами (х4, у4)

(рис. 10.9).

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

графики, соответствует объект Canvas. Свойство pixels, представляющее

собой двумерный массив типа TColor, содержит информацию о цвете каждой

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

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

"нарисовать" точку. Например, инструкция

Form1.Canvas.Pixels[10,10]:=clRed окрашивает точку поверхности формы в

красный цвет. Размерность массива pixels определяется размером

графической поверхности. Размер графической поверхности формы (рабочей

области, которую также называют клиентской)задается значениями свойств

ciientwidth и ClientHeight, а размер графической поверхности компонента

image — значениями свойств width и Height. Левой верхней точке рабочей

области формы соответствует элемент pixels [0,0], а правой нижней -

Pixels[Ciientwidth - 1,ClientHeight - 1].

Свойство Pixels можно использовать для построения графиков. График

строится, как правило, на основе вычислений по формуле. Границы

диапазона изменения аргумента функции являются исходными данными.

Диапазон изменения значения функции может быть вычислен. На основании

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

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

вывода графика.

Например, если некоторая функция f(x) может принимать значения от нуля

до 1000, и для вывода ее графика используется область формы высотой в 250

пикселов, то масштаб оси Y вычисляется по формуле: т = 250/1000. Таким

образом, значению f(x) = 70 будет соответствовать точка с

координатой Y =233. Значение координаты Y вычислено по формуле Y= h -

f(x) х т = 250 - 70х(250/1000), где h - высота области построения графика.

Обратите внимание на то, что точное значение выражения 250 -

70х(250/1000) равно 232,5. Но т. к. индексом свойства pixels, которое

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

целое значение, то число 232,5 округляется к ближайшему целому, которым

является число 233.

Следующая программа, текст которой приведен в листинге 10.5, используя

свойство pixels, выводит график функции у = 2 sin(jc) e*/5. Для построения

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

работы программы пользователь изменит размер окна, то график будет

выведен заново с учетом реальных размеров окна.

Основную работу выполняет процедура GrOfFunc, которая сначала

вычисляет максимальное (у2) и минимальное (yl) значения функции на

отрезке [x1l,x2]. Затем, используя информацию о ширине (Forml.Clientwidth -

40) и высоте (Form1.ClientHeight - 40) области вывода графика, вычисляет

масштаб по осям X (mх) иY(mу).

Высота и ширина области вывода графика определяется размерами рабочей

(клиентской) области формы, т. е. без учета области заголовка и границ.

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

горизонтальной оси (уо) и вычерчивает координатные оси графика. Затем

выполняется непосредственное построение графика (рис. 10.10).

Вызов процедуры GrOfFunc выполняют процедуры обработки событий

onPaint и onFormResize. Процедура TForm1. FormPaint обеспечивает

вычерчивание графика после появления формы на экране в результате

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

программы, например, в результате удаления или перемещения других окон,

полностью или частично перекрывающих окно программы. Процедура

TForm1.FormResize обеспечивает вычерчивание графика после изменения

размера формы.

Приведенная программа довольно универсальна. Заменив инструкции в

теле функции f (х), можно получить график другой функции. Причем

независимо от вида функции ее график будет занимать всю область,

предназначенную для вывода.

Рассмотренная программа работает корректно, если функция, график

которой надо построить, принимает как положительные, так и отрицательные

значения. Если функция во всем диапазоне только положительная или только

отрицательная, то в программу следует внести изменения. Какие — пусть это

будет упражнением для читателя.

Вывод иллюстраций

Наиболее просто вывести иллюстрацию, которая находится в файле с

расширением bmp, jpg или ico, можно при помощи компонента image, значок

которого находится на вкладкеAdditional палитры.

Во время разработки формы иллюстрация задается установкой значения

свойства picture путем выбора файла иллюстрации в стандартном диалоговом

окне, которое появляется в результате щелчка на командной

кнопке Load окна Picture Editor (рис. 10.12). Чтобы запустить Image Editor,

нужно в окне Object Inspector выбрать свойство Picture и щелкнуть на кнопке

с тремя точками.

Если размер иллюстрации больше размера компонента, то свойству strech

нужно присвоить значение True и установить значения свойств width и Height

пропорционально реальным размерам иллюстрации.

Чтобы вывести иллюстрацию в поле компонента image во время работы

программы, нужно применить метод LoadFromFile к свойству Picture, указав

в качестве параметра имя файла иллюстрации. Например, инструкция

Form1.Image1.Picture.LoadFromFile('e:\temp\bart.bmp')

загружает иллюстрацию из файла bart.bmp и выводит ее в поле вывода

иллюстрации (imagel).

Метод LoadFromFile позволяет отображать иллюстрации различных

графических форматов: BMP, WMF, JPEG (файлы с расширением jpg).

Битовые образы

При работе с графикой удобно использовать объекты типа TBitMap

(битовый образ). Битовый образ представляет собой находящуюся в памяти

компьютера, и, следовательно, невидимую графическую поверхность, на

которой программа может сформировать изображение. Содержимое битового

образа (картинка) легко и, что особенно важно, быстро может быть выведено

на поверхность формы или области вывода иллюстрации (image). Поэтому в

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

изображений, например, картинок командных кнопок.

Загрузить в битовый образ нужную картинку можно при помощи метода

LoadFromFlie, указав в качестве параметра имя BMP-файла, в котором

находится нужная иллюстрация.

Например, если в программе объявлена переменная pic типа TBitMap, то

после выполнения инструкции pic.LoadFromFiie('е:\images\aplane.bmp')

битовый образ pic будет содержать изображение самолета. Вывести

содержимое битового образа (картинку) на поверхность формы или области

вывода иллюстрации можно путем применения метода Draw к

соответствующему свойству поверхности (canvas). Например, инструкция

Image1.Canvas.Draw(x,у, bm) выводит картинку битового образа bm на

поверхность компонента image 1 (параметры х и у определяют положение

левого верхнего угла картинки на поверхности компонента).

Если перед применением метода Draw свойству Transparent объекта

TBitMap присвоить значение True, то фрагменты рисунка, окрашенные

цветом, совпадающим с цветом левого нижнего угла картинки, не будут

выве-

дены — через них будет как бы проглядывать фон. Если в качестве

"прозрачного" нужно использовать цвет, отличный от цвета левой нижней

точки рисунка, то свойству Transparentcoior следует присвоить значение

символьной константы, обозначающей необходимый цвет.

Следующая программа, текст которой приведен в листинге 10.7,

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

изображения из нескольких элементов.

После запуска программы в окне приложения (рис. 10.14) появляется

изображение летящих на фоне неба самолетов. Фон и изображение самолета -

битовые образы, загружаемые из файлов. Белое поле вокруг левого самолета

показывает истинный размер картинки битового образа aplane. Белое поле

вокруг правого самолета отсутствует, т. к. перед его выводом свойству

Transparent битового образа было присвоено значение True.

Мультипликация.

Под мультипликацией обычно понимается движущийся и меняющийся

рисунок. В простейшем случае рисунок может только двигаться или только

меняться.

Как было показано выше, рисунок может быть сформирован из графических

примитивов (линий, окружностей, дуг, многоугольников и т. д.). Обеспечить

перемещение рисунка довольно просто: надо сначала вывести рисунок на

экран, затем через некоторое время стереть его и снова вывести этот же

рисунок, но уже на некотором расстоянии от его первоначального

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

расстояния между старым и новым положением рисунка (шага

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

впечатление, что рисунок равномерно движется по экрану.

Основную работу выполняет процедура Ris, которая стирает окружность

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

перерисовки окружности поверх нарисованной, но цветом фона.

Для обеспечения периодического вызова процедуры Ris в форму

программы добавлен невизуальный компонент Timer (таймер), значок

которого находится на вкладке System палитры компонентов.

Добавляется компонент Timer к форме обычным образом, однако,

поскольку компонент Timer является невизуальным, т. е. во время работы

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

место формы. Компонент Timer генерирует событие OnTimer. Период

возникновения события OnTimer измеряется в миллисекундах и определяется

значением свойства Interval. Следует обратить внимание на свойство Enabled.

Оно дает возможность программе "запустить" или "остановить" таймер. Если

значение свойства Enabled равно False, то событие OnTimer не возникает.

Событие onTimer в рассматриваемой программе обрабатывается процедурой

TimeriTimer, которая, в свою очередь, вызывает процедуру Ris. Таким

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

процедуры Ris.

Переменные х, у (координаты центра окружности) и dx (приращение

координаты х при движении окружности) объявлены вне процедуры Ris, т. е.

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

инициализацию (в программе инициализацию глобальных переменных

реализует процедура FormActivate). При программировании сложных

изображений, состоящих из множества элементов, используется метод,

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

в следующем:

1. Выбирается некоторая точка изображения, которая принимается за

базовую.

2. Координаты остальных точек отсчитываются от базовой точки.

3. Если координаты точек изображения отсчитывать от базовой в

относительных единицах, а не в пикселах, то обеспечивается возможность

масштабирования изображения.

На рис. 10.17 приведено изображение кораблика. Базовой точкой

является точка с координатами (X0 Y0). Координаты остальных точек

отсчитываются именно от этой точки.

Отрисовку и стирание изображения кораблика выполняет процедура

Titanik, которая получает в качестве параметров координаты базовой точки и

цвет, которым надо вычертить изображение кораблика. Если при вызове

процедуры цвет отличается от цвета фона формы, то процедура рисует

кораблик, а если совпадает — то "стирает". В процедуре Titanik объявлены

константы dx и dy, определяющие шаг (в пикселах), используемый при

вычислении координат точек изображения. Меняя значения этих констант,

можно проводить масштабирование изображения.

В предыдущем примере изображение формировалось из графических

примитивов. Теперь рассмотрим, как можно реализовать перемещение

одного сложного изображения на фоне другого, например перемещение

самолета на фоне городского пейзажа. Эффект перемещения картинки

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

смещением относительно ее прежнего положения. При этом предполагается,

что перед выводом картинки в новой точке сначала удаляется предыдущее

изображение. Удаление картинки может быть выполнено путем перерисовки

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

образом движущегося объекта. В рассматриваемой программе используется

второй подход. Картинка выводится применением метода Draw к свойству

canvas компонента Image, a стирается путем копирования (метод copyRect)

нужной части фона из буфера на поверхность компонента Image.

Для хранения битовых образов (картинок) фона и самолета, а также

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

объекты типа TBitMap, которые создаются динамически процедурой

FormActivate. Эта же процедура загружает из файлов картинки фона

(factory.bmp) и самолета (aplane.bmp), а также сохраняет область фона, на

которую первый раз будет накладываться картинка. Сохранение копии фона

выполняется при помощи метода CopyRect, который позволяет выполнить

копирование прямоугольного фрагмента одного битового образа в другой.

Объект, к которому применяется метод CopyRect, является приемником

копии битового образа. В качестве параметров методу передаются

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

поверхность, откуда должно быть выполнено копирование, а также

положение и размер копируемой области. Информация о положении и

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

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

из буфера, находится в структуре BackRct типа TRect. Для заполнения этой

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

что начальное значение переменной х, которая определяет положение левой

верхней точки битового образа движущейся картинки, — отрицательное

число, равное ширине битового образа картинки. Поэтому в начале работы

программы изображение самолета не появляется, картинка отрисовывается за

границей видимой области. С каждым событием OnTimer значение

координаты х увеличивается, и на экране появляется та часть битового

образа, координаты которой больше нуля. Таким образом, у наблюдателя

создается впечатление, что самолет вылетает из-за левой границы окна.

3.2 Анимация и мультимедиа в прикладном программировании.

Мультимедиа-возможности Delphi

Большинство современных программ, работающих в среде Windows,

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

видеороликов и мультипликации, воспроизведение музыки, речи, звуковых

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

и обучающие программы.

Delphi предоставляет в распоряжение программиста два компонента, которые

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

Animate — обеспечивает вывод простой анимации (подобной той,

которую видит пользователь во время копирования файлов);

MediaPlayer — позволяет решать более сложные задачи, например,

воспроизводить видеоролики, звук, сопровождаемую звуком

анимацию.

Хотя анимация, находящаяся в AVI-файле может сопровождаться звуковыми

эффектами (так ли это — можно проверить, например, при помощи

стандартной программы Проигрыватель Windows Media), компонент Animate

обеспечивает воспроизведение только изображения. Для полноценного

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

компонент меdiaPlayer.

Компонент Animate добавляется к форме обычным образом. После

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

Свойства компонента Animate перечислены в табл.

Таблица Свойства компонента Animate

Свойство Определяет

Name Имя компонента. Используется для доступа к свойствам

компонента и управлением его поведением

FileName Имя AVI-файла в котором находится анимация,

отображаемая при помощи компонента

StartFrame Номер кадра, с которого начинается отображение анимации

stopFrame Номер кадра, на котором заканчивается отображение

анимации

Activate Признак активизации процесса отображения кадров

анимации

Color Цвет фона компонента (цвет "экрана"), на котором

воспроизводится анимация

Transparent Режим использования "прозрачного" цвета при отображении

анимации

Repetitions Количество повторов отображения анимации

Следует еще раз обратить внимание, что компонент Animate предназначен

для воспроизведения AVI-файлов, которые содержат только анимацию. При

попытке присвоить записать в свойство FileName имя файла, который

содержит звук, Delphi выводит сообщение о невозможности открытия

указанного файла (Cannot open AVI). Чтобы увидеть, что находиться в AVI-

файле: анимация и звук или только анимация, нужно из Windows раскрыть

нужную папку, выделить AVI-файл и из контекстного меню выбрать

команду Свойства. В результате этого откроется окно Свойства, на

вкладке Сводка которого будет выведена подробная информация о

содержимом выбранного файла.

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

Программа обеспечивает два режима просмотра анимации: непрерывный и

покадровый.

Кнопка Button1 используется как для инициализации процесса

воспроизведения анимации, так и для его приостановки. Процесс

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

события Onclick на кнопке Пуск, которая присваивает значение True

свойству Active. Эта же процедура заменяет текст на кнопке Button1 с Пуск

на Стоп. Режим воспроизведения анимации выбирается при помощи

переключателей Ra-dioButton1 и RadioButton2. Процедуры обработки

события Onclick на этих переключателях изменением значения свойства

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

активизации воспроизведения анимации (Buttoni), перехода к следующему

(Button2) и предыдущему (Buttons) кадру. Во время непрерывного

воспроизведения анимации процедура обработки события OnCkick на кнопке

Стоп (Buttoni) присваивает значение False свойству Active и тем самым

останавливает процесс воспроизведения анимации.

Компонент Animate позволяет программисту использовать в своих

программах стандартные анимации Windows. Вид анимации определяется

значением свойства СommonAVI. Значение свойства задается при помощи

именованной константы.

Компонент MediaPlayer, значок которого находится на вкладке System,

позволяет воспроизводить видеоролики, звук и сопровождаемую звуком

анимацию.

В результате добавления к форме компонента MediaPlayer на форме

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

аудио- или видеоплеере.

Воспроизведение звука

Звуковые фрагменты находятся в файлах с расширением WAV.

Например, в каталоге C:\Winnt\Media можно найти файлы со стандартными

звуками Windows.

Помимо компонента MediaPiayer на форме находится компонент

ListBox и два компонента Label, первый из которых используется для вывода

информационного сообщения, второй — для отображения имени WAV-

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

Работает программа следующим образом. После появления диалогового

окна воспроизводится "Звук Microsoft", затем пользователь может из списка

выбрать любой из находящихся в каталоге C:\Windows\Media звуковых

файлов и после щелчка на кнопке Воспроизведение услышать, что находится

в этом файле.

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

процедура обработки события onFormActivate путем применением метода

Play к компоненту MediaPlayerl (действие этого метода аналогично щелчку

на кнопке Воспроизведение). Эта же процедура формирует список WAV-

файлов, находящихся в каталоге C:\Winnt\Media. Для формирования списка

используются функции FindFirst и FindNext, которые, соответственно,

выполняют поиск первого и следующего (по отношению к последнему,

найденному функцией FindFirst или FindNext) файла, удовлетворяющего

указанному при вызове функций критерию. Обеим функциям в качестве

параметров передаются маска WAV-файла (критерий поиска) и переменная -

структура searchRec, поле Name которой в случае успешного поиска будет

содержать имя файла, удовлетворяющего критерию поиска.

Щелчок на элементе списка обрабатывается процедурой

TForm1.ListBox1Click, которая выводит в поле метки Label2 имя файла,

выбранного пользователем (во время работы программы свойство ItemIndex

содержит номер элемента списка на котором выполнен щелчок).

В результате щелчка на одной из кнопок компонента MediaPiayeri

активизируется процедура TForm1.MediaPiayer1Сlick, которая проверяет,

какая из кнопок компонента была нажата. Если нажата

кнопка Воспроизведение (btPlay), то в

свойство FileName компонента MediaPiayeri записывается имя выбранного

пользователем файла, затем метод open загружает этот файл и активизирует

процесс его воспроизведения.

Наличие у компонента MediaPiayer свойства visible позволяет скрыть

компонент от пользователя и при этом применять его для воспроизведения

звука без участия пользователя. Например, следующая программа

пересчитывает вес из фунтов в килограммы и сопровождает выдачу

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

исходные данные или введет их неверно, программа выведет сообщение об

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

Запись звука

В некоторых случаях программисту могут потребоваться специфические

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

компьютера в виде WAV-файла. В этом случае возникает задача создания,

или, как говорят, записи WAV-файла.

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

в виде WAV-файла можно при помощи входящей в состав Windows

программы Звукозапись. ПрограммаЗвукозапись, вид ее диалогового окна

приведен на рис. 11.8, запускается из главного меню Windows при помощи

команды Пуск | Программы | Стандартные | Развлечения | Звукозапись.

Источником звука для программы Звукозапись может быть микрофон,

аудио-CD или любое другое подключенное к линейному входу звуковой

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

возможно микширование (смешение) звуков различных источников.

Создается WAV-файл следующим образом. Сначала нужно определить

источник (или источники) звука. Чтобы это сделать, надо открыть Регулятор

громкости (для этого надо щелкнуть на находящемся на панели задач

изображении динамика и из появившегося меню выбрать команду Регулятор

громкости) и из меню Параметры выбрать командуСвойства. Затем в

появившемся окне Свойства (рис. 11.9) выбрать переключатель Запись и в

списке Отображаемые регуляторы громкости установить флажки,

соответствующие тем устройствам, сигнал с которых нужно записать. После

щелчка на кнопке ОК на экране появляется окно Уровень записи (рис. 11.10),

используя которое, можно управлять уровнем сигнала (громкостью) каждого

источника звука в общем звуке и величиной общего, суммарного сигнала,

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

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

внимание на то, что движки регуляторов группы Уровень доступны только

во время процесса записи звука. На этом подготовительные действия

заканчиваются. Теперь можно приступить непосредственно к записи звука.

Чтобы записать музыкальный или речевой фрагмент, надо запустить

программу Звукозапись, активизировать диалоговое окно Уровень, выбрать

устройство-источник звука, инициировать процесс звучания (если запись

осуществляется, например с CD) и в нужный момент времени щелкнуть на

кнопке Запись.

Во время записи в диалоговых окнах можно наблюдать изменение сигнала на

выходе микшера (индикатор Громкость диалогового окна Уровень) и на

входе программы записи.

Для остановки процесса записи следует щелкнуть на кнопке Стоп.

Сохраняется записанный фрагмент в файле обычным образом, т. е. выбором

из меню Файл команды Сохранить или Сохранить как. При выборе

команды Сохранить как можно выбрать формат, в котором будет сохранен

записанный звуковой фрагмент.

Существует несколько форматов звуковых файлов. В частности,

возможно сохранение звука с различным качеством как стерео, так и моно.

Здесь следует понимать, что чем выше качество записи, тем больше места на

диске компьютера требуется для хранения соответствующего WAV-файла.

Считается, что для речи приемлемым является формат "22050 Гц, 8 бит,

моно", а музыки - "44100 Гц, 16 бит, моно" или "44100 Гц, 16 бит, стерео".

Просмотр видеороликов и анимации.

Помимо воспроизведения звука, компонент MediaPiayer позволяет

просматривать видеоролики и мультипликации, представленные как AVI-

файлы (AVI — это сокращение от Audio Video Interleave, что переводится как

чередование звука и видео, т. е. AVI-файл содержит как звуковую, так и

видеоинформацию) .

Процесс использования компонента MediaPiaer для посмотра содержимого

AVI-файла рассмотрим на примере программы, которая в результате щелчка

на командной кнопке воспроизводит на поверхности формы простую

сопровождаемую звуковым эффектом мультипликацию — вращающееся по

часовой стрелке слово Delphi (файл delphi.avi, содержащий этот мультик,

находится на прилагаемом к книге диске).

Создается форма приложения обычным образом. Компонент Paneii

используется в качестве экрана, на который осуществляется вывод анимации,

и его имя принимается в качестве значения свойства Display компонента

MediaPlayeri. Поэтому сначала к форме лучше добавить компонент Panel и

затем — MediaPlayer. Такой порядок создания формы позволяет установить

значение свойства Display путем выбора из списка.

Следует особо обратить внимание на то, что размер области вывода

анимации на панели определяется не значениями свойств width и Height

панели (хотя их значения должны быть как минимум такими же, как ширина

и высота анимации). Размер области определяется значением свойства

DisplayRect компонента MediaPlayer. Свойство DisplayRect ВО время

разработки программы недоступно (его значение не выводится в окне Object

Inspector). Поэтому значение свойства DisplayRect устанавливается во время

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

MediaPlayer1.DisplayReet:=Rect(0,0,60,60).

Чтобы получить информацию о размере кадров AVI-файла, надо,

используя возможности Windows, открыть папку, в которой находится этот

файл, щелкнуть правой кнопкой мыши на имени файла, выбрать

команду Свойства и в появившемся диалоговом окне — вкладку Сводка, в

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

кадров.

Процесс воспроизведения анимации активизируется применением метода

Play, что эквивалентно нажатию кнопки Play в случае, если кнопки

компонента MediaPlayer доступны пользователю.

Процесс создания файла анимации (AVI-файла) рассмотрим на примере.

Пусть надо создать анимацию, которая воспроизводит процесс рисования

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

11.13, несколько кадров анимации — на рис. 11.14).

Для решения поставленной задачи можно воспользоваться популярной

программой Macromedia Flash.

Список использованных источников

1. Хомоненко А.Д. и др. Delphi 7. – СПб.: БХВ – Петербург, 2010.

2.Голицына О.Л., Попов И.И. Основы алгоритмизации и

программирования: Учебное пособие. – издание – М.: ФОРУМ: ИНФРА

– М, 2008

3.Фаронов В.В. Delphi. Программирование на языке высокого уровня:

Учебник для вузов – СПб.: Питер, 2007.

4.Delphi программирование. – URL:

http://www.delphisources.ru/index.html.

http://citforum.ru/programming/32less/les41.shtml

http://old.kpfu.ru/student/t/delphibook/Chapter%2010/1.htm#1

5.Иллюстрированный самоучитель по Delphi 7 для начинаюших. – URL:

http://www.realcoding.net/teach/Delphi_7.

6.Программирование на Delphi 7. - URL:

http://gluk.webhost.ru/delphi.html.

7.Культин Н.Б. Delphi 7 в задачах и примерах. – СПб.: БХВ – Петербург,

2004

8.Фленов М.В. Библия Delphi 7.0. - Издательство: БХВ-Петербург, 2011.

- 686 c.

9.Чиртик А.А., Борисок В.В., Корвель Ю.И. Delphi. Трюки и эффекты. –

СПб.: Питер, 2007.

http://shiva16.narod.ru/Index.htm