МИНОБРНАУКИ РОССИИ
––––––––––––––––––––––––––––––––––––––––––––––––––––
Санкт-Петербургский государственный электротехнический
университет «ЛЭТИ» им. В. И. Ульянова (Ленина)
–––––––––––––––––––––––––––––––––––––––––––
М. В. БЕЛЬТЮКОВ
ПРОГРАММИРОВАНИЕ В СРЕДЕ RAD STUDIO
ДЛЯ РЕШЕНИЯ МЕДИКО-ТЕХНИЧЕСКИХ ЗАДАЧ
Учебно-методическое пособие
Санкт-Петербург
Издательство СПбГЭТУ «ЛЭТИ»
2020
1
УДК 621.3.06:61
ББК З 973.2 – 018 + Р
Б 44
Бельтюков М. В.
Б 44 Программирование в среде RAD Studio для решения медико-технических
задач: учеб.-метод. пособие. СПб.: Изд-во СПбГЭТУ «ЛЭТИ», 2020. 98 с.
ISBN 978-5-7629-2681-2
Содержит основы практического обучения программированию. Курс построен на изучении базовых приемов программирования с использованием
языка Delphi и включает 7 тем. В качестве среды программирования выбрана
среда RAD Studio.
Предназначено для студентов бакалавриата первого семестра дневной и
вечерней форм обучения, направление «Биотехнические системы и технологии».
УДК 621.3.06:61
ББК З 973.2 – 018 + Р
Рецензент: д-р техн. наук, проф. П. Н. Афонин (Санкт-Петербургский
им. В. Б. Бобкова филиал Российской таможенной академии).
Утверждено
редакционно-издательским советом университета
в качестве учебно-методического пособия
© СПбГЭТУ «ЛЭТИ», 2020
ISBN 978-5-7629-2681-2
2
Введение
Использование компьютерных технологий в медицине. Медицина не
может обойтись без компьютерных технологий. Это и все более сложные методы математической обработки медицинских данных, и обработка сложных
изображений, и хранение всевозможной информации. Часть этих задач можно решать с помощью стандартных программных пакетов, но некоторые задачи требуют создания специального программного обеспечения.
Рассмотрим в качестве примера простую задачу – отображение сигнала
ЭКГ (электрокардиограммы), снятой у пациента и записанной в текстовый
файл. Данная программа должна позволять считывать данные из файла и
строить кривую ЭКГ. Также, учитывая большую длительность сигнала,
необходимо обеспечить возможность «скроллирования» сигнала в окне программы. В качестве средства создания программного комплекса была выбрана оболочка RAD Studio. Вид экрана представлен на рис. В.1.
автоскрол
лер
Рис. В.1. Вид экрана
Цель данного пособия – привить студентам первичные навыки программирования с использованием языка Delphi в среде RAD Studio, которые помогут им создавать программные комплексы медицинского назначения.
Язык программирования Delphi. В настоящее время в компьютерном
мире существует множество языков программирования. Программу, выполняющую одни и те же действия, можно написать на языках Бейсик (BASIC),
3
Паскаль (Pascal), Си (C), Питон (Python). Язык Delphi основан на базе языка
Object Pascal и лучше других языков подходит для обучения программированию. Это обусловлено тем, что язык Pascal был разработан в 1970-е гг. швейцарским ученым Никлаусом Виртом специально для обучения студентов
программированию. Язык был назван в честь французского математика и
философа Блеза Паскаля.
Наиболее популярным компилятором стала разработка американской
фирмы «Embarcadero». С появлением системы MS Windows возникла необходимость написания программ для этой системы, и фирма «Borland» выпустила несколько версий компиляторов для создания программ в среде Windows (Turbo Pascal for Windows). Но наиболее удачной получилась система
визуальной среды программирования (Rapid Application development – RADсистема) Borland Delphi.
Первая версия Delphi была создана для Windows 3.1. С появлением системы MS Windows 95 была выпущена 16-разрядная версия Delphi 2.0, а затем 32-разрядная Delphi 3.0. В 2020 г. выпущена версия RAD Studio XE
10.4.1. (В 2000-х годах фирма «Borland International» передала права на среду
программирования фирме «Embarcadero», а сама система стала поддерживать
не только язык Object Pascal, который «перерос» в язык Delphi, но кроме Delphi поддерживает языки программирования Delphi.Net и C++ для операционных систем Windows, Linux, IOS и Android.)
Среда Delphi предполагает использование визуального проектирования
и событийного программирования (программирование процедур обработки
событий визуальных компонентов), применение которых позволяет существенно упростить процесс разработки и создания приложений. Программисту требуется разработать только «идею» программы, а «представление»
программы сделает Delphi.
Этапы разработки программ включают в себя:
• построение модели программы;
• разработку и выбор алгоритма решения поставленной задачи;
• набор текста программы. В визуальной среде программирования это
означает: создание окна программы, содержащего различные визуальные
элементы, и написание команд событий;
• отладку;
• тестирование;
• написание и настройку файла помощи;
• создание инсталлятора.
4
Модель программы. На этом этапе определяется, какая информация будет входной и какие результаты должны быть представлены на выходе.
Разработка алгоритма – последовательность действий для достижения
поставленной задачи. Результатом этого этапа является подробное словесное
описание алгоритма или его графическое отображение – построение структурной схемы алгоритма.
После создания алгоритма осуществляется собственно этап написания
программы. Необходимо создать макеты диалоговых окон и продумать взаимодействие между ними, а затем написать код программы.
При написании программы неизбежно возникают ошибки – как синтаксические (ошибки при наборе текста), так и алгоритмические (ошибки в самом алгоритме программы). Требуется этап отладки.
После его окончания следует этап тестирования, проверка работоспособности системы с различными входными данными.
При написании коммерческой программы также необходимо предусмотреть контекстную помощь – этап создания файла помощи. Этот этап
может быть включен в этап написания программы.
Окончательно для распространения программы другим пользователям
служит этап создания инсталлятора.
Схемы алгоритмов и программ. При написании алгоритма программы
наиболее удобным способом отображения является графический способ –
структурная схема. Для создания структурных схем алгоритма необходимо
использовать ГОСТ 19.701-90 (ИСО 5807-85). Все основные символы алгоритма вписываются в прямоугольник со сторонами a b. Соотношение сторон b = 2a или 3a = 2b. Базовый размер a берут из ряда 10, 15, 20 и т. д.,
кратным 5. Основные символы показаны на рис. В.2.
Структура пособия. Каждая тема разделена на две части: теоретическое
знакомство с материалом и описание алгоритма создания программы.
Работа выполняется на двух занятиях. На первом занятии требуется по
предлагаемым инструкциям набрать программу и разобраться в ее структуре. Второе занятие посвящено созданию программы по индивидуальному заданию.
Результатами работы являются созданная программа и отчет, включающий титульный лист; схему алгоритма; тестовый пример (для вычислительных задач).
5
R = 0,25a 0,5
a
a
R
Комментарий
Комментарий
5 толщин линии
Решение
Линия
0,2a
Терминатор
0,2a
a
b
Граница цикла
Процесс
0,15a
Соотношение размеров
0,25a
Предопределенный
процесс
ø 0,5a
N
N
Для сохранения формы символов при построении
можно воспользоваться соотношением
2b = 3a или b = 2a
Данные
К
стр.
NS
Из
стр.
NS
Направление потока указывается в конце каждой
линии или на всех потоках, или на тех, которые
идут справа налево и снизу вверх.
Пересечение потоков не имеет логической связи
Схема «Простейшая программа»
N
Начало
Соединитель
Внешний
(N – буква
и внутренний
соединения соединители
«A», «B» и т. д.) (N – буква соединения;
NS – номер страницы,
соединяемого
Соединители
элемента)
Название
программы
или процедуры
Тело программы
Конец
Рис. В.2. Основные символы, используемые для построения
структурных схем алгоритмов
Каждая работа заканчивается зачетом по теоретическому материалу рассматриваемой темы и созданной программе.
Замечание. Для выполнения практических заданий подходят все версии
RAD Studio или Delphi.
1. ЗНАКОМСТВО СО СРЕДОЙ
ПРОГРАММИРОВАНИЯ RAD STUDIO
Цели: получить представление об оболочке программирования RAD
Studio, научиться запускать оболочку, создавать простейшую программу.
1.1. Теоретические сведения
Оболочка RAD Studio. Для запуска оболочки RAD Studio (поскольку
мы будем создавать программы на языке Delphi для среды Windows, то в
6
дальнейшем используем обозначение Delphi) необходимо выбрать в главном
меню MS Windows пункт Пуск/Программы/Embarcadero RAD Studio
10.4/RAD Studio 10.4. Значок иконки оболочки Delphi в зависимости от версии показан на рис. 1.1.
Embarcadero
RAD Studio X 10
(иконки RAD Studio, Delphi, C++)
Рис. 1.1. Иконка среды программирования RAD Studio
Окна Delphi показаны на рис. 1.2. Условно оболочка представляет собой
четыре основных окна: «Главное окно Delphi», «Инспектор объектов» – окно
настройки свойств и событий объектов, окно «Визуальный проектировщик
форм» и окно «Редактор программы».
При создании программы в Delphi приняты понятия «проект» и «модуль». Это связано с модульным способом построения программ. Главная
программа называется проектом и содержит ссылки на дополнительные
файлы – модули, используемые главной программой.
Object Inspector
Главное окно
Проектировщик формы
Tool Palette
Текст программы
Рис. 1.2. Интегрированная среда программирования RAD Studio 10.4
7
При написании программы в Delphi создаются следующие типы файлов:
1) имя1.dpr – имя файла проекта. Имя создаваемой программы определяется именем проекта;
2) имя2.dfm – имя визуального образа создаваемой программы;
3) имя2.pas – имя модуля программы, содержащей текст событий визуального образа;
4) имя1.cfg, имя2.dcu, имя1.dof, имя1.dsk, имя1.dsm, имя1.res – вспомогательные файлы;
5) *.~* – резервные копии файлов;
6) имя1.exe – файл созданной программы.
Для сохранения программы необходимы файлы, указанные в п. 1–3.
Остальные файлы создаются автоматически при компиляции программы.
Главное окно Delphi может состоять из меню системы, панели проектировщика проекта, панели кода программы, панели визуальных компонентов.
Настройка видимых элементов системы осуществляется в пункте меню View.
Меню системы включает команды Delphi для управления проектом. Панель
инструментов содержит иконки кнопок быстрого доступа к некоторым командам меню. Панель визуальных компонентов содержит иконки всех визуальных компонентов, которые программист может использовать в своей программе. Для удобства визуальные компоненты сгруппированы по назначению
и расположены на различных вкладках – Standard, Additional, Win32 и т. д.
Инспектор объектов (рис. 1.3) состоит из двух частей (вкладок) – Properties (Свойства) и Events (События). В верхней строке указан визуальный компонент (объект), для которого настраиваются свойства и события. Настроить
свойство объекта (вкладка Properties) можно тремя способами: набрать свойство в строке ввода, выбрать свойство из списка (значок ) и воспользоваться
«Мастером настройки свойств» (значок ). Некоторые свойства содержат
подсвойства, доступ к которым можно получить, щелкнув мышью на значке .
Чтобы свернуть список подсвойств, необходимо щелкнуть на значке . Для
заполнения событий визуального объекта необходимо выбрать вкладку Events.
Чтобы запрограммировать событие, необходимо щелкнуть на выбранном
свойстве, при этом становится активным Редактор программы.
Визуальный проектировщик форм представляет собой окно создаваемой
программы. В Delphi есть шаблоны для создания некоторых «специальных»
окон: окно о программе (About), различные диалоговые окна и т. д. Для создания такого окна необходимо при создании новой формы (вид создаваемого ок8
на) выбрать соответствующий шаблон в галерее форм, выполнив пункт меню в
Главном окне Delphi File/New form, значок . После создания формы необходимо настроить ее свойства (имя (Name) объекта формы, заголовок, цвет и др.)
Обозначение объекта
Настраиваемые события
Настраиваемые свойства
Свойство имеет подсвойства
Свойство выбирается из списка
Для настройки свойства служит «Мастер»
Рис. 1.3. Окно «Инспектор объектов»
После этого на форме размещают другие визуальные компоненты. Для
этой цели выбирают в Главном окне Delphi в Панели визуальных компонентов необходимый компонент и помещают его на форме (щелкают на выбранном элементе, затем щелкают на форме в том месте, где должен быть
расположен этот компонент). Для точного изменения размера компонента
можно использовать комбинацию клавиш на клавиатуре <Shift> и <стрелки>.
В Инспекторе объектов эти свойства задаются в строках Height – высота
объекта в пикселях и Width – ширина объекта. Для точного позиционирования объекта в форме можно использовать комбинации клавиш <Ctrl> и
<стрелки>. Позиция определяется свойствами Top – верхний левый угол
объекта и Left – левый край объекта.
При помещении на форму визуального компонента каждый из них получает собственное имя (свойство Name), позволяющее обращаться к этому
объекту при программировании. Имя построено так, что содержит в названии
имя класса, к которому относится объект, и порядковый номер используемого элемента данного класса. Например, имя Form1 указывает на элемент
формы и показывает, что это первый элемент класса Form.
Рекомендация. Следует изменять имена элементов, чтобы было понятно
назначение каждого элемента. Но чтобы показать, к какому свойству относится объект, необходимо оставлять заглавные буквы от класса. Например,
FMain – объект класса Form (буква «F»), который обозначает главное окно
9
(«Main»); BBExit – объект класса BitBtn (кнопка с картинкой), на что указывают буквы «BB», и эта кнопка служит для выхода из программы («Exit» –
выход). Те объекты, которые будут использоваться только как видимые элементы, можно не переименовывать.
При выборе визуального компонента, для которого необходимо написать событие (например, для кнопки BBExit написать команду выхода из программы), выбирают в Инспекторе объектов вкладку Events и выбирают необходимое событие – onClick (щелчок мыши), onKeyPress (нажатие клавиши)
и др. – и щелкают по нему мышью. Некоторое событие является событием
«по умолчанию», т. е. если в окне Визуальный проектировщик форм выбрать
визуальный элемент и дважды на нем щелкнуть, то будет программироваться
именно это событие (это событие расположено первым в списке событий).
При этом становится активным окно Редактор программы. При создании
модуля программы часть стандартного текста вводится автоматически.
Структура модуля.
unit Модуль;
// Имя модуля программы
{************}
interface
// Описание интерфейсной части
{Разделы доступны другим модулям, использующим этот:}
uses
// Раздел модулей – модули, используемые в программе
Мод1, МодN; {Имена используемых модулей: «Мод1», «МодN»}
const
// Раздел констант
Конст1 = Знач1; // Присвоение значения «Знач1» константе «Конст1»
type
// Раздел типов – используемые типы
Тип1 = Описание1; // Описание типа с именем «Тип1»
var
// Раздел переменных – используемые переменные
Пер1 : Тип1;
// Описание переменной «Пер1» типа «Тип1»
{************}
implementation // Раздел описания модуля
{Разделы доступны глобально внутри модуля:}
uses
// Раздел модулей – модули, используемые в программе
Мод2;
// Внутри модуля используется модуль «Мод2»
const
// Раздел констант
Конст2 = Знач2; // Присвоение значения «Знач2» константе «Конст2»
label
// Описание раздела меток
Метка1;
// Описание метки с именем «Метка1»
10
type
// Раздел типов – используемые типы
Тип2 = Описание2; // Описание типа с именем «Тип2»
var
// Раздел переменных – используемые переменные
Пер2 : Тип2;
// Переменная «Пер2» типа «Тип2»
{************}
procedure Проц1;
// Описание процедуры с именем «Проц1»
{Разделы доступны локально внутри процедуры:}
type
// Раздел типов – используемые типы
Тип3 = Описание3; // Описание типа с именем «Тип3»
var
// Раздел переменных – используемые переменные
Пер3 : Тип3;
// Переменная «Пер3» типа «Тип3»
begin
// Начало описания процедуры «Проц1»
Операция1;
// Тело процедуры «Проц1», выполняющей «Операцию1»
end;
// Конец описания процедуры «Проц1»
end.
// Конец описания модуля «Модуль»
Таким образом, модуль состоит из трех частей:
1. Описание типов, констант, процедур, доступных другим программам,
использующим этот модуль.
2. Описание типов, констант и т. д., используемых в данном модуле (это
раздел глобальных переменных).
3. Описание самих процедур со своими типами и константами (раздел
локальных переменных).
Для каждого оператора или группы операторов может быть написан
комментарий. Комментарий одной строки кода начинается с двойного слеша – «//», заключается в фигурные скобки – «{}» или в скобки со знаками
«звездочка» – «(* *)»:
//комментарий одной строки
{комментарий части текста}
(*Комментарий
{ // текста
программы}
с комментариями*)
При написании текста модуля целесообразно использовать отступы в
описании конкретных разделов, что дает возможность видеть начало и конец
соответствующего раздела.
11
Некоторые команды редактора. При написании программы можно использовать следующие комбинации клавиш для упрощения набора текста:
Справка:
<F1> – выдает справку (если курсор указывает на стандартный оператор, то будет выдана справка по этому оператору).
Переключение между окнами:
<F12> – переключает окна Визуальный проектировщик форм и
Редактор программы;
<F11> – делает активным окно Инспектор объектов;
<F10> – делает активным Главное окно Delphi.
Перемещение по тексту:
<↑> <↓> <→> <←>
– передвинуть курсор вверх, вниз, вправо,
влево;
<PgUp>, <PgDn> – передвижение на страницу вверх, вниз;
<Ctrl><PgUp>,
<Ctrl><PgDn>
– передвижение в начало текста, в конец
текста.
Ввод и удаление текста:
<Insert> – режим «вставки»/«замены»: текущий режим показан внизу
окна Редактор программы – «Insert» (вставка) или «Overwrite» (замена);
<Enter> – добавить новую строку;
<Delete>, <BackSpace> – удалить символ в позиции курсора (Delete)
или слева от курсора (BackSpace);
<Alt><BackSpace> – восстановить текст (например, удаленный фрагмент).
Работа с фрагментом текста:
<Shift><стрелки> – выделение текста («окраска» текста инвертируется);
<Ctrl><Insert> – поместить фрагмент в буфер обмена;
<Shift><Delete> – удалить фрагмент из текста в буфер обмена;
<Shift><Insert> – вставить текст из буфера обмена;
<Ctrl><K><H> – снять выделение фрагмента;
<Ctrl><K><U> – сдвинуть фрагмент на символ влево;
<Ctrl><K><I> – сдвинуть фрагмент на символ вправо.
Установка закладок. В большом тексте для облегчения перемещения
по тексту можно устанавливать закладки:
12
<Ctrl><K><«N»> – установить закладку с номером «N» (N – номер закладки, в левой позиции строки появится символ
с номером закладки, в
данном случае номер «1» (комбинация клавиш <Ctrl><K><1>));
<Ctrl><Q><«N»> – перейти на закладку с номером «N».
Компиляция и запуск программы:
<Ctrl><F9> – компиляция программы (создание файла с расширением
.exe без запуска программы);
<F9> – запуск программы.
1.2. Создание программы «Моя первая программа»
Задача. В качестве первой программы необходимо создать программу
«Цветное окно с картинкой».
Примерный вид окна программы показан на рис. 1.4.
Рис. 1.4. Примерный вид окна первой программы
Процесс создания программы проходит по следующему алгоритму:
1. Запустить оболочку Delphi из пункта меню MS Windows или с «Рабочего стола».
2. Сохранить проект в рабочем каталоге с помощью команды File/Save Project As…, значок
в Главном окне Delphi. Необходимо изменить предлагаемые
по умолчанию имена на следующие: файл с расширением .dpr назвать
«Work1.dpr» (так будет называться файл создаваемой программы); модуль –
файл с расширением .pas – назвать «main», т. е. это главное окно программы.
Рекомендация. Целесообразно каждый создаваемый проект хранить в
отдельной папке; в именах файлов можно использовать только латинские
буквы без пробелов!
13
3. Настроить окно программы:
• назвать форму FMain Окно Инспектор объектов, вкладка
Properties, свойство Name (в дальнейшем изменяемое свойство будет обозначаться после стрелки);
• заголовок окна изменить на Программа №1 свойство Caption;
• изменить свойство Position на poScreenCenter для вывода окна программы в центре экрана;
• изменить цвет окна на стандартный в свойстве Color выбрать цвет
clBtnFace;
• сделать окно «прозрачным»: установить в свойстве TransporentColor
значение True (цвет прозрачный), а в свойстве TransporentColorValue выбрать, какой цвет прозрачный (в нашем случае выбрать clBtnFace);
• изменить тип окна программы свойство BorderStyle, выбрать значение bsNone (в программе отсутствуют рамка и заголовок окна).
4. Поместить на форму картинку объект Image вкладка Additional на
Панели визуальных компонентов в Главном окне Delphi, иконка значка
.
На форме появится место будущей картинки. Картинка может быть отображена двумя способами: либо занять место, определенное пользователем
(рамка картинки), либо изменить рамку под реальные размеры картинки. Для
настройки картинки необходимо изменить следующие свойства:
• Picture – загружает «Мастера» для выбора картинки из файла. Выберите
любой файл с картинкой из имеющихся на жестком диске. В состав Delphi
входит набор картинок. Их можно взять в папке Image\Splash, находящейся в
папке Delphi (для версий 1, 2), или в папке Program Files\Common
Files\Borland Shared\Image\Splash (для остальных версий). Картинки находятся
в двух папках: 16 Color и 256 Color – в зависимости от используемых в картинке цветов. Если указанной папки нет, выбрать любую доступную картинку;
• AutoSize – при значении true значения, установленные пользователем
для картинки (свойства Width – ширина и Height – высота), будут изменены
в соответствии с реальными размерами картинки;
• Stretch – при значении true размеры картинки будут адаптированы к размерам, установленным пользователем (указанным в свойствах Width и Height).
Замечание. Свойства AutoSize и Stretch являются взаимоисключающими;
• Transparent – при значении true картинка будет иметь прозрачный фон.
5. Поместить на форме кнопку для выхода из программы. Можно установить кнопки двух типов: простую объект Button, вкладка Standard, с
14
иконкой объекта
, или с картинкой объект BitBtn, вкладка Additional,
значок
. Изменить свойства (пусть мы используем кнопку BitBtn):
• Name, если установлена кнопка BitBtn, изменить на BBExit;
• выбрать «родительский» тип кнопки – в свойстве Kind выбрать значение bkClose – кнопка закрытия окна. Будут выбраны стандартные значения
заголовка кнопки (свойство Caption) и картинка кнопки (свойство Glyph).
Картинка нас устраивает, а вот заголовок изменим;
• установить заголовок кнопки (свойство Caption) на значение
«В&ыход». Символ «&» указывает, что следующая буква в названии будет
«горячей», т. е. при нажатии на букву «ы» сработает кнопка. Но только если
выбрана русская раскладка клавиатуры!
6. Поместить на форму метку для подписи к картинке объект Label,
вкладка Standard, значок
. Изменить ее свойства:
• Caption – заголовок, изменить на название помещенной картинки;
• Font – шрифт текста, запускает «Мастера» для настройки названия,
цвета и стиля шрифта метки.
7. Запрограммировать выход при щелчке по кнопке:
• выбрать элемент установленной кнопки на форме (вокруг кнопки будет
рамочка). Активный элемент, т. е. элемент, свойства которого настраиваются,
выделен рамочкой
; если рамочки нет ни на одном элементе, то активна
форма;
• так как у нас взят элемент BtnFace, то кнопку даже не нужно программировать – кнопка сама закроет окно (программу) при ее нажатии!;
• если бы была выбрана кнопка Button, то такая кнопка программируется
вручную: дважды щелкнуть по кнопке мышью – будет выполнено событие onClick на вкладке Events в Инспекторе объектов (это событие является событием
«по умолчанию»). Станет активным окно Редактор программы. При этом автоматически будет создана процедура для программирования события onClick.
Например, если была использована кнопка BExit, текст будет следующим:
Procedure TFMain.BExitClick(Sender: TObject);
begin
end;
• в тело созданной процедуры (между операторными скобками begin и
end) вписать команду закрытия окна – Close. Так как оно одно, то закрытие
окна приведет к выходу из программы. Текст программы станет таким:
15
Procedure TFMain.BExitClick(Sender: TObject);
begin
Close;
end;
• Обратите внимание! После слова «Close» стоит знак «;», так как на
языке Delphi необходимо ставить знак «точка с запятой» «;» после каждой
команды.
8. Программа создана! Для запуска программы необходимо:
• сохранить программу команда File/Save All, значок
в меню Главного окна Delphi;
• запустить программу Run/Run в меню Главного окна Delphi или
щелкнуть на значок
на Панели инструментов в Главном окне Delphi.
9. Выйти из Delphi по команде File\Exit, значок .
10. Загрузить проект (если потребуется) при следующем запуске Delphi
можно через пункт File/Open Project, значок
в Главном окне Delphi. А последние проекты доступны в пункте File/Reopen.
Итоги. В первой теме были изучены: оболочка Delphi; структура программы; команды редактора.
При создании демонстрационной программы получены навыки работы
со следующими командами и визуальными компонентами: окном формы
Form; кнопкой Button; кнопкой с картинкой BitBtn; рисунком Image; меткой Label; командой закрытия окна Close.
2. УСЛОВНЫЕ ОПЕРАТОРЫ
Цели: изучение типов переменных, описания переменных и констант,
операций с переменными; изучение условных операторов.
2.1. Теоретические сведения
Типы данных. Язык Object Pascal предоставляет ряд типов данных. Все они
построены на базе стандартных типов переменных стандарта языка Паскаль:
• Integer – целый тип, переменные этого типа могут принимать положительные и отрицательные значения в диапазоне от –32768 до 32767.
• Real – вещественный тип, переменные этого типа могут принимать
положительные и отрицательные значения, записываемые как в простой
форме: 10.12, 5.6, так и в экспоненциальной: 2.123Е5 (= 2,123105), 0,854Е3(= 8.5410–4). Диапазон чисел этого типа – от 2.9Е-39 до 1.7Е38.
16
• Char – символьный тип, переменные этого типа служат для записи значений символов, которые должны заключаться в прямые кавычки: 'A', 'ю', '7' –
переменная содержит символы «А», «ю», «7».
• Boolean – логический тип, переменные этого типа могут принимать
только два значения: true (истина) и false (ложь).
• Перечисляемый тип – указывает возможные значения переменной,
например: 1, 5, 45, 56 – переменная такого типа может содержать только одно
из указанных чисел. На базе стандартных типов переменных созданы все
остальные типы Object Pascal, представленные в табл. 2.1 (ячейки стандартных типов выделены).
Таблица 2.1
Тип данных
ShortInt
SmalInt
LongInt
Byte
Word
Integer
Cardinal
Comp
Тип данных
Real
Single
Double
Extended
Тип данных
AnsiChar
WideChar
Char
Тип
String
ShortString
LongString
WideString
Тип
Boolean
Целые числа
Диапазон
Формат
–128…127
Знаковый, 8 бит
–32768…32767
Знаковый, 16 бит
–2147483648…2147483647
Знаковый, 32 бита
0…255
Беззнаковый, 8 бит
0…65535
Беззнаковый, 16 бит
–2147483648…2147483647
Знаковый, 32 бита
0… 2147483647
Беззнаковый, 32 бита
18
18
Целый, абсолютно точный
–9,210 …9,210
Вещественные числа
Диапазон
Кол-во цифр
Кол-во байт
–39
+38
11–12
6
2,910 …1,710
–45
+38
7–8
4
1,510 …3,410
–324
+308
15–16
8
5,010 …1,710
–4932
+4932
19–20
10
3,410
…1,110
Символы
Символы
Коды
ANSI
0…255
Unicode
0…65535
ANSI
0...255
Строки
Тип строки
Статическая длина от 0 до 255 символов
Длина ограничена объемом памяти
Динамический
То же, но каждый символ –
Unicode-символ (16 бит)
Логический
Значение
true (истина), false (ложь)
17
Переменные и константы. Для описания переменных служит раздел
переменных, начинающийся ключевым словом Var. Переменные могут быть
глобальными (переменная доступна в любом месте программы) и локальными
(переменные доступны только в той процедуре, в которой они описаны).
Объявление переменной выглядит так:
имя : тип;
Здесь имя – имя объявляемой переменной; тип – один из типов языка
Delphi.
Пример.
var
a,b,c: Real;
S : String;
В примере введены три переменные типа real и одна переменная string.
Однотипные переменные можно перечислять через запятую.
Замечание. Имя переменной может содержать только латинские буквы
и не зависит от выбранного регистра, т. е. переменные s и S – это одна и та
же переменная. Удобно записывать разнотипные переменные на разных
строках.
При назначении переменной значения используется оператор «присвоить» – «:=».
В общем виде присвоение выглядит так:
Имя := Выражение;
Пример.
k := 5; – присвоить переменной k значение 5; с := 5 + t; – присвоить переменной с значение 5 + t .
В языке Паскаль существует два вида констант: обычные и именованные. Обычная константа – это целое или дробное число, строка символов
или отдельный символ, логическое значение. Именованные константы, как
и переменные, перед использованием должны быть объявлены в разделе описания констант. Описание именованной константы в общем виде:
Константа = значение;
Здесь константа – имя объявляемой константы; значение – значение
именованной константы.
Пример.
const
Ch = 'S'; // Константа Ch содержит символ S
18
V = 33;
// Константа V содержит значение числа 3.
Тип константы определяется ее значением. После объявления константы
в инструкциях программы вместо значения константы можно использовать
ее имя.
Операции с переменными. Выражение состоит из операторов и операндов. Операции находятся между операндами. Операндами могут быть
константы и/или переменные. Операции определяют действия, выполняемые
над операндами. В табл. 2.2 указаны операторы, их действия и тип полученного выражения.
Таблица 2.2
Оператор
Действие
+
Сложение
–
Вычитание
*
Умножение
/
div
Деление
Деление нацело
Остаток
от деления
mod
Оператор
Действие
and
Конъюнкция
(«И»)
or
Дизъюнкция
(«ИЛИ»)
Оператор
>
Инверсия
(Отрицание)
Описание
Больше
<
Меньше
=
Равно
<>
Не равно
not
>=
<=
Больше
или равно
Меньше
или равно
Если один операнд real
все integer
Если один операнд real
все integer
Если один операнд real
все integer
Real или integer
Всегда integer
Тип
выражения
Real
Integer
Real
Integer
Real
Integer
Real
Integer
Всегда integer
Integer
Тип оператора
Логические операторы
Операнд1
Операнд2
Результат
False
False
False
False
True
False
True
False
False
True
True
True
False
False
False
True
False
True
False
True
True
True
True
True
False
True
True
False
Значение выражения
True, если первый операнд больше второго, иначе false
True, если первый операнд меньше второго,
иначе false
True, если первый операнд равен второму, иначе false
True, если первый операнд не равен второму,
иначе false
True, если первый операнд больше или равен второму,
иначе false
True, если первый операнд меньше или равен второму,
иначе false
19
Условные операторы. Условный оператор позволяет выбирать одно из
двух действий, причем выбор осуществляется во время выполнения программы. Существует два вида условных операторов:
1. If условие then действие.
2. If условие then действие1 else действие2.
Здесь условие – выражение логического типа; действие1, действие2 –
отдельные операторы или операторы, сгруппированные вместе при помощи
операторных скобок begin и end. Такой оператор называется составным.
Графически операторы условия изображены на рис. 2.1.
Условие
Ложь
Истина
Истина
Действие
Условие
Действие 1
Оператор первого типа
Ложь
Действие 2
Оператор второго типа
Рис. 2.1. Структурная схема условного оператора
Замечание. Над потоками должны быть указаны значения условия, при
котором выполняются действия (на рисунке это «Истина» и «Ложь»).
Для оператора первого типа, если выражение условие принимает значение true, выполняется действие, стоящее после ключевого слова then. Если
же значение условие равно false, то действие не выполняется.
Пример.
If X > Y then X := 5; – значение переменной Х станет равным 5 только в
том случае, если выполняется условие X > Y, в противном случае значение Х
останется прежним.
Для оператора второго типа, если условие принимает значение true, то
выполняется действие1, стоящее после оператора true, при значении условия
false выполняется действие2, стоящее после оператора else.
Пример.
If X > Y then X := 5 else X := 3; – значение переменной Х станет равным
5 при условии X > Y, при невыполнении условия Х будет равно 3.
Замечания:
1. Перед оператором else значок «точка с запятой» не ставится!
20
2. В условном операторе выполняется только один оператор, стоящий
после слов then или else. Если требуется выполнить несколько операторов,
необходимо их поместить между операторными скобками begin и end.
Пример.
Переменные X и Y должны получить значения 5 и 23 соответственно
при выполнении условия А > 0 и обнуляются (получают значение 0), если
A 0. Оператор условия будет выглядеть так:
If A > 0 then
begin
X := 5;
Y := 23;
end
else
begin
X := 0;
Y := 0;
end;
Операторы, следующие после then или else, в свою очередь также могут
быть условными операторами.
1. Условный оператор первого типа – If условие then действие. При
этом:
• если оператор действие является условным оператором первого типа
(рис. 2.2), ему соответствует конструкция:
Истина
Условие 1
Ложь
Условие 2
Ложь
Истина
Действие
Рис. 2.2. Выполнение Условие 1 –
условный оператор первого типа
21
If условие1 then
If условие2 then действие
В этом случае оператор действие определяется однозначно;
• если оператор действие – условный оператор второго типа, то справедлива конструкция:
If условие1 then
If условие2 then
действие1
else
действие2.
Возникает вопрос: какому оператору then соответствует else (рис. 2.3)?
Для обеспечения однозначности в языке Паскаль принято соглашение о том,
что каждому else соответствует предыдущий свободный then.
Истина
Условие 1
Ложь
Условие 2
Ложь
Истина
Действие1
Действие2
Рис. 2.3. Выполнение Условие 1 –
условный оператор второго типа
2. Условный оператор второго типа – If условие then действие1 else действие2. Оператор действие1 – условный оператор первого типа, оператор действие2 не является условным оператором (рис. 2.4). Получаем конструкцию:
If условие1 then
begin
If условие2 then
действие1
end
else
действие2.
Видно, что оператор действие1 необходимо заключить в операторные
скобки, иначе придем к схеме на рис. 2.3.
22
Истина
Условие 1
Ложь
Условие 2
Истина
Ложь
Действие 2
Действие 1
Рис. 2.4. Выполнение Условие 1 – условный
оператор первого типа, невыполнение – Действие2
Рекомендации:
1. Для упрощения чтения текста программы при описании условных
операторов следует использовать лидирующие пробелы для выделения каждого раздела.
2. Если возникают трудности в оценке порядка выполнения действий в
условном операторе, необходимо использовать операторные скобки.
Оператор выбора. Если при построении условного оператора известно
большинство возможных значений условия, то необходимо использовать
оператор выбора. В общем виде структура этого оператора следующая:
Case переменная of
Значение1 : Действие1;
…
ЗначениеN :
ДействиеN;
else
ДействиеN1;
end;
Здесь:
Переменная – переменная перечисляемого типа (например: integer, char);
Значение1, …, ЗначениеN – возможные значения переменной;
Действие1, …, ДействиеN – действия, выполняемые при значении переменной, равном одному из значений Значение1, …, ЗначениеN;
ДействиеN1 – действие, выполняемое в случае, когда переменная не
принимает ни одно из перечисленных значений (Значение1, …, ЗначениеN).
Структурная схема оператора выбора показана на рис. 2.5.
23
Условие
Значение 1
Действие 1
Значение N
Значение 2
Действие 2
…
Действие N
Иначе
Действие N+1
Рис. 2.5. Оператор выбора
Так же как и при использовании условного оператора, если Действие
представляет собой несколько операторов, их нужно поместить в
операторные скобки begin и end. Если при отсутствии значения переменной
никакое действие не выполняется, схема оператора выбора будет следующей:
Case переменная of
Значение1 : Действие1;
…
ЗначениеN : ДействиеN;
end;
Замечание. Оператор Case всегда оканчивается оператором end.
Очень удобно использовать оператор выбора при анализе нажатия клавиш клавиатуры.
Пример.
Пусть в разделе переменных описана переменная Ch типа сhar.
Case Ch of
'W' :
Y := Y + 1;
'X' :
Y := Y – 1;
end;
В примере анализируется переменная Ch. Если Ch содержит символ
«W», то переменная Y увеличивается на 1; если Ch содержит символ «X», то
переменная Y уменьшается на 1.
2.2. Создание программы «Попадание точки в фигуру»
Задача. Дана сложная фигура, вписанная в квадрат с координатами: левый нижний угол (5, 5), верхний правый угол (20, 20). Требуется написать
программу для определения попадания точки с введенными координатами в
указанную фигуру. Примерный вид окна программы показан на рис. 2.6.
24
Рис. 2.6. Примерный вид окна программы «Попадание точки в фигуру»
Процесс создания программы проходит по следующему алгоритму:
1. Запустить программу Delphi.
2. Сохранить проект как «Work2», модуль назвать «Main».
3. Назвать форму Name в значении FIf.
4. Создать образ окна: изменить заголовок на Попадание точки в фигуру.
5. Создать изображение фигуры:
• поместить в форму элемент Shape, вкладка Additional, значок
;
• изменить свойства объекта:
° дать имя фигуре (Name) Shape1. Так как на углах фигуры круги, изменить тип фигуры (свойство Shape изменить на stCircle). Цвет фигуры пусть
будет синий (Brush.Color и Pen.Color), назначить clBlue. Размер: ширину
(Width) изменить на 100, высоту (Height) – на 100. Положение фигуры: левую координату (Left) изменить на 100, верхнюю координату (Top) – на 100.
Остальные фигуры (три круга и пять квадратиков) будут иметь параметры,
приведенные в табл. 2.3;
• поместить два элемента Shape для отображения осей координат. Один
элемент назвать (Name) SX0, другой SY0. Для элемента SX0 установить параметры: Left в значение 50, Top в значение 2, Height – 250, Width – 1. Для
элемента SX0: Left – 50, Top – 250, Height – 1, Width – 260;
25
Таблица 2.3
Свойства
Name
Shape
Brush.Color
Pen.Color
Left
Top
Height
Width
2
Shape2
stCircle
clBlue
clBlue
100
50
100
100
3
Shape3
stCircle
clBlue
clBlue
150
50
100
100
Значения для фигуры под номером
4
5
6
7
Shape4 Shape5
Shape6
Shape7
stCircle stSquare stSquare stSquare
clBlue
clBlue
clBlue
clBlue
clBlue
clBlue
clBlue
clBlue
150
100
150
200
100
100
150
100
100
50
50
50
100
50
50
50
8
Shape8
stSquare
clBlue
clBlue
150
50
50
50
9
Shape9
stSquare
clBtnFace
clBtnFace
150
100
50
50
• поместить фигуру для отображения точки: элемент Shape. Настроить
его свойства: имя (Name) SPoint, ширина (Width) и высота (Height) – в значение 10, координата положения по X (Left) – в значение 45, по Y (Top) – в
значение 245.
6. Создать два элемента для ввода координат точки:
• поместить на форму два элемента SpinEdit, вкладка Samples, значок
;
• назвать один элемент SECoordX (для координаты X) и SECoordY (для
координаты Y) свойство Name;
• настроить минимальное возможное значение вводимого числа – 0, максимальное – 25, значение по умолчанию 0 и шаг изменения величины 1
соответственно MinValue, MaxValue, Value и Increment.
7. Добавить надписи к полям ввода:
• поместить три элемента Label, вкладка Standard, значок
;
• настроить надписи на Координата X, Координата Y и Результат
Caption.
8. Поместить метку для отображения результата попадания точки:
• назвать элемент LResult Name. Цвет текста Font.Color в красный
цвет – clRed и заголовок метки – в значение Не попала.
9. Добавить метку для вывода результата попадания точки:
• поместить элемент Label, вкладка Standard, значок
;
• изменить заголовок на «Не попала» Caption.
10. Добавить кнопки для запуска вычислений и выхода из программы:
• добавить кнопку для закрытия программы (элемент BitBtn, вкладка
Additional, значок
;
• назвать кнопку для выхода BBExit;
26
• выбрать тип кнопки Kind в значение bkClose;
• изменить заголовок кнопки на «Выход» Caption.
11. Образ окна создан!
12. Проанализировать форму фигуры для создания алгоритма – в нашем
случае проверить попадание в большой квадрат с четвертями окружности по
углам и проверить, не попадает ли точка во внутренний квадрат.
13. Запрограммировать элемент SECoordX:
• щелкнуть дважды по кнопке SECoordX (будет сгенерировано событие
onChange – изменение значения в элементе SpinEdit);
• записать оператор проверки координат (координаты можно получить у
элементов SECoordX и SECoordY через свойства Value – обращение к свойству объекта осуществляется через «точку», например: SECoordX.Value дает
значение свойства Value элемента SECoordX. SECoordX.Value дает значение введенной координаты X, SECoordY.Value – координаты Y). Для удобства введем переменные X и Y – тип данных выбираем byte (подходит этот
тип данных, так как он позволяет содержать значения от 0 до 255, а координаты имеют значения от 0 до 25):
procedure TFIf.SECoordXChange(Sender: TObject);
var
X, Y : byte;
begin
LResult.Font.Color := clRed;
X := SECoordX.Value;
Y := SECoordY.Value;
// первый круг (Shape 1)
if ((X >= 5)and(X <= 10)and(Y >= 5)and(Y <= 10)and
(Sqr(X - 10) + Sqr(Y-10) <= 25))or
// второй круг (Shape 2)
((X >= 15)and(X <= 20)and(Y >= 5)and(Y <= 10)and
(Sqr(X - 15) + Sqr(Y-10) <= 25))or
// третий круг (Shape 3)
((X >= 15)and(X <= 20)and(Y >= 15)and(Y <= 20)and
(Sqr(X - 15) + Sqr(Y-15) <= 25))or
// четвертый круг (Shape 4)
((X >= 5)and(X <= 10)and(Y >= 15)and(Y <= 20)and
(Sqr(X - 10) + Sqr(Y-15) <= 25))or
27
// первый квадрат (Shape 5)
((X >= 5)and(X <= 10)and(Y >= 10)and(Y <= 15))or
// второй квадрат (Shape 6)
((X >= 10)and(X <= 15)and(Y >= 5)and(Y <= 10))or
// третий квадрат (Shape 7)
((X >= 15)and(X <= 20)and(Y >= 10)and(Y <= 15))or
// четвертый квадрат (Shape 8)
((X >= 10)and(X <= 15)and(Y >= 15)and(Y <= 20))
then
begin
// попадание в фигуру (отображаем зеленым цветом)
LResult.Font.Color := clGreen;
LResult.Caption := 'Попала';
end
else
begin
// непопадание в фигуру (отображаем красным цветом)
LResult.Font.Color := clRed;
LResult.Caption := 'Не попала';
end;
// передвигаем «точку» в выбранные координаты
// начало координат определяется свойствами Left и Top элементов
// осей координат SX0 и SY0 соответственно. Шаг попиксельно
// рассчитываем, зная ширину и высоту квадратика Shape6,
// умноженную на введенные значения X и Y
// учитываем направление изменения координат X – слева-направо
// Y – сверху-вниз
SPoint.Left := SX0.Left + X * Shape6.Width div 5 - (SPoint.Width div 2);
SPoint.Top := SY0.Top - Y * Shape6.Height div 5 - (SPoint.Height div 2);
end;
14. Выбрать то же событие выбора значения onChange у элемента
SECoordY, что и запрограммированное для элемента SECoordX – из выпадающего списка в событии SECoordY.onChange выбрать SECoordXChange.
15. Запустить программу <F9>.
16. Для улучшения программы можно запрограммировать:
• дооформить координатные оси: добавить промежуточные оси, пронумеровать координаты на осях;
28
• получать результат попадания точки при нажатии кнопки мыши на
форме.
Индивидуальное задание. Создать программу по заданию, рассмотренному в 2.2, используя шаблон в соответствии с номером варианта (рис. 2.7).
Для отображения треугольника можно его нарисовать в стандартной программе Paint и вставить в Delphi с помощью элемента Image (как в работе 1).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
25
24
Рис. 2.7. Варианты заданий
Итоги. Во второй теме были изучены: типы переменных; операции над
операндами; условные операторы.
При создании демонстрационной программы получены навыки работы
со следующими командами и визуальными компонентами: элементом фигуры Shape; элементом изменения значения чисел SpinEdit; связыванием событий объектов.
3. ОПЕРАТОРЫ ЦИКЛА
Цели: изучение стандартных функций; метки; изучение операторов
цикла; отладка программ.
3.1. Теоретические сведения
Стандартные функции. Для выполнения часто встречающихся вычислений и преобразования данных в Object Pascal существуют стандартные
функции.
Некоторые стандартные арифметические функции перечислены в табл. 3.1.
29
Для более сложных расчетов необходимо подключить к программе модуль Math. Для этого в разделе описания модулей (например, после слова
implementation) добавить следующую строку: Uses Math;
Некоторые функции из этого модуля (арифметические, тригонометрические и для перевода углов из одной системы в другую) представлены в табл. 3.2.
Таблица 3.1
Функция
Abs(n)
Sqr(n)
Sqrt(n)
Sin(n)
Cos(n)
ArcTan(n)
Exp(n)
Ln(n)
Действие
Абсолютное значение n
Число n в степени 2
Корень квадратный из числа n
Синус числа n
Косинус числа n
Арктангенс числа n
Число е в степени n
Натуральный логарифм числа n
Таблица 3.2
Функция
Lnxp1(x)
Ceil(x)
Floor(x)
Frexp(x,m,e)
IntPower(a,x)
LdExp(x,p)
Log10(x)
Log2(x)
LogN(n,x)
Max(a,b)
Min(a,b)
Poly(x,C)
Power(a,x)
PI
ArcCos(x)
ArcCosH(x)
ArcSin(x)
ArcSinH(x)
ArcTanH(x)
CosH(x)
Cotan(x)
Hypon(a,b)
SinCos(r,s,c)
SinH(x)
Tan(x)
TanH(x)
Действие
Арифметические
Натуральный логарифм числа (x + 1)
(использовать при х, близких к 0)
Ближайшее большее число к х
Ближайшее меньшее число к х
Мантисса m и порядок e числа х
а в целой степени х – ах
Число х, умноженное на 2 в целой степени р – х2р
Десятичный логарифм числа х (lg(x))
Двоичный логарифм числа х (lb(x))
Логарифм по основанию n числа х (lognх)
Максимальное из двух чисел а и b
Минимальное из двух чисел а и b
Степенной ряд с коэф. С (массив) – с0 + с1х + с2х2+…+ сnxn
Число а в степени х (ах)
Тригонометрические
Число ( ≈3,1415926535897932385)
Арккосинус х
Гиперболический арккосинус х
Арксинус х
Гиперболический арксинус х
Гиперболический арктангенс х
Гиперболический косинус х
Котангенс х (Cos(x) / Sin(x))
Гипотенуза прямоугольного треугольника – a2 b 2
Синус s и косинус с угла r в радианах
Гиперболический синус х
Тангенс х (Sin(x) / Cos(x))
Гиперболический тангенс х
30
Окончание табл. 3.2
Перевод углов из одной системы в другую
Перевод периодов х в радианы (1 период соответствует 2)
Перевод градусов х в радианы (180 соответствуют )
Перевод величины x, представленной в радианах, в периоды
RadToCycle(x)
(2 соответствует период)
Перевод величины х, представленной в радианах, в градусы
RadToDeg(x)
( радиан соответствуют 180)
Статистические расчеты
Генерация случайного числа по распределению Гаусса,
RandG(m,sd)
задается m – математическое ожидание, sd – стандартное
отклонение
MaxIntValue(D)
Максимальное число из массива целых чисел D
MaxValue(D)
Максимальное число из массива чисел D
Mean(D)
Среднее число массива D
MeanAndStdDev(D,
Среднее число m и квадратичное отклонение sd массива D
m,sd)
MinIntValue(D)
Минимальное число массива целых чисел D
MinValue(D)
Минимальное число массива чисел D
StdDev(D)
Квадратичное отклонение массива D
Sum(D)
Сумма всех чисел массива D
SumInt(D)
Сумма всех целых чисел массива D
CycleToRad(x)
DegToRad(x)
Функции преобразования типов. Функции преобразования служат для
преобразования переменной одного типа в другой тип. Наиболее часто такие
функции используются при вводе и выводе информации. Например, для вывода значения переменной числового типа в поле ввода необходимо преобразовать значение в строковый тип, так как поле ввода позволяет выводить только
строки. В табл. 3.3 перечислены основные функции преобразования типов.
Таблица 3.3
Функция
Chr(n)
IntToStr(n)
FloatToStr(n)
FloatToStrF(n,f,l,m)
StrToInt(s)
StrToFloat(s)
Round(n)
Trunc(n)
Frac(n)
Int(n)
Значение
Символ в стандарте ANSI с номером n
Преобразование целого числа n в строку
Преобразование вещественного числа n в строку
Преобразование вещественного числа n в строку с форматом f,
длиной строки l и количеством m цифр после десятичной точки
Преобразование строки s в целое число
Преобразование строки s в вещественное число
Ближайшее к n целое
Целая часть от n
Дробная часть вещественного числа n
Целая часть вещественного числа n
Операторы цикла. При разработке алгоритмов решения большинства
задач возникает необходимость повторения ряда шагов. Для организации новых повторов (циклов) можно использовать три разновидности операторов
31
цикла: с параметром, с предусловием, с постусловием. КажI := NV
дую разновидность цикла можно реализовать с помощью
условного оператора и безусловного перехода (см. далее).
Тело цикла
Если число повторений тела цикла заранее известно, то
применяется оператор цикла с параметром. Структурная
схема представлена на рис. 3.1. Общий вид следующий:
I := KV
For переменная := нач_значение to кон_значение do тело
или
Рис. 3.1. Цикл
For переменная := нач_значение downto кон_значение do
с параметром тело;
Здесь:
переменная – параметр цикла, в качестве параметра может быть использована любая переменная перечисляемого типа (например, integer);
нач_значение и кон_значение – выражения, задающие начальное и конечное значения параметра цикла соответственно;
тело – простой или составной оператор.
Тип начального и конечного значений цикла должен совпадать с типом
параметра цикла. Выполнение оператора цикла начинается с проверки условия переменная <= конзн для цикла to и переменная >= конзн для цикла
downto. Если условие не выполняется, то оператор тело не выполняется и
управление передается следующему за циклом оператору. Если же условие
истинно, то выполняется оператор тело, затем параметру цикла переменная
присваивается следующее значение (цикл to) или предыдущее значение
(цикл downto). Далее процесс повторяется. Если параметр цикла целого типа,
то это означает его увеличение (цикл to) или уменьшение (цикл downto) на
единицу при каждом вычислении расположенного в цикле оператора.
Замечание. Шаг изменения параметра всегда равен 1 или –1.
Примеры.
(Считается, что раздел переменных имеет следующий вид: var S,I: Integer; Sim : Char; L : Boolean;)
S := 0; For I := 5 to 7 do Inc(S);
Операция Inc(S,K) означает S := S + K, т. е. увеличение параметра S на
значение K. Если K не задан, то считается, что K = 1. (Обратная функция
Dec(S,K) – уменьшение переменной S на значение K.) В примере после выполнения цикла переменная S получит значение 3.
S := 10; For I:= 10 downto 6 do Dec(S,2); S получит значение 0.
S := 0; For Sim := 'A' to 'D' do S := S + 1; S получит значение 4.
S := 0; For L:=false to true do Inc(S,3); S получит значение 6.
32
Если в цикле необходимо выполнить несколько операторов, то используется составной оператор.
Пример.
S := 0;
For I := 1 to 3 do
begin
S := S + Sqr(I);
P := S + 1;
end;
После выполнения цикла переменная S станет равной 14, а переменная
P – равной 15.
Замечания.
1. Значение переменной параметра цикла, а также начальное и конечное
значения изменять внутри цикла нельзя.
2. Для принудительного выхода из цикла в Object Pascal используют команду Break.
3. Для повторного выполнения тела цикла со следующим значением параметра цикла в Object Pascal используют команду Continue.
4. При выходе из цикла значение параметра цикла не определено.
Оператор цикла с параметром применим, если известно число повторений, шаг цикла равняется 1 или –1. В противном случае необходимо использовать два других типа цикла: с предусловием или с постусловием.
Оператор цикла с предусловием (рис. 3.2, а) имеет вид:
while условие do тело;
Здесь:
условие – выражение условного типа;
Имя цикла
Имя цикла
тело – простой или составной оператор.
Условие
Выполнение оператора начинается с выТело цикла
числения значения выражения условие. Если Тело цикла
это значение true, то выполняется оператор
тело. Затем выполнение оператора цикла поИмя цикла
Имя цикла
вторяется до тех пор, пока значение выражения
Условие
условие не станет равным false. В этом случае
управление передается оператору, стоящему за
а
б
оператором цикла. Если значение выражения
Рис. 3.2. Цикл
с предусловием (а)
условие при первом входе в цикл равно false, то
и с постусловием (б)
цикл не выполняется ни разу.
33
Замечание. Один из операторов внутри цикла должен влиять на значение условие, иначе цикл будет повторяться бесконечно – происходит «зацикливание» программы.
Пример.
k := 0;
while k <6 do
begin
Inc(k,2);
Y := Sqr(k);
end;
В примере использована процедура Inc(k,2), которая увеличивает значение переменной k на 2. Общий вид процедуры: Inc(перем [, знач]) – увеличить значение переменной перем на величину знач. При отсутствии величины знач переменная перем будет увеличена на 1. Процедура Dec(перем
[,знач]) уменьшает значение переменной перем на величину знач.
В процессе выполнения цикла переменная Y будет иметь значения 4, 16, 36.
Оператор цикла с постусловием (рис. 3.2, б) похож на оператор цикла с
предусловием, но условие проверяется после выполнения операторов, составляющих тело цикла. Общий вид оператора:
repeat
тело;
until условие;
Здесь:
условие – выражение логического типа;
тело – оператор или составной оператор;
Замечания:
1. Так как тело цикла заключено между ключевыми словами цикла, то
при использовании в теле цикла составного оператора помещать его между
операторными скобками begin и end не нужно.
2. Так как условие проверяется в конце цикла, то необходимо, чтобы
цикл выполнялся как минимум один раз.
Оператор цикла с постусловием начинается с выполнения операторов
внутри цикла. Затем вычисляется выражение условие. Если значение равно
true, то осуществляется выход из цикла, а при значении false выполнение
тела повторяется.
34
Замечание. Выход из цикла с предусловием осуществляется при достижении ложности
Тело цикла
условия, а из цикла с постусловием – при достижении истинности условия.
Пример.
Условие
Возьмем тот же пример, что и в цикле с
Ложь
предусловием:
Истина
K := 0;
Рис. 3.3. Цикл с постусловием,
repeat
построенный с помощью
условного оператора
Inc(k,2);
Y := Sqr(k);
until(k>6);
Результат будет тот же.
Любой тип оператора цикла может быть построен с помощью условного
оператора. Например, структурная схема цикла с постусловием, построенного с помощью условного оператора, показана на рис. 3.3.
При построении такого цикла необходимо переслать информационный поток перед операторами цикла, используя метки и оператор безусловного перехода goto. Как и переменные, метки должны быть объявлены. Метки объявляются в разделе меток (label). При использовании метки необходимо указать ее
имя с двоеточием. Переход на метку осуществляется командой goto метка.
Рассмотрим тот же пример, но с использованием условного оператора.
В разделе меток необходимо описать метку. Пусть имя метки beg.
Пример.
label
beg;
begin
{Прочие операторы}
k := 0;
beg :Inc(k,2);
Y := Sqr(k);
If k < 6 then goto beg;
{Прочие операторы}
end;
35
Рекомендация. Использование безусловного оператора goto затрудняет
чтение текста программы программистом, поэтому его применять не рекомендуется.
Отладка программы. При построении сложных программ могут возникать ошибки. Их принято делить на три группы:
1) синтаксические;
2) ошибки времени выполнения;
3) алгоритмические.
Наиболее простые из них синтаксические – ошибки набора текста – они
исправляются в процессе компиляции программы. Ошибки времени выполнения – ошибки, возникающие при несоответствии типов введенных параметров типам используемых переменных, или ошибки вычислений (например,
деление на 0) – отслеживаются так же легко уже при первых запусках программы. Будем считать, что программа запускается из оболочки Delphi. После возникновения такой ошибки необходимо нажать «Ok» в окне сообщения
об ошибке, а затем завершить выполнение программы – пункт меню
Run/Program reset – или нажать комбинацию клавиш <Ctrl><F2>. При возникновении такой ошибки курсор в программе будет указывать на строку,
вызвавшую ошибку. Наиболее сложно обнаружить алгоритмические ошибки. Программа компилируется без ошибок, не дает ошибок при пробных запусках, но при анализе результатов выясняется, что результат неправильный.
Необходимо вручную «прокрутить» алгоритм – требуется отладка программы.
Для трассировки программы (проверки «логики алгоритма»), т. е. выполнения программы по шагам, необходимо выполнить следующие действия.
В пункте меню выбрать пункт Run/Step over или Run/Trace in to (клавиши
<F8> и <F7> соответственно), команда Run/Trace in to отличаются более детальной трассировкой. Для прекращения трассировки и продолжения выполнения программы в автоматическом режиме необходимо выбрать пункт
Run/Run или нажать <F9>. Остановить программу можно с помощью команды Run/Program reset или нажать комбинацию клавиш <Ctrl><F2>.
Иногда необходимо выполнить трассировку с определенной строки программы. Для этого курсор подводят к интересующей строке и выполняют
команду Run/Run to cursor или нажимают <F4>.
Часто известно возможное место ошибки в алгоритме – тогда используют точку останова. Программист устанавливает на нужной строке курсор и
ставит там точку останова с помощью команды Run/Add Breakpoint или
36
нажав <F5>. Выбранная строка будет отмечена. Для снятия точки останова
необходимо на этой строке снова нажать <F5>. При выполнении программа
дойдет до точки останова, затем программист сможет трассировать программу с помощью <F7> и <F8>. При необходимости можно указать условие
остановки на точке останова (эта настройка осуществляется в окне Breakpoints, пункт меню Run/Add breakpoints).
При выполнении программы по шагам часто необходимо не только проверять правильность «логики алгоритма», но и знать значения некоторых
переменных. Для этого выполняют команду View/Watch/Add watch и вводят
имя интересующей переменной либо подводят курсор к переменной, значение которой необходимо просмотреть, и нажимают <Ctrl><F5>. При трассировке программы в этом случае в окне Watch list можно наблюдать изменение значений интересующих переменных.
3.2. Создание программы «Степенные ряды»
Задача. Необходимо рассчитать значения функций ex и ln(x), заданных с
помощью рядов, с определенной точностью. Точность и аргумент функции
вводятся с клавиатуры. Результат работы сравнить со значениями стандартных функций.
Формулы разложения в ряд экспоненты и логарифма представлены в
табл. 3.4.
Таблица 3.4
Функция
Разложение в ряд
x 2 x3 x 4
...
2! 3! 4!
exp(x)
ex 1 x
ln(x)
x 2 x3 x 4
ln( x 1) x ...
2 3 4
Стандартная
функция
Замечания
Exp(x)
–
Lnxp1(x+1)
Необходим модуль
Math
|x|<1
Примерный вид окна программы представлен на рис. 3.4.
Процесс создания программы проходит по следующему алгоритму:
1. Запустить Delphi.
2. Сохранить проект как «Work3», модуль – «Main».
3. Изменить свойства окна: заголовок «Степенные ряды» Caption.
4. Создать поля ввода для значений X и погрешности Е. Считать, что все
числа целые, порядок чисел задавать программно:
• взять два элемента SpinEdit, вкладка Samples, значок
37
;
Рис. 3.4. Примерный вид окна программы «Ряды Тейлора»
• назвать (свойство Name) один SEValueX – для ввода X, другой SEValueE – для ввода E;
• настроить минимальные значения элементов на 0 MinValue;
• настроить максимальное значение для элемента SEValueX – 9, для
SEValueE – 14 MaxValue;
• изменить шаг дискретизации на 1 Increment.
5. Добавить два элемента для вывода результатов – функция, рассчитанная с помощью ряда, и функция, рассчитанная с помощью стандартной
функции:
• добавить два элемента Edit, вкладка Standard, значок
;
• назвать элементы (свойство Name) для вывода рассчитанной функции
ERFun, для стандартной – ESFun. Изменить свойство Text на 0 (по умолчанию результат равен «0»);
• добавить метки для обозначения вводимых и выводимых величин:
• изменить заголовки (Caption) меток:
○ для поля ввода X – «Введите Х»;
38
○ для ввода погрешности «Введите погрешность 10^-Е» (погрешность
вводить как количество знаков после запятой, например, число 3 будет обозначать погрешность 0,001);
○ для вывода расчетного значения – «Рассчитанная функция»;
○ для вывода стандартного значения функции – «Стандартная функция».
6. Так как будут рассчитываться две функции, добавить переключатель –
какая функция рассчитывается:
• добавить элемент RadioGroup, вкладка Standard, значок
;
• изменить название на RG Name;
• изменить заголовок на «Функция» Caption;
• добавить названия функций «Экспонента» и «Логарифм», запустив
мастер свойства Items:
○ ввести две строки: «Экспонента» и «Логарифм»;
○ установить активным первый элемент (нумерация начинается с 0)
ItemIndex установить в 0.
7. Добавить две кнопки для выхода из программы и для начала расчета:
• добавить элемент Button, вкладка Standard, значок
;
• кнопки назвать: кнопка выхода BExit, кнопка расчета BOk Name;
• изменить заголовки на «Выход» и «Ok» Caption.
8. Окно готово!
9. Запрограммировать выход на кнопку BExit (команда Close);
10. Запрограммировать расчет на кнопке BOk: расчет будет осуществлен
для функции, которая отмечена элементом RG. Первой является функция
«экспонента»:
• проанализировать ряд, по которому осуществляется расчет функции, и
выявить, как получить элемент ряда an, зная элемент an-1. Для расчета экспоненты необходимо элемент ряда умножить на «x / n»;
• для расчета функции потребуются следующие переменные: для хранения значения функции – переменная Func вещественного типа (тип Real);
переменные а и а1 для хранения соответственно n-го и (n+1)-го членов ряда
(также тип Real); переменная е (тип Real) для хранения точности расчета;
переменная x (тип Real) для удобства записи формул; переменная n (тип Integer) – счетчик цикла. Эти переменные необходимо описать в разделе var
процедуры нажатия на кнопку «Оk». Текст процедуры примет вид:
39
procedure TForm1.BOkClick(Sender: TObject);
var
Func : real;
A,A1 : real;
e
: real;
x
: real;
n
: integer;
• присвоить значению переменной x значение элемента SEValueX (свойство Value). При расчете точности необходимо в цикле умножать переменную e на число 0.1 столько раз, сколько требуется знаков после запятой (данное число содержит элемент SEValueE). Для этого после начала процедуры
(оператор begin) ввести следующие строки:
x := SEValueX.Value;
e := 1;
For n := 1 to SEValueE.value do e := e * 0.1;
• выяснить, какая функция рассчитывается, можно по переменной
RG.ItemIndex: если она равна 0, то рассчитывается функция «экспонента»,
если 1 – «логарифм». Для решения такой задачи удобно использовать оператор выбора Case. После расчета точности необходимо добавить:
case RG.ItemIndex of
0 : begin
{Расчет экспоненты}
end;
1 : begin
{Расчет логарифма}
end;
end; {Case}
• для расчета функции можно использовать оператор цикла с постусловием, так как данная функция может быть рассчитана как минимум один раз.
Условием выхода из цикла будет тот факт, что значение очередного члена
ряда станет меньше заданной точности. После комментария {Расчет экспоненты} добавить строки:
Func := 1;
a := 1;
n := 1;
repeat
40
a1 := a * x /n;
Func := Func + a1;
a := a1;
Inc(n);
until(a<e);
• для вывода результатов расчета необходимо преобразовать числа в
строки, так как полем ввода/вывода элемента Edit является строка. После
окончания цикла (строка end {Case}) необходимо добавить следующие строки:
ERFun.Text := FloatToStr(Func);
ESFun.Text := FloatToStr(Exp(x));
11. Расчет экспоненты окончен! Запустить программу, нажав <F9>.
12. Для улучшения программы:
• необходимо написать текст расчета функции «логарифм». Так как ряд
использует в качестве аргумента x+1, удобно использовать функцию Lnxp1,
которая также возвращает натуральный логарифм числа (х+1). Для этого требуется подключить к программе модуль Math. Это можно сделать в разделе
описания модулей после слова implementation. Необходимо добавить:
Uses
Math;
• для автоматического расчета после ввода значений в поля ввода (без
нажатия на кнопку «Ok») необходимо назначить элементам SEValueX и SEValueE событие onChange кнопки BOk и сделать невидимой кнопку BOk
(эти задачи рассмотрены в 2.2).
Индивидуальное задание. Создать демонстрационную программу, используя две функции в соответствии с номером варианта.
Разложение в ряд функций и стандартные функции перечислены в
табл. 3.5, а варианты – в табл. 3.6.
Таблица 3.5
Функция
Разложение в ряд
x 2 x3 x 4
...
2! 3! 4!
ex
ex 1 x
ln(x)
x 2 x3 x 4
ln( x 1) x ...
2
3
4
Sin(x)
sin( x) x
Cos(x)
x3 x5 x 7
...
3! 5! 7!
x 2 x 4 x6
cos( x) 1 ...
2! 4! 6!
41
Стандартная
функция
Замечания
Exp(x)
–
Lnxp1(x+1)
Необходим модуль
Math
|x|<1
Sin(x)
–
Cos(x)
–
Окончание табл. 3.5
Функция
Разложение в ряд
x3 x5 x 7
...
3
5
7
Arctg(x)
arctg( x) x
Sh(x)
x3 x5 x 7
sh( x) x
...
3! 5! 7!
Ch(x)
x 2 x 4 x6
ch( x) 1 ...
2! 4! 6!
π
1 1 1
1 ...
4
3 5 7
№
1
2
3
4
5
F1
Sin
Sin
Sin
Sin
Sin
F2
Cos
ArcTg
Ln
Sh
Ch
№
6
7
8
9
10
F1
Sin
Cos
Cos
Cos
Cos
Стандартная
функция
Замечания
ArcTan(x)
|x|<1
e x e x
Sh(x)
2
–
e x e x
2
–
Ch(x)
Точность ограничить 5 знаками
Pi/4
F2
ArcTg
Ln
Sh
Ch
№
11
12
13
14
15
F1
Cos
ArcTg
ArcTg
ArcTg
ArcTg
F2
Ln
Sh
Ch
№
16
17
18
19
20
Таблица 3.6
F1
F2
Ln
Sh
Ln
Ch
Ln
Sh
Ch
Sh
Итоги. В третьей теме были изучены: стандартные функции; функции
модуля Math; функции преобразования типов; операторы циклов.
При создании демонстрационной программы получены навыки работы
со следующими командами и визуальными компонентами: элемент строка
ввода Edit; элемент список зависимых кнопок RadioGroup.
4. ТИП ДАННЫХ «МАССИВ»
Цели: объявление новых типов данных; генератор случайных чисел;
изучение структуры массив; алгоритмы действий с массивами.
4.1. Теоретические сведения
Новые типы данных. Когда необходимо объявить свой тип данных, то
следует поместить его описание в разделе описания типов. В общем случае
описание типов выглядит так:
Имя = Описание типа;
Здесь:
Имя – имя нового типа;
Описание типа
– описание возможных значений переменных созданного типа.
Замечание. При описании нового типа после имени типа ставится знак
«равно», затем следует описание типа.
42
Примеры.
DayOfWeek = (Monday, Wednesday, Friday);
Day = 1..31;
Тип подобного вида называется перечисляемым, переменные данного
типа могут принимать только перечисленные значения. В примере это одно
из названий дня недели (тип DayOfWeek) или одно из чисел от 1 до 31 (тип
Day). Обратите внимание: перечисляемый тип данных не может содержать
кириллицу! С переменными перечисляемого типа можно использовать функции Pred(переменная) и Succ(переменная), возвращающие предыдущее
(Pred) и последующее (Succ) из допустимых значений.
Примеры.
Пусть объявлены переменные W : DayOfWeek и D : Day. Тогда:
W := Wednesday;
Succ(W); {Оператор вернет значение «Monday»}
D := 5;
Pred(D); {Оператор вернет значение «4»}
Замечания:
1. Значения перечисляемого типа не могут содержать русские буквы.
2. Обращение с помощью оператора Succ или Pred к последнему (для оператора Succ) или первому (для оператора Pred) элементу приведет к ошибке.
Массивы. Массив – это структура данных, которую можно рассматривать как набор переменных одного типа, имеющих общее имя. Массивы
удобно использовать для хранения однородной по своей природе информации, например, таблиц, коэффициентов уравнений, матриц.
Объявление массива. Массив, как и любая переменная, перед использованием должен быть объявлен в разделе объявления переменных. В общем
случае объявление массива выглядит следующим образом:
Имя : array [нижний_индекс..верхний_индекс] of тип;
Здесь:
Имя – имя переменной-массива;
array – зарезервированное слово языка Паскаль, обозначающее, что переменная является массивом;
нижний_индекс,
верхний_индекс – целые константы, определяющие диапазон изменения
индекса элементов массива и неявно – количество элементов массива;
тип – тип элементов массива.
43
Примеры.
day = array [1..30] of Integer; {Объявлен тип – массив 30 целых чисел}
r : array [5..7] of Boolean; {Объявлена переменная – массив трех логических элементов}
Если необходимо объявить несколько элементов типа «массив», целесообразно создать новый тип «массив» в разделе описания типов, а в разделе
описания переменных указать в качестве типа созданный тип. В этом случае
описание массива будет следующим:
type {Раздел описания типов}
ИмяТипа = array [нижний_индекс..верхний_индекс] of тип;
var {Раздел описания переменных}
Имя : ИмяТипа;
При объявлении массива удобно использовать именованные константы.
Пример.
const
N = 1;
E = 5;
type
Arr = array [N..E] of Char;
Массивы могут быть многомерными (обычная размерность массива – не
более трех). Для описания такого массива необходимо указать диапазоны индексов для каждой размерности через запятую.
В общем случае описание, например, двухмерного массива будет таким:
Имя : array [н_и1..в_и1, н_и2..в_и2] of тип;
Здесь:
н_и1, в_и1, н_и2, в_и2 – целые константы, определяющие диапазон
изменения верхнего и нижнего индексов первой и второй размерностей.
Пример.
Coord : array [1..5, 1..3] of Integer;
{Переменная типа массив Coord описывает двухмерный массив}
Чтобы в программе использовать элемент массива, надо указать имя
массива и номер элемента (индекс), заключив его в квадратные скобки. Индекс может быть константой или выражением целого типа.
Примеры.
P := Coord[1,3];
Coord[5,2] := Coord[3,1];
44
Типичные действия с массивом – это вывод массива; ввод массива;
поиск максимального или минимального элемента массива; поиск в массиве
заданного элемента; сортировка массива.
Под выводом массива понимается вывод в диалоговом окне значений
элементов массива. Для вывода всех элементов массива можно использовать
оператор цикла For, при этом параметр цикла может служить в качестве индекса элементов массива.
При выводе элементов массива можно, например, использовать следующие элементы: метка (элемент Label, вкладка Standard, значок
),
строка ввода (Edit, Standard,
).
Под вводом массива понимается получение от пользователя во время
работы программы значений элементов массива. Способ ввода зависит от алгоритма программы – можно вводить каждый элемент массива отдельно, а
можно вводить сразу все элементы, используя, например, элемент строка
ввода и разделяя элементы определенным символом, например пробелом, с
последующей обработкой строки.
Для ввода элементов массива можно использовать: для ввода целых чисел элемент Ввод целых чисел (SpinEdit, Samples,
); при вводе/выводе
массива (особенно двухмерного) очень удобен элемент Таблица (StringGrid,
Additional,
).
Подробно действия с этими элементами при работе с массивами будут
рассмотрены при построении демонстрационной программы.
Генератор псевдослучайных чисел. Если необходимо получить числа,
содержащие случайные значения, то можно использовать генератор псевдослучайных чисел. Существуют два оператора:
1. Randomize – служит для «запуска» генератора чисел (иначе последовательность генерируемых чисел всегда будет одна и та же).
2. Random[(R)] – служит для генерации случайного числа в диапазоне
от 0 до R, включая значение R. Квадратные скобки при описании какого-либо
оператора обозначают, что часть кода, помещенная в них, может не указываться, тогда будут использованы начальные установки для этого оператора.
Если в операторе Random граница R не указана, то числа будут генерироваться в диапазоне от 0 до 1, включая значение 1.
45
Для генерации случайного числа по нормальному распределению необходима функция RandG(m,sd) из модуля Math (задаются математическое
ожидание m и стандартное отклонение sd).
Поиск минимального (максимального) элемента. В качестве примера
рассмотрим одномерный массив целых чисел.
Алгоритм поиска минимального (максимального) элемента массива
довольно очевиден: сначала делается предположение, что первый элемент
массива является минимальным (максимальным), затем остальные элементы массива последовательно сравниваются с этим элементом. Если при
очередной проверке обнаруживается, что проверяемый элемент меньше
(больше) принятого за минимальный (максимальный), то этот элемент
принимается за минимальный (максимальный) и продолжается проверка
оставшихся элементов.
Пример.
Пусть Size – размер массива a, переменная для хранения минимума –
min, максимума – max, I – параметр цикла.
Тогда поиск минимального и максимального значений будет выглядеть
так:
min := a[1];
max := a[1];
For I := 1 to Size do
begin
If a[I] < min then min := a[I];
If a[I] > max then max := a[I];
end;
После окончания цикла в переменной min будет храниться минимальное
значение, а в переменной max – максимальное.
Поиск заданного элемента. Самый простой способ – перебора – последовательный перебор значений массива и сравнение с искомым. Но при
большой размерности массива это приведет к неоправданным затратам времени. Оптимальным является метод бинарного поиска. Алгоритм предполагает, что исходный массив отсортирован. На структурной схеме алгоритма
(рис. 4.1) приняты следующие обозначения: A – массив значений; S – средний индекс массива; N – начальный индекс массива; K – конечный индекс
массива; F – искомое значение.
46
Начало
Начало
N+K
S=
+N
2
Цикл I
I := 1
увеличение
A[S]=F
Цикл J
J := K
уменьшение
Да
Нет
Да
A[S]<F
A[J-1]< A[J]
Да
K := S – 1
N := S + 1
Нет
Нет
Нет J := J + 1
A[J-1] := A[J]
A[J] := A[J-1]
Цикл J
J=I
N>K
Цикл I
I=K
Да
Конец
Конец
Рис. 4.1. Бинарный поиск
Рис. 4.2. «Пузырьковая сортировка»
Сортировка данных. Для ускорения поиска, как уже отмечалось, удобно использовать отсортированный массив. Рассмотрим алгоритмы сортировки данных. Наиболее популярным является «метод пузырька». В основе алгоритма лежит обмен соседних элементов массива. Каждый элемент массива,
начиная с первого, сравнивается со следующим, и если он больше следующего, то элементы меняются местами. Таким образом, элементы с меньшими
значениями передвигаются к началу массива («всплывают»), а с большими
значениями – к концу массива («тонут»). Отсюда и название «пузырьковая
сортировка». Процесс сравнения повторяется столько раз, сколько элементов
в массиве минус единица, поэтому при большом количестве элементов процесс сортировки требует много времени. На структурной схеме (рис. 4.2)
приняты следующие обозначения: А – массив; K – конечный индекс массива;
I, J – параметры цикла.
47
4.2. Создание программы «Работа с массивом»
Задача. Необходимо сгенерировать матрицу случайных чисел размерностью 55 и в соответствии с имеющимся шаблоном сформировать итоговый
массив по следующему правилу: если в шаблоне позиция зачернена, то в этой
позиции в итоговую матрицу записывается число из той же позиции из исходной матрицы, иначе записывается 0.
Примерный вид окна программы представлен на рис. 4.3.
Рис. 4.3. Примерный вид окна программы
«Работа с массивами»
Процесс создания программы проходит по следующему алгоритму:
1. Запустить Delphi.
2. Сохранить проект («work4.dpr» и «main.pas»).
3. Настроить окно проекта:
• изменить заголовок окна на «Работа с массивом» Caption;
• сформировать изображение шаблона массива:
○ поместить на форму элемент фигура (элемент Shape, вкладка Additional, значок
);
○ настроить размеры фигуры, чтобы можно было из них построить
квадрат размером 5 на 5 фигур. Для этого изменить свойства фигуры Width –
ширина и Height – высота;
○ скопировать элемент в буфер (<Ctrl><С>);
○ сделать 24 копии (<Shift><V>);
○ разместить квадратики в квадрат 55;
48
○ выделить средний квадрат размером 33 (удерживая <Shift>, щелкать
на нужных квадратиках) – выделенные квадратики будут отмечены рамочкой
;
○ изменить цвет выделенного квадрата на красный (свойство
Shape/Color установить в значение clRed);
• поместить два элемента для хранения массивов:
○ поместить на форму два элемента строковая таблица (StringGrid,
Additional,
), разместив их слева (начальная матрица) и справа (итоговая
матрица) от построенного шаблона;
○ настроить имена этих элементов SGIshod и SGItog для хранения исходного и итогового массивов соответственно (Name);
○ остальные настройки этих двух элементов будут совпадать – выделить
эти два элемента;
○ настроить размеры таблиц (55 – количество квадратиков и заголовки;
итоговый размер 66) (свойства ColCount (количество столбцов) и RowCount (количество строк) установить в значение 6);
○ так как в ячейки будут записаны цифры размером 88 пикселей, изменить размеры ячеек на значение 16 (ширину (DefaultColWidth) и высоту (DefaultRowHeight));
○ изменить размеры (свойства Width и Height установить в значение
110);
○ изменить размер шрифта, используемого в таблицах, на 8 (Font/Size);
○ изменить свойство ScrollBars на ssNone, для того чтобы при выводе
цифр не появлялся скроллер;
• поместить на форму элементы для вывода неотсортированного и отсортированного массивов:
○ для неотсортированного массива использовать элемент метка (Label,
Standard,
);
○ назвать элемент LSort (Name);
○ для отсортированного массива использовать элемент строка ввода
(Edit, Standard,
);
○ назвать элемент ESort (Name);
49
• поместить метки для подписи всех видимых элементов: «Исходный
массив», «Итоговый массив», «Шаблон», «Неотсортированный массив» и
«Отсортированный массив» (Label, Standard,
);
• добавить кнопки запуска расчетов и выхода из программы:
○ добавить два элемента Кнопка (Button, Standard,
);
○ назвать один «BOk» (расчет) и другой – «BExit» (выход) (Name);
• форма готова!
4. Запрограммировать выход на кнопку BExit (команда Close).
5. Запрограммировать свойство формы onActivate для отображения первого результата расчета сразу после запуска программы, т. е. при ее активизации:
• сделать активной форму – щелкнуть на окне на свободном от элементов месте;
• выбрать в Инспекторе объектов на вкладке Events свойство onActivate;
• дважды щелкнуть на нем для начала ввода текста программы;
• ввести раздел переменных и сами переменные: параметры цикла I, J, K;
массивы – исходный MIs, итоговый MIt, для описания шаблона MSh (элементы, отмеченные цветом, будут иметь значение 1, остальные – 0), одномерный массив для сортировки Mass. Необходимо ввести следующие строки
перед оператором begin:
Var
I, J, K
: Integer;
MIs, MIt, MSh
: array [1..5,1..5] of Integer;
Mass
: array [1..25] of Integer;
• перед заполнением массива запустить генератор псевдослучайных чисел – после слова begin добавить оператор Randomize;
• пронумеровать заголовки строк и столбцов цифрами от 1 до 5. Для
этих целей удобно использовать цикл с параметром. При обращении к элементам таблицы (StringGrid) необходимо указать через точку свойство Cells.
Это свойство является двухмерным массивом и позволяет хранить значения
используемого массива. Нумерация индексов массива Cells начинается с 0,
причем нулевые элементы – это элементы заголовков; первый индекс – это
столбец, второй – строка. Текст программы будет следующим:
50
Randomize;
For I := 1 to 5 do
begin
{Элемент таблицы «строка» – требуется преобразование типов}
SGIshod.Cells[0,I] := IntToStr(I); {Пронумеровали строки}
SGIshod.Cells[I,0] := IntToStr(I); {Пронумеровали столбцы}
SGItog.Cells[0,I] := IntToStr(I);
{Пронумеровали строки}
SGItog.Cells[I,0] := IntToStr(I);
{Пронумеровали столбцы}
end;
• проанализировать полученный шаблон – в данном случае структура
массивов представляет собой квадрат и легко описывается циклом с параметром;
• алгоритм обработки массива будет следующим:
○ обнулить массив шаблона;
○ обнулить итоговый массив;
○ заполнить массив шаблона единицами в позициях заданного шаблона
(центральный квадрат размером 33). Также изменить значения для элементов [1,1], [5,5] на значение 1 и [3,3] – на значение 0;
○ заполнить случайными числами из диапазона 1…9 исходный массив,
используя оператор Random, но так как он возвращает числа, начиная от 0,
необходимо к сгенерированному числу прибавлять 1 – команда
«Random(9)+1» как раз и будет генерировать числа от 1 до 9;
○ просматривая исходный массив, в соответствии с правилом заполнить
итоговый массив;
○ отобразить полученный итоговый массив в элементе SGItog;
○ выполнив эти пункты, получим следующий текст программы:
{Обнуляем итоговый массив и массив шаблона}
For I := 1 to 5 do
For J := 1 to 5 do
begin
MSh[I,J] := 0;
MIt[I,J] := 0;
end;
{Заполняем массив шаблона}
For I := 2 to 4 do
For J := 2 to 4 do
51
MSh[I,J] := 1;
MSh[3,3] := 0;
MSh[1,1] := 1;
MSh[5,5] := 1;
{Заполняем итоговый массив и отображаем его}
For I := 1 to 5 do
For J := 1 to 5 do
begin
MIs[I,J] := Random(9)+1;
SGIshod.Cells[I,J] := IntToStr(MIs[I,J]);
end;
{Заполняем по шаблону итоговый массив и отображаем его}
For I := 1 to 5 do
For J := 1 to 5 do
begin
If MSh[I,J] = 1 then MIt[I,J] := MIs[I,J];
SGItog.Cells[I,J] := IntToStr(MIt[I,J]);
end;
{Окончание заполнения массива}
• для реализации алгоритма сортировки массива необходимо:
○ перевести двухмерный массив в одномерный – пусть элемент с индексом [1,1] будет иметь индекс [1]; [1,2] – [2]; [1,3] – [3]; [1,4] – [4]; [1,5] – [5];
[2,1] – [6]; [2,2] – [7] и т. д. Эту операцию также легко выполнить, используя
двойной цикл по параметрам цикла двухмерного массива и внутри цикла изменяя параметр цикла одномерного массива. Текст программы дополнится
после строки «{Окончание заполнения массива}» следующими строками:
k := 0;
For I := 1 to 5 do
For J := 1 to 5 do
begin
Inc(k);
Mass[k] := MIs[J,I];
end;
• вывести массив в поле вывода, задаваемое меткой LSort (сначала строку сделать «пустой», а затем, чтобы цифры при выводе не сливались, добавить после каждой цифры пробел):
52
LSort.Caption := '';
For I := 1 to 25 do LSort.Caption := LSort.Caption+IntToStr(Mass[I])+ ' ';
{Массив еще не отсортирован}
• алгоритм сортировки массива Mass написать самостоятельно. Поместить созданный текст алгоритма после строки {Массив еще не отсортирован}.
6. Для того чтобы программу можно было запускать на расчет многократно, связать команду onClick кнопки BOk с командой onActivate (в поле
команды onClick в Инспекторе объектов выбрать процедуру FormActivate).
7. Запустить программу <F9>.
8. Программа готова!
Индивидуальное задание. Создать демонстрационную программу, используя шаблон в соответствии с номером варианта (рис. 4.4).
Итоги. В четвертой теме были изучены: объявление новых типов данных; генератор случайных чисел; структура «массив»; алгоритмы операций с
массивами.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Рис. 4.4. Варианты заданий
53
При создании демонстрационной программы получены навыки работы с
командами: Randomize, Random и визуальными компонентами: элемент
строковая таблица StringGrid.
5. ГРАФИЧЕСКИЕ ПРИМИТИВЫ
Цели: знакомство с графическими примитивами; печать изображения;
мультипликация; формирование программируемого изображения.
5.1. Теоретические сведения
Графические примитивы. При создании программы может возникнуть
ситуация, когда, используя видимые элементы Delphi, не удается сформировать нужное изображение (это могут быть чертежи, иллюстрации, графики и
т. п.). В этом случае можно использовать программирование изображения.
Вся поверхность окна представляет собой холст, на который программа может выводить графику.
(0,0)
Этот холст задается свойством Canvas, позволяющим выводить графические примитивы (точки, линии,
окружности, прямоугольники и т. п.)
и задавать их характеристики: цвет,
толщину и стиль линий; цвет и вид
(Image1.Width, Image1.Height)
заполнения областей; характеристи(Form1.ClientWidth, Form1.ClientHeight)
ки шрифта при выводе текстовой
Рис. 5.1. Координаты точек холста
информации. Холст представляет сои элемента Image
бой систему координат с началом в
верхнем левом углу – таким образом, увеличение координаты X идет слева
направо, а координаты Y – сверху вниз (рис. 5.1). Холст можно представить
как набор пикселей – начало координат имеет координаты (0,0), а правый
нижний угол окна – (ClientWidth, ClientHeight).
Для рисования графических объектов используют «карандаш» (Pen), а
для заполнения замкнутых областей – «кисть» (Brush). Свойства инструментов Pen и Brush приведены в табл. 5.1.
В табл. 5.2 представлены все стандартные цвета, которые пользователь
может использовать в качестве значений свойства Color.
54
Таблица 5.1
Свойство
Color
Width
Style
Mode
Color
Style
Определение
«Карандаш» – Pen
Цвет линии
Толщина линии
Стиль линии
Режим отображения
«Кисть» – Brush
Цвет закрашиваемой области
Стиль заполнения области
Таблица 5.2
Константа
clAqua
clBlack
clBlue
clCream
Константа
clMedGray
clManeyGreen
clNavy
clOlive
Цвет
Средне-серый
Цвет мяты
Темно-синий
Оливковый
clPurple
Пурпурный
clFuchsia
Цвет
Бирюзовый
Черный
Синий
Кремовый
Темно-серый
(clGray)
Фиолетовый
clRed
clGray
Серый (clDkGray)
clSilver
clGreen
clLime
Зеленый
Салатный
Светло-серый
(clSilver)
Темно-бордовый
clSkyBlue
clTeal
Красный
Серебристый
(clLtDark)
Лазурный (Delphi 6)
Темно-голубой
clWhite
Белый
clYellow
Желтый
clDkGray
clLtGray
clMaroon
Если требуются другие цвета, то можно воспользоваться функцией
RGB(Red, Green, Blue), в качестве параметров которой передаются значения
соответствующего цвета (красного, зеленого, синего) в диапазоне от 0 (значение отсутствует) до 255 (цвет полностью насыщен).
Пример.
RGB(255, 0, 0) – даст чисто красный цвет (clRed);
RGB(100, 100, 100) – даст оттенок серого;
RGB(255, 255, 255) – даст чисто белый цвет (clWhite).
Также полезным может оказаться свойство Pen.Width, устанавливающее толщину рисуемой линии в пикселях. Дополнительную справку по
остальным свойствам «карандаша» и «кисти» можно получить из контекстной справки Delphi.
Рассмотрим графические примитивы: TextOut – вывод текста, Pixels –
вывод точки, LineTo – вывод линии, PolyLine – вывод ломаной, PolyGon –
55
многоугольник, Rectangle – прямоугольник, RoundRec – прямоугольник с
закругленными краями, Ellipse – эллипс, Arc – дуга и Pie – сектор.
TextOut(X,Y:Integer; const Text: String) – вывод текста Text в прямоугольник, имеющий координаты верхнего левого угла X,Y. Стиль (Style),
цвет (Color), название шрифта (Name), размер шрифта (Size) определяются
объектом Font.
Пример.
Font.Name := 'Times New Roman'; {Название шрифта Times New Roman}
Font.Size := 14;
{Размер шрифта 14}
Font.Color := clBlue;
{Цвет шрифта Синий (clBlue)}
Font.Style := [fsBold, fsItalic, fsUnderLine, fsStrikeOut];
{Настройка стиля шрифта указывается в квадратных скобках через запятую: fsBold – жирный, fsItalic – курсив,
fsUnderLine – подчеркнутый, fsStrikeOut – зачеркнутый}
Для настройки фона выводимого текста необходимо настроить цвет кисти (Brush.Color), например системный цвет clBtnFace позволит выводить
фон текста таким же, как фон окна.
Pixels[X,Y:Integer] := цвет – вывод точки с координатами X, Y цветом,
указанным переменной цвет.
Замечание. Все последующие процедуры чертятся цветом, установленным для инструмента «карандаш» – Pen.Color.
LineTo(X,Y:Integer) – рисует линию от текущей точки окна (позиция
курсора) до точки с координатами X и Y. Чтобы установить курсор в определенную точку, необходимо использовать процедуру MoveTo[X,Y:Integer],
которая перемещает курсор в точку с координатами X и Y.
Пример.
MoveTo(0,0);
LineTo(ClientWidth,ClientHeight);
В примере будет проведена линия от левого верхнего угла окна до правого нижнего угла.
PolyLine(array of TPoint) – рисует ломаную кривую по точкам, указанным в массиве точек, соединяя первую со второй, вторую с третьей и т. д. Точки
массива могут быть как перечислены непосредственно в процедуре PolyLine,
так и описаны ранее. Использование процедуры будет понятно из примеров.
Примеры.
1. Точки описаны в процедуре:
56
PolyLine([Point(10,20),Point(20,10),Point(30,20)]);
будет построена ломаная с вершинами в точках, указанных в стандартной
переменной Point, с координатами (10,20), (20,10), (30,20).
2. Для описания массива точек назначим массив PArray, который опишем в разделе описания переменных. Затем необходимо заполнить массив
значениями точек и, наконец, вызвать процедуру PolyLine:
var
PArray : array[1..3] of TPoint;
begin
… {Описание программы}
PArray[1].X := 10;
PArray[1].Y := 20;
PArray[2].X := 20;
PArray[2].Y := 10;
X3
X1,Y1
PArray[3].X := 30;
PArray[3].Y := 20;
Y3
X2,Y2
PolyLine(PArray);
Здесь также будет построена ломаная
Рис. 5.2. Прямоугольник
с теми же координатами вершин, что и в
со скругленными углами
предыдущем случае.
Второй пример, несмотря на громоздкость, в случае многократного использования PolyLine позволит разделить текст, описывающий точки, и
текст построения изображения, что лучше структурирует текст программы.
PolyGon(array of TPoint) – отличается от предыдущей процедуры тем,
что соединяет последнюю точку массива с первой, т. е. получаем замкнутую
фигуру.
Замечание. Все замкнутые фигуры чертятся цветом, установленным для
инструмента «карандаш» – Pen.Color, и заполняются цветом, определенным
для инструмента «кисть» – Brush.Color.
Rectangle(X1,Y1,X2,Y2:Integer) – прямоугольник, имеющий левый верхний угол с координатами (X1,Y1) и нижний правый угол с координатами
(X2,Y2). Если длина X1–Y1 окажется равной X2–Y2, то получится квадрат.
RoundRec(X1,Y1,X2,Y2,X3,Y3:Integer) – вычерчивает прямоугольник
(X1,Y1,X2,Y2), но со cкругленными углами, размер скругления определяется
X3 – диаметром скругления по X и Y3 – диаметром скругления по Y (рис. 5.2).
57
Ellipse(X1,Y1,X2,Y2:Integer) – эллипс, вписанный в прямоугольник с
координатами (X1,Y1,X2,Y2); если это квадрат, то получаем окружность.
Arc(X1,Y1,X2,Y2,X3,Y3,X4,Y4:Integer) – вычерчивает дугу эллипса,
вписанного в прямоугольник с вершинами (X1,Y1,X2,Y2); X3,Y3 определяют
точку начала дуги; X4,Y4 определяют точку конца дуги. Начальная (конечная) точка – это точка пересечения границы эллипса с прямой, проведенной
из центра эллипса в точки с координатами (X3,Y3) и (X4,Y4). Дуга вычерчивается против часовой стрелки от начальной точки к конечной.
Pie(X1,Y1,X2,Y2,X3,Y3,X4,Y4:Integer) – строит сектор. Строится по тем
же правилам, что и дуга, но отличается тем, что сектор – замкнутая фигура,
т. е. имеет цвет заполнения. Дуга и сектор изображены на рис. 5.3.
Дуга
X1,Y1
X3,Y3
X1,Y1
X4,Y4
X3,Y3
X4,Y4
X2,Y2
X2,Y2
Сектор
X1,Y1
X3,Y3
X1,Y1
X4,Y4
X2,Y2
X4,Y4
X3,Y3
X2,Y2
Рис. 5.3. Значения параметров для построения дуги и сектора
Печать изображения. Печать изображения – то же, что и вывод на
экран. Принтер, как и форма, имеет свойство Canvas. Здесь действуют та же
система координат и те же инструменты «карандаш» и «кисть». Отличие состоит лишь в следующем: при печати надо сообщить принтеру, чтобы он
начал и закончил печать. Для этого надо поместить в текст программы все
графические вызовы, которые должны распечатать изображение между командами принтера: Printer.BeginDoc и Printer.EndDoc. Как только принтер
получит команду Printer.EndDoc, он сразу отпечатает изображение.
Для печати необходимо настроить принтер с помощью стандартного окна настройки. Для этого Delphi имеет вкладку наиболее популярных диалогов – Dialogs. На этой вкладке есть и диалоги настройки свойств принтера
58
(значок
) и свойств печати (значок
). Для вызова этих диалогов необходимо
выполнить
команду
Execute.
Например,
команда
PrinterDialogSetup1.Execute откроет стандартное окно настройки принтера
(считается, что на форму помещен элемент настройки печати с именем
PrinterDialog1).
Если при создании программы планируется, что изображение будет печататься, необходимо предусмотреть умножение всех размеров используемых объектов на константу, определяющую различие между размерами окна
и размерами бумаги. Для этих целей необходимо использовать свойства
принтера Printer.PageWidth и Printer.PageHeight, дающие размеры бумаги – ширину и высоту соответственно. Получить коэффициенты пересчета
можно, поделив самые короткие размеры печатаемой страницы на самые короткие размеры отображаемой формы:
Коэффициент =
Printer.PageWidth
Pronter.PageHeight
.
Таким образом, при печати изображения останется только умножать все
размеры на эту константу.
Мультипликация. Под мультипликацией обычно понимают передвижение объекта или изменение его свойств (формы, цвета и т. п.). Сделать
движущийся объект очень просто – достаточно вывести изображение, затем
через некоторое время стереть его и вывести новое. Подобрав время между
выводом изображений, можно добиться плавного изменения изображения.
Для создания задержки в Delphi служит невидимый элемент Timer,
вкладка System, значок
. «Невидимый элемент» означает, что во время
выполнения программы этот элемент виден не будет, поэтому на стадии разработки окна данный значок можно поместить в любое место. Этот элемент
имеет всего три свойства: имя (Name), интервал (Interval) и запрещение/разрешение работы (Enabled). Таким образом, необходимо настроить
интервал перерисовки (значение свойства Interval, заданное в миллисекундах) и разрешить перерисовку (свойство Enabled установить в true). Для запуска событий, которые должны перерисовываться, необходимо обратиться к
свойству onTimer. Картинка будет перерисовываться с частотой, заданной
свойством Interval.
59
Если требуется, чтобы картинка двигалась, при ее программировании
необходимо ввести базовую точку и все координаты рассчитывать от этой
точки. Обычно это делается так: вводятся константы по координатам, которые должны изменяться, и все соответствующие координаты изображения
увеличиваются на это значение.
Пример.
Пусть необходимо передвигать окружность с координатами (5, 5, 10, 10)
по горизонтали. Введем переменную базовой точки по координате X и назовем ее dx. Рисование окружности будет осуществляться командой:
Ellipse(dx+5, 5, dx+10, 10);
Затем в нужный момент старое изображение затирается цветом фона,
изменяются координаты базовой точки и прорисовывается картинка с новыми координатами.
5.2. Создание программы «Графические примитивы»
Задача. Написать программу, формирующую графическое изображение,
используя графические примитивы. Идея программы такая: изображение «голова» имеет «глаза» и «следит взглядом» за перемещением курсора мыши.
Окно программы представлено на рис. 5.4.
Рис. 5.4. Возможный вид экрана программы
«Графические примитивы»
Процесс создания программы проходит по следующему алгоритму:
1. Запустить Delphi.
2. Сохранить проект («work5.dpr», «main.pas»).
3. Настроить вид экрана:
• форму назвать FPaint – свойство Name;
• настроить размеры формы: ширину (свойство Width) и высоту (свойство Height) установить в 600;
60
• форма содержит всего три элемента: контекстное меню (PopupMenu,
Standard,
) в Object Inspector – назвать этот элемент PM (свойство
Name), и два элемента таймер (Timer, System,
) для создания мультфильма – один из них назвать TEyes – таймер для прорисовки глаз и второй
TMig – таймер для прорисовки мигания глаз. Все рисованные элементы создаются программно;
• настроим окно для отображения графики без отображения самого окна:
свойство BorderStyle установить в значение bsNone – рамки у окна нет! Сделаем цвет окна «прозрачным»: свойство TransparentColor установить в значение true – будет использоваться «прозрачный» цвет, свойство TransparentColorValue установить в значение clBtnFace – стандартный цвет окна будет «прозрачный», т. е. все окно «прозрачное»;
• для выхода из программы настроить элемент контекстного меню;
щелкнуть мышкой на этом элементе дважды – откроется «Мастер настройки
меню», ввести в свойстве Caption название пункта меню В&ыход – таким
образом создали контекстное меню для вызова команды Выход;
• установить время обращения к элементам таймера: TEyes будет срабатывать 10 раз в секунду (100 мс) – этого достаточно, чтобы оперативно следить за курсором; так как значения таймера задаются в миллисекундах, убедиться, что значение Interval равно 100; для второго элемента TMig установить интервал 5000 – интервал мигания глаз 5 с.
4. Форма настроена!
5. Запрограммировать выход из программы: команда Close при нажатии
на кнопку пункта контекстного меню Выход.
6. Так как в окне программы нет заголовка, то выход из программы сделан через контекстное меню, но без заголовка нет возможности перемещать
окно программы по экрану! Для осуществления перемещения окна будем
считать, что вся форма – это заголовок окна – окно можно будет перемещать,
«удерживая» мышкой за любую часть окна программы. В тексте программы
необходимо ввести процедуру WMNChitTest. Для этого перейти в текст программы (нажать клавишу <F12>) и вписать после строчки private строчку:
• procedure WMNCHitTest(var Message: TWMNCHitTest);
message WM_NCHITTEST;
• реализовать эту процедуру: выбрать строку procedure WMNCHitTest
и нажать комбинацию строк <Ctrl><Shift><C> – Complete class at cursor –
закончить написание элемента класса;
61
• в созданном автоматически «теле» процедуры вписать:
// унаследовать все свойства предка
inherited;
// дать возможность вызывать контекстное меню по правой кнопке
мыши
if ((GetAsyncKeyState(VK_RBUTTON) and $F000) = 0) and
(Message.Result = htClient) then
// перенаправление команд – вся форма – заголовок
Message.Result := htCaption;
7. Для отслеживания положения курсора потребуется переменная, хранящая последнюю до перемещения мыши позицию курсора:
• после строк:
private
{ Private declarations }
procedure WMNCHitTest(var Message: TWMNCHitTest);
message WM_NCHITTEST;
ввести защищенный раздел класса и там описать переменную:
protected
m_lastPos : TPoint;
8. Сформировать процедуру, которая будет рисовать глаза:
• после строки m_lastPos : TPoint вписать заголовок процедуры:
procedure DrawPupil(const in_eyeRect : TRect);
• реализовать эту процедуру – набрать в теле процедуры код:
const
// ширина зрачка
PUPIL_WIDTH = 50;
// высота зрачка
PUPIL_HEIGHT = 50;
// радиус перемещения зрачка
MOVE_RADIUS = 90;
// дистанция направления взгляда
FULL_DIST = 200;
var
// точка рисования зрачка
eyePos : TPoint;
// направление взгляда
62
eyeDist : integer;
// смещение по x и y
dx, dy : integer;
// зона, занимаемая глазами
pupilRect : TRect;
begin
// нарисовать зрачки
// eyePos присвоить значение точки
{Функция Point берет параметры X и Y и
возвращает значение TPoint, содержащее их.}
eyePos := Point((in_eyeRect.Left + in_eyeRect.Right) div 2,
(in_eyeRect.Top + in_eyeRect.Bottom) div 2);
// задает координаты прямоугольника
{в Delphi функция Rect создает объект TRect (прямоугольник),
для создания прямоугольника необходимо указать 4 координаты или 2
точки.}
pupilRect := Rect(eyePos.X - PUPIL_WIDTH div 2,
eyePos.Y - PUPIL_HEIGHT div 2,
eyePos.X + PUPIL_WIDTH div 2 + 1,
eyePos.Y + PUPIL_HEIGHT div 2 + 1);
// определить позицию глаз
eyePos := ClientToScreen(eyePos);
dx := m_lastPos.X - eyePos.X;
dy := m_lastPos.Y - eyePos.Y;
eyeDist := Round(Sqrt(Sqr(dx) + Sqr(dy)));
// граница перемещения зрачка не превышает диаметр радужки
if (eyeDist > FULL_DIST) then
// изменяет координаты прямоугольника на указанное смещение
{procedure OffsetRect(var Rect: TRect; X, Y: Integer);
изменяет координаты прямоугольника на указанные смещения по X и Y.}
OffsetRect(pupilRect,
MulDiv(dx, MOVE_RADIUS, eyeDist),
{function MulDiv(Number, Numerator, Denominator: Integer): Integer;
умножает Numerator на Number и делит результат на Denominator,
округляя получаемое значение до ближайшего целого.}
MulDiv(dy, MOVE_RADIUS, eyeDist))
63
else
if (eyeDist > 0) then
OffsetRect(pupilRect,
MulDiv(dx, MulDiv(MOVE_RADIUS, eyeDist, FULL_DIST),
eyeDist),
MulDiv(dy, MulDiv(MOVE_RADIUS, eyeDist, FULL_DIST),
eyeDist));
Canvas.Ellipse(pupilRect);
9. Ввести координаты глаз и тела в виде констант точек для удобства
программирования. Для этого после строки {$R *.dfm} ввести следующие
строки:
const
// положение глаз и тела
LEFT_EYE : TRect = (Left:60; Top:85; Right:285; Bottom:310);
RIGHT_EYE : TRect = (Left:325; Top:85; Right:550; Bottom:310);
BOTTOM_EYE : TRect = (Left:188; Top:320; Right:412; Bottom:545);
BODY : TRect = (Left:0; Top:0; Right:600; Bottom:600);
10. Ввести переменную Mig для отслеживания фазы мигания:
• после строки: BODY : TRect = (Left:0; Top:0; Right:600; Bottom:600);
вписать:
var
Mig : Boolean = True;
11. Чтобы осуществить прорисовку изображения сразу при запуске программы, настроить событие прорисовки окна – onPaint (щелкнуть на форму
(FPaint), выбрать свойство onPaint, вкладка Events в Инспекторе объектов),
щелкнуть на этом событии.
12. Запрограммировать рисование:
• назначить область рисования Canvas – набрать после begin текст:
with canvas do //Обращаемся к свойствам холста
begin
//Область рисования
end;
• После строки //Область рисования вписать следующий текст:
// рисуем тело голубым цветом
Brush.Color := clSkyBlue;
Brush.Style := bsSolid;
64
Pen.Color := clSkyBlue;
Pen.Style := psSolid;
Pen.Width := 1;
Canvas.Ellipse(BODY);
// рисуем радужку глаз салатным цветом
Brush.Color := clLime;
Brush.Style := bsSolid;
Pen.Color := clLime;
Pen.Style
:= psSolid;
Pen.Width := 1;
Canvas.Ellipse(LEFT_EYE);
Canvas.Ellipse(RIGHT_EYE);
Canvas.Ellipse(BOTTOM_EYE);
// рисуем зрачки черным цветом
Brush.Color := clBlack;
Brush.Style := bsSolid;
Pen.Style := psClear;
drawPupil(LEFT_EYE);
drawPupil(RIGHT_EYE);
drawPupil(BOTTOM_EYE);
end; // Конец рисования на холсте
Замечание. При программировании сложного изображения следует располагать элементы послойно – сначала те, что расположены на нижнем фоне,
а затем те, что выше.
13. Запрограммировать «мультипликацию» – движение глаз за курсором
и мигание:
• дважды щелкнуть на элементе TMig (будет сформирована процедура
для события onTimer). Ввести нужные переменные (раздел var перед begin)
и записать событие:
// таймер мигания глаза
var
Color1, Color2 : TColor;
Interval
: Word;
begin
if Mig then
begin
65
// если глаз мигает, цвет фона (голубой)
Color1 := clSkyBlue;
Color2 := clSkyBlue;
// интервал мигания 0,2 с
Interval := 200;
end
else
begin
// радужка зеленая
Color1 := clLime;
// зрачки черные
Color2 := clBlack;
// интервал мигания 5 с
Interval := 5000;
end;
with Canvas do
begin
// нарисовать глаза (радужку)
Brush.Color := Color1;
Brush.Style := bsSolid;
Pen.Color := Color1;
Pen.Style := psSolid;
Pen.Width := 1;
Canvas.Ellipse(LEFT_EYE);
Canvas.Ellipse(RIGHT_EYE);
Canvas.Ellipse(BOTTOM_EYE);
// нарисовать зрачки
Brush.Color := Color2;
Brush.Style := bsSolid;
Pen.Style := psClear;
// левый глаз
drawPupil(LEFT_EYE);
// правый глаз
drawPupil(RIGHT_EYE);
// нижний глаз
drawPupil(BOTTOM_EYE);
66
TMig.Interval := Interval;
end;
// фазу мигания сменить
Mig := not Mig;
• запрограммировать «слежение» за курсором – дважды щелкнуть на
элементе TEyes. Ввести переменную и запрограммировать событие:
var
mousePos : TPoint;
begin
mousePos := Mouse.CursorPos;
// отслеживаем и перерисовываем глаза
if (mousePos.X <> m_lastPos.X) or (mousePos.Y <> m_lastPos.Y) then
begin
self.Invalidate;
m_lastPos := mousePos;
end;
14. Так как мы перехватили нажатие мыши для перемещения формы, то
стандартный способ вызова контекстного меню из формы (свойство
PopupMenu) не срабатывает! Необходимо вручную запрограммировать событие нажатия мыши: выбрать у формы событие OnMouseDown и запрограммировать его:
// вызвать контекстное меню в позиции курсора в окне программы
// нажата правая кнопка мыши
if (Button = mbRight) then
mnuPopup.Popup(m_lastPos.X, m_lastPos.Y);
15. Создание программы завершено! Запустить программу – <F9>.
Индивидуальное задание. Придумать изображение средней сложности
(не меньше 20 команд рисования) и запрограммировать его.
Итоги. В пятой теме были изучены: графические примитивы; основы
печати графического изображения; способ программирования мультипликации; диалог настройки принтера; диалог настройки печати.
При создании демонстрационной программы получены навыки работы с визуальным компонентом «таймер», навыки построения сложного
изображения.
67
6. РАБОТА С ТЕКСТОВОЙ ИНФОРМАЦИЕЙ
Цели: изучение работы со строковыми переменными; работа с текстовыми файлами; стандартные диалоговые окна.
6.1. Теоретические сведения
Символы и строки. Для задания в программе символьных переменных
можно использовать стандартный тип языка Паскаль – Char. Значением переменной типа Char может быть любой символ, отображаемый на экране:
буква русского или латинского алфавита, цифра, знак препинания, специальные символы, например, символ клавиши <Enter> («переход на новую строку»). Переменная должна быть объявлена в разделе описания переменных.
Значение переменной заключается в прямые одинарные кавычки: ch := 'Л' –
переменная ch получает значение – символ буквы Л. Переменные типа Char
можно
сравнивать
друг
с
другом,
используя
соотношение:
'0'<'1'<…<'A'<'B'<…<'a'<'b'<…<'А'<'Б'<…<'а'<…<'я'.
Часть символов не имеет буквенных обозначений на клавиатуре. Для их
обозначения необходимо использовать оператор Chr(код), где код – номер
символа, который нужно вывести. Все символы пронумерованы: системные
символы имеют коды 1…31, цифры ('0'…'9') – 48…57, латинские буквы
('A'…'z') – 65…122, русские буквы ('А'…'п') – 128…175, ('р'…'я') – 224…239.
Вместо функции Chr можно использовать оператор #. Для обратной операции – получения номера указанного символа – служит оператор Ord(символ).
Примеры.
Ch := Chr(13) – переменной символьного типа Ch присвоить значение
символа «переход на новую строку».
S := #10 – переменной символьного типа S присвоить значение символа
«конец строки».
V := Ord('5') – переменная целого типа получит значение кода символа
«5» – код символа «5» равен 53.
На базе стандартного типа Char созданы тип «строка» – String и все
производные от него типы (см. 2.1). Далее будем рассматривать стандартный
тип String. Строка представляет собой массив символов, т. е. является описанием array [0..255] of Char. Таким образом, к элементу строки можно обращаться по номеру: если переменная S имеет тип «строка», то S[2] даст второй
символ строки, S[5] – пятый символ строки. По умолчанию максимально доступная длина строки равняется 255 символам. Если необходимо ограничить
68
длину строки, то после описания типа переменной String указывают в квадратных скобках требуемую длину строки.
Примеры.
S : String[15]; – переменная S является строкой с максимально доступной
длиной, равной 15.
Если переменная имеет значение S := 'абвгд', то S[2] даст значение 'б' –
второй символ в строке s.
Строки можно сравнивать друг с другом посимвольно: если символы
строк одинаковы, то такие строки равны; если в одинаковых позициях расположены разные символы, то больше та строка, у которой код символа больше.
Примеры.
'Аб' > 'АБ'
– во второй позиции код символа «б» больше кода «Б»;
'Аб' < 'Аб'
– вторая строка имеет большую длину;
'Аб' = 'Аб'
– строки равны по длине и по составу символов.
Со строками можно выполнять следующие операции:
• Length(строка) – возвращает длину строки, описанной переменной
строка. Команда Length возвращает числовое значение длины строки.
• Delete(строка, позиция, количество) – удаляет из строки количество
символов, начиная с позиции позиция.
• Pos(подстрока, строка) – возвращает позицию вхождения подстроки
подстрока в строку строка. Если в строке нет искомой подстроки, оператор
Pos вернет значение 0.
• Copy(строка, позиция, количество) – копирует из строки строка с позиции позиция количество символов, указанных в переменной количество.
• Insert(подстрока, строка, позиция) – вставляет в строку строка с позиции позиция подстроку подстрока.
Примеры.
Пусть переменная S – строкового типа, имеющая значение «СанктПетербург», и V – переменная целого типа:
V := Length(S) – V получит значение 14;
Delete(S,1,6) – переменная S получит значение «Петербург»;
V := Pos('Петербург',S) – переменная V получит значение 7;
S := Copy(S,7,8) – переменная S получит значение «Петербург»;
Insert('+-',S,7) – строка S получит значение «Санкт-+-Петербург».
Файлы и работа с текстом. Иногда необходимо выводить информацию
не на экран, а в файл или считывать информацию из файла. Для этих целей
69
существует переменная типа file. При ее создании указывается тип файла,
т. е. тип данных, которые будет хранить файл. Для указания типа файла указывают file of тип. Особым является файл для содержания текстовой информации, который описывается как TextFile.
Примеры.
Res : file of char; – переменная Res указывает на файл символов;
T : file of integer; – переменная T указывает на файл целых чисел;
Str : File of String; – переменная Str указывает на файл строк;
Text : TextFile; – переменная Text указывает на текстовый файл.
Замечание. Файл строк и текстовый файл – это не одно и то же. Текстовый файл самостоятельно обрабатывает признак конца строки и переход
на новую строку.
Для связки переменной типа «файл» с конкретным файлом на диске
необходимо использовать оператор AssignFile(переменная, путь_к_файлу).
Примеры.
AssignFile(text, 'document.txt'); – установление связи между переменной
text и файлом «document.txt»;
AssignFile(res, 'a:\chars.dat'); – установление связи между переменной
res и файлом «chars.dat», находящимся в корневой папке диска а:.
Замечание. Для обеспечения возможности запуска программы с разных
папок/компьютеров не следует без необходимости указывать жесткий путь к
файлу, а нужно считать, что файл хранится в текущей папке, или указывать
путь от текущей папки. Данное соглашение позволит переносить программу
на другой компьютер без требования идентичной настройки структуры папок
на двух компьютерах.
Для вывода информации в файл используется оператор
write(переменная_типа_файл, информация)
или writeln(переменная_типа_файл, информация),
Здесь:
переменная_типа_файл – переменная, указывающая на файл, в который
осуществляется вывод информации;
информация – записываемая в файл информация.
Оператор writeln работает только в текстовых файлах, его отличие от
write в том, что после вывода информации курсор в файле переводится на
новую строку.
Команда writeln(переменная_типа_файл) – добавит пустую строку.
70
Пример.
Пусть описана переменная F типа «текст» (F : TextFile), и выводимая
информация хранится в переменных X1 и Y1. Вывод значений этих переменных в файл на разных строках может быть выполнен так: writeln(F,X1);
writeln(F,Y1);
Для считывания информации используется оператор
read(переменная_типа_файл, информация)
или readln(переменная_типа_файл, информация).
Описание этих операторов такое же, как и у операторов вывода. Оператор readln также может быть использован только для считывания информации из текстового файла, при этом предполагается, что считываемые значения находятся на разных строках.
Команда readln(переменная_типа_файл) переведет курсор в файле на
новую строку.
Для работы с файлом необходимо указать операцию, которая будет выполняться с файлом: чтение или запись (здесь не рассматриваются случаи,
когда необходима работа с файлом, позволяющая одновременно и записывать, и считывать информацию). Для текстовых файлов существует еще одна
возможность – открыть файл на последней строке для дописывания информации. Эти операции описываются операторами:
Reset(переменная_типа_файл)
– открыть файл для чтения;
Rewrite(переменная_типа_файл) – открыть файл для записи;
Append(переменная_типа_файл) – открыть файл для дописывания.
Необходимо отметить особенности работы этих операторов. Оператор
Reset открывает файл для чтения; если в момент открытия файла не существует, то это приведет к ошибке. Это же ограничение накладывается и на команду
Append. При открытии для записи (команда Rewrite) уже имеющегося файла
он будет предварительно очищен, т. е. вся информация из него будет удалена;
если файл на момент открытия отсутствовал, то он будет создан.
При возникновении ошибок открытия файла программа выдаст стандартное окно сообщения об ошибке. Для того чтобы самостоятельно учитывать и обрабатывать возможные ошибки при работе с файлами, необходимо:
1. Отключить автоматический контроль работы с файлами – директива
{$I-}; такая команда сообщает компилятору, что автоматическая обработка
исключительных ситуаций при работе с файлами отключена (все директивы
71
компилятора начинаются с последовательности двух значков – «открывающаяся фигурная скобка» и «знак доллара» – и заканчиваются «закрывающейся фигурной скобкой»).
2. Выполнить критическую операцию (открытие, чтение и т. д.).
3. Включить директиву автоматической проверки корректности операций с файлами – директива {$I-}.
4. Проверить результат операции, возвращаемый оператором IOResult.
Если этот оператор возвращает 0, то операция прошла успешно, иначе он
возвращает код ошибки.
5. Проанализировать сообщение оператора IOResult и при необходимости выполнить соответствующие действия. Например, если при открытии
файла для чтения выяснилось, что файл не существует, то нужно создать его
командой Rewrite, а затем снова открыть для чтения.
После окончания работы с файлом необходимо закрыть переменную типа «файл» с помощью команды CloseFile(переменная_типа_файл).
Замечание. Сколько раз файл был открыт (для чтения или для записи),
столько же раз он должен быть закрыт.
При считывании информации из файла необходимо знать, сколько информации можно из него считать. Для этих целей введена переменная
EOF(переменная_типа_файл, читаемая End Of File – конец файла), которая
принимает значение true при достижении конца файла и false – в противном случае. Поэтому процесс считывания информации из файла обычно
осуществляется в цикле до тех пор, пока не достигнут конец файла (если
нет другого условия окончания операции считывания). Для текстовых
файлов существует также переменная, оценивающая, не достигнут ли конец строки – EOLn(переменная_типа_файл, читаемая End Of Line – конец
строки), которая принимает значение true при достижении конца строки и
false – в противном случае.
Для демонстрации последовательности работы с файлом рассмотрим
фрагмент программы посимвольного считывания информации из текстового
файла «document.txt» и подсчета количества символов в файле. Будем считать, что раздел переменных содержит описание переменных: F : TextFile; –
текстовый файл; C : Char; – считываемые символы; I : Integer; – переменная
для подсчета количества символов.
72
Пример.
var
//Раздел описания переменных
F : TextFile;
C : Char;
I : Integer;
begin
AssignFile(F, 'document.txt'); //Связка файла и файловой переменной
{$I-}
//Отключить автоматическую проверку
reset(F);
//Открыть файл для чтения
{$I+}
//Включить автоматическую проверку
If IOResult = 0 then
//Если операция прошла успешно, то
begin
I := 0; //Установить счетчик символов в 0
While Not EOF(F) do //Пока не конец файла
begin
while Not EOLn(F) do //Пока не конец строки
begin
read(F,C);
//Считать очередной символ
Inc(I);
//Увеличить счетчик символов
end;
readln(F); //Перейти к считыванию новой строки
end
end
else
begin
MessageDlg('Ошибка открытия файла', mtError, [mbOk], 0);
//В случае ошибки выдать сообщение об ошибке
end;
end;
В примере для вывода сообщения об ошибке было использовано стандартное диалоговое окно.
Стандартные диалоговые окна. Для вывода различных сообщений
можно использовать стандартные диалоговые окна Delphi. Диалоговые окна
запускаются командой:
MessageDlg(Сообщение, Тип, Кнопки, КонтекстСправки);
73
Здесь:
Сообщение – выводимое сообщение;
Тип – тип сообщения. Оно может быть информационным, предупреждающим или сообщением об ошибке;
Кнопки – список, определяющий число и вид кнопок;
КонтекстСправки – определяет номер экранной справки; так как экранная справка не используется, то необходимо установить значение 0.
Константы, определяющие тип окна сообщения и вид кнопок, перечислены в табл. 6.1.
Таблица 6.1
Константа
mtWarning
Тип сообщения
Сообщение
Внимание
mtError
Ошибка
mtInformation
Информация
mtConfirmation
mtCustom
Запрос подтверждения
Пользовательское окно
Вид кнопок
Обозначение
Да
Нет
Ok
Отмена
Помощь
Прекращение
Повтор
Игнорировать
Все
Константа
mbYes
mbNo
mbOk
mbCancel
mbHelp
mbAbort
mbRetry
mbIgnore
mbAll
Значок
–
Код возврата
mrYes
mrNo
mrOk
mrCancel
mrHelp
mrAbort
mrRetry
mrIgnory
mrAll
При вызове диалогового окна с набором кнопок их константы перечисляются в квадратных скобках через запятую. Для анализа, какая кнопка была
активирована, следует значение, возвращаемое диалоговым окном, присвоить переменной типа word.
Пример.
Пусть необходимо выдать диалоговое окно запроса с тремя кнопками
«Yes», «No» и «Cancel» и проанализировать, какая кнопка была «нажата».
W := MessageDlg('Какую кнопку нажать?', mtConfirmation,
[mbYes, mbNo, mbCancel]);
74
Case W of
mrYes
: {действие, связанное с «нажатием» на кнопку Yes};
mrNo : {действие, связанное с «нажатием» на кнопку No};
mrcancel : {действие, связанное с «нажатием» на кнопку Cancel};
end;
6.2. Создание программы «Редактор текста»
Задача. Написать программу, считывающую посимвольно информацию
из текстового файла, позволяющую отредактировать считанный текст и сохранить файл на диске.
Окно программы представлено на рисунке.
D:\text.txt
Файл
Редактирование
Формат
Вид
Проверка чтения текста
из редактора RichEdit
с подсчетом строк и символов
В файле содержатся 3 строки и
71 символ (а/ов)
Примерный вид окна программы «Работа с текстом»
Процесс создания программы проходит по следующему алгоритму:
1. Запустить Delphi.
2. Сохранить проект («work6.dpr», «main.pas»).
3. Настроить вид экрана:
• для отображения быстрой справки – подсказки видимых элементов окна – необходимо установить свойство формы ShowHint (показывать подсказку) в значение true. Все элементы, размещенные в окне, автоматически
будут иметь свойство ShowHint в значении true;
75
• в качестве дизайна окна использовать «главное меню» и панель «горячих клавиш». Поместить панель на форму и настроить ее свойства:
○ поместить панель (элемент Panel, вкладка Standard, значок
);
○ изменить заголовок на '' Caption;
○ изменить высоту панели так, чтобы она была чуть больше кнопок, которые будут в нее вставлены (Height = 40);
○ настроить панель, чтобы она всегда находилась вверху окна, независимо от его размера Align установить в значение alTop – вверху;
• поместить на экран «горячие кнопки» (SpeedButton, Additional,
).
Такие кнопки обычно не имеют заголовка, а несут функциональную информацию по картинке и контекстной справке. Поместить три такие кнопки:
«Выход», «Открыть файл», «Сохранить файл»:
○ назвать кнопки (Name) соответственно SBExit, SBOpen и SBSave;
○ выбрать картинки для кнопок в соответствии с назначением кнопок
(картинки можно взять из папки кнопок в папке общих программ Borland или
в папке Delphi (папка Images\Buttons))Glyph; можно выбрать следующие
картинки: FileOpen для открытия файла, FileSave для закрытия файла, DoorShot для выхода из программы;
○ назначить подсказки для кнопок: для кнопки SBExit – «Выход из программы»; для SBOpen – «Открыть файл»; для SBSave – «Сохранить файл» Hint;
• создать главное меню:
○ поместить главное меню на форму (MainMenu, Standard,
);
○ этот значок запускает программу «Мастера построения меню» –
щелкнуть на значке для запуска «Мастера»;
○ построить иерархическое меню. Для этого в поле
Файл
ввода набрать название пункта меню («Файл») (Caption),
Открыть
затем сместиться в подменю и ввести названия «Открыть»
Сохранить
и «Сохранить», затем поставить разделитель пунктов – при
Выход
вводе названия поставить «-» (минус);
○ для каждого пункта меню назначить «горячую клавишу»,
т. е. ту комбинацию клавиш, при нажатии которой этот пункт меню будет активизироваться (свойство ShortCut). Назначить такие комбинации (выбрать
из списка): для пункта «Открыть» – <Ctrl><O>; «Сохранить» – <Ctrl><S>;
«Выход» – <Ctrl><Q>;
76
• для открытия файла поместить стандартный диалог открытия файлов:
○ поместить объект открыть файл (Dialogs, OpenDialogs, );
○ дать ему имя ODText (Name);
○ настроить заголовок окна на «Открытие текстового файла» (Title);
○ назначить имя папки, из которой будут открываться файлы по умолчанию, дав ему имя «точка» (.) – текущая папка (папка программы) (InitialDir);
○ настроить фильтр файлов, которые будут открываться (Filter). Это
свойство запустит «Мастера» – слева в окне описание групп файлов (Filter
Name), справа – шаблон группы (Filter). Изменить описание на «Текстовые
файлы», а шаблон – на «*.txt»;
• для сохранения файлов необходимо:
○ поместить на форму элемент диалог сохранения (SaveDialog,
Dialogs, );
○ настроить имя на SDText (Name);
○ остальные свойства настроить, как и у объекта OpenDialog;
• для переключения между режимами чтения файла (посимвольное чтение или чтение сразу всего файла) необходимо:
○ поместить на панель объект независимая метка (CheckBox,
Standard,
);
○ настроить имя на CBChar ( Name);
○ заголовок изменить на «Посимвольно» ( Caption);
○ кнопка активна (выполняется чтение посимвольно) ( Checked установить в true);
• для вывода текста необходимо:
○ на форму поместить элемент примечаний (Memo, Standard,
);
○ настроить имя на MText ( Name);
○ изменить свойство ScrollBars на ssBoth для добавления в поле вывода
текста скроллеров – обеспечение перемещения по тексту, если текст окажется больше окна вывода;
○ очистить окно текста. Выбрать свойство Lines и удалить строку
MText;
○ расположить поле вывода текста на все доступное пространство формы. Для этого изменить свойство Align на alClient;
77
• форма настроена!
4. Приступить к программированию событий:
• запрограммировать выход из программы на кнопку SBExit (Событие
onClick, команда – Close);
• запрограммировать открытие файла на кнопку SBOpen (Событие onClick), добавив следующий текст:
○ в разделе описания переменных процедуры добавить следующие переменные: F – переменная типа текстовый файл для связки с файлом на
диске; C – считываемый символ – переменная типа символ I – переменная
для подсчета количества символов и W – переменная типа целое число для
записи текста в поле MText, так как этот объект не позволяет добавлять
строку посимвольно:
var
F
:
TextFile;
C
:
Char;
I
:
Word;
W
:
Word;
○ технология считывания следующая:
▪ открыть диалог открытия файлов;
▪ получить имя открываемого файла из этого диалога;
▪ открыть файл;
▪ проверить результат открытия файла, в случае ошибки выдать сообщение, иначе приступить к считыванию информации;
▪ при чтении сразу всего файла считать текст,
иначе: пока не конец файла – добавить в поле вывода текста пустую строку; пока не конец строки – считать символ и добавить его к пустой строке;
○ текст, реализующий этот алгоритм:
If ODText.Execute then
//Если в диалоге выбран файл
begin
MText.Clear;
//Очистить поле вывода
AssignFile(F,ODText.FileName); //Связать файл с F
{$I-}
//Отключить проверку
reset(F);
//Открыть файл
{$I+}
//Включить проверку
If IOResult = 0 then
//Файл открыт удачно
begin
78
Form1.Caption := ODText.FileName;
{В заголовке окна отобразить имя открытого файла}
W := 0;
//Счетчик строк
I := 0;
//Счетчик символов
If CBChar.Checked then
//Если посимвольный ввод
begin
while Not EOF(F) do
//Пока не конец файла
begin
MText.Lines.Add('');
//Добавить пустую строку
While Not EOLn(F) do //Пока не конец строки
begin
read(F,C);
//Считать очередной символ
inc(I);
//Увеличить счетчик символов
MText.Lines[W]:=MText.Lines[W]+C;
{Добавить к пустой строке считанный символ}
end;
Inc(W);
//Увеличить счетчик строк
readln(F);
{Перейти к считыванию новой строки}
end;
{Вывести окно с количеством символов в файле}
ShowMessage('Количество символов: '+IntToStr(I));
end
else
//Файл считывается сразу
begin
{Считать файл}
MText.Lines.LoadFromFile(ODText.FileName);
end;
CloseFile(F);
//Закрыть файл
end
else
//Файл не открыть
ShowMessage('Ошибка открытия файла '+ODText.FileName);
{Выдать сообщение об ошибке}
end;
//Конец работы с файлом
В программе виден способ заполнения элемента MText текстом: текст
представляет собой массив строк (свойство Lines) и либо загружается сразу
79
из указанного файла (строка MText.Lines.LoadFromFile(ODText.FileName);),
либо происходит обращение по индексу к нужной строке и заполнение ее
(строка MText.Lines[W]:=MText.Lines[W]+C; – к строке с индексом W добавить считанный символ C, учитывая, что нумерация строк начинается с 0);
○ запрограммировать сохранение введенного или отредактированного
файла на диске кнопкой SBSave (Событие onClick):
▪ ввести следующий текст:
If SDText.Execute then
{Если выбрано сохранение файла}
begin
Mtext.Lines.SaveToFile(SDText.FileName); //Сохранить файл
Form1.Caption := SDText.FileName;
{Изменить заголовок окна на имя сохраненного файла}
end;
5. Для улучшения программы можно выполнить следующее:
а) ввести индикатор изменения текста в поле ввода – как только текст
изменен, отобразить индикатор изменения;
б) при сохранении файла проверять, нет ли уже файла с таким именем, и
выдавать запрос на перезапись.
Например, п. 5а можно выполнить так:
• на форму (на панель) добавить элемент «метка» (Label, Standard,
).
Изменить его свойства:
○ имя изменить на LModify (Name);
○ заголовок – на Текст изменен (Caption);
○ видимость (если текст не изменен, то и индикатор изменения не показывать) установить в значение false (Visible);
• запрограммировать событие onKeyPress элемента MText, выполняемое при нажатии клавиш, и ввести текст:
LModify.Visible := true;
• при сохранении текста (событие onClick кнопки SBSave) после строки
«{изменить заголовок окна на имя сохраненного файла}» добавить строку
изменения состояния индикатора:
LModify.Visible := false;
6. При желании п. 5б запрограммировать самостоятельно. (Рекомендация. Попытаться открыть файл с введенным именем, и, если это удается
(файл существует!), то требуется вывести запрос на перезапись.)
7. Программа готова – запуск <F9>.
80
Индивидуальное задание. Модифицировать созданную программу для
выполнения операции с текстом в соответствии с номером варианта:
1. В считанном из файла тексте подсчитать количество гласных букв.
2. В считанном из файла тексте подсчитать количество согласных букв.
3. Заменить все гласные буквы в тексте на порядковые номера: «а» – 1,
«е» – 2 и т. д.
4. Добавить после каждого слова текста запятую.
5. Подсчитать количество слов в тексте.
6. Найти слово с максимальным соотношением согласные/гласные.
7. Найти в тексте самое длинное слово.
8. Подсчитать все знаки препинания в тексте.
9. Найти в тексте самое длинное предложение.
10. Выводить каждую строчку в обратном порядке.
11. Выводить только нечетные слова текста.
12. Выводить только четные слова текста.
13. Подсчитать количество предложений в тексте.
14. Выводить только те слова, длина которых больше введенного числа.
15. Выводить только те строки, которые содержат введенную подстроку.
16. Каждый символ, считываемый из файла, закодировать кодом символа, после кода ставить знак «;».
17. Выводить каждое считанное предложение с новой строки.
18. Найти предложение с максимальным количеством слов.
19. Удалить из текста введенный фрагмент строки.
20. Заменить в тексте один введенный фрагмент на другой введенный
фрагмент.
Итоги. В шестой теме были изучены: функции языка Delphi для работы
со строками; функции для работы с текстовыми файлами; стандартные диалоговые окна.
При построении демонстрационной программы получены навыки использования новых компонентов: панели; кнопок быстрого доступа – «горячих кнопок»; главного меню окна; диалоговых окон – открытие файла и сохранение файла; элемента независимого выбора.
81
7. РАБОТА С ГРАФИКАМИ
Цель: изучение работы с компонентом TChart, позволяющим строить
графики функций.
7.1. Теоретические сведения
Построение графиков функций. В инженерных расчетах, а также в медицинских исследованиях часто приходится строить разные графики. При
построении графиков функций возникают различные проблемы: большое количество точек построения, требующих либо скроллировать график, либо
масштабировать для возможности просматривать все имеющиеся значения
или видеть общий вид кривой. Также возникает проблема масштабирования
по оси ординат, позволяющего увидеть разброс значений. Данные могут быть
либо взяты из таблицы значений, либо (чаще всего в математических задачах) получены с использованием расчетной формулы.
Для решения подобных задач можно использовать уже рассмотренные
графические примитивы (см. гл. 5), но тогда все возникающие вопросы отображения данных придется решать самостоятельно. Поэтому еще в первых
версиях Delphi появились компоненты, позволяющие упростить процесс построения графиков. Один из таких компонентов – TeeChart, позволяющий
строить различные кривые наподобие используемых, например, в MS Office.
Компонент TChart. Компонент построения графиков может отсутствовать среди компонентов RAD Studio! В этом случае его можно установить
(Trial version) с сайта разработчика:
https://www.steema.com/downloads/vcl
Рассмотрим некоторые основные особенности работы с этим компонентом. (Рассмотрена версия TeeChart Standard
v.2016.17.160129 32bit VCL.)
Рис. 7.1. Заготовка графика
Компонент TChart
может располагаться, например, на вкладке TeeChart Std.
Его необходимо поместить в нужное место
на форме. На форме он будет представлен
сразу заготовкой графика (рис. 7.1).
82
Editing Chart1
Series
Chart
General
Axis
Titles
Legend
Panel
Paging
Walls
3D
Data
Export
Print
View
Add…
Delete
Title…
Clone
Change
Upgrade to Pro version with 100% source code
Close
Рис. 7.2. Мастер настройки TChart
Далее, если щелкнуть мышью дважды на этом элементе, то запустится
«Мастер настройки TChart» (рис. 7.2).
Как видно на рисунке, настроек очень много. Можно настроить почти все, что требуется для построения графика. Это разделы: Series (вид
графика), Chart (настройка свойств графика), Data (данные графика),
Export (экспорт полученного графика) и Print (печать графика). Рассмотрим основные настройки.
Первым разделом является Series. При выборе этого раздела появляются
кнопки управления графиками: Add (добавить график), Delete (удалить график), Title (название данных), Clone (сделать копию настроенного графика) и
Change (изменить тип графика) (рис. 7.2). При выборе кнопки Add появляется окно выбора типа графика (Series), а также становятся доступными использование функций над данными (Functions) и шаблоны сложных графиков (Templates) (рис. 7.3).
83
Рис. 7.3. Раздел Series
В списке можно выделить различные типы диаграмм (табл. 7.1).
Таблица 7.1
Тип диаграммы
Рисунок
Название
Line
Линия
FastLine
Быстрая линия
Horizontal Line
Горизонтальная линия
Bar
Столбцы, пирамиды, конусы
HorizBar
Горизонтальные столбцы
Area
Область
Horizontal Aria
Горизонтальная область
Point
Точка
84
Окончание табл. 7.1
Тип диаграммы
Рисунок
Название
Pie
Сектор эллипса («пирог»)
Arrow
Стрелка
Bubble
Эллипс («пузырь»)
Gantt
Каждая точка – горизонтальный столбик
Shape
Фигура
Можно выбрать диаграмму для выполнения некоторых математических
функций (табл. 7.2).
Тип диаграммы
Таблица 7.2
Математическая функция
Рисунок
Add
Суммирует значения серии
Average
Получает среднее значение
всех значений серии
Divide
Делит значения исходной серии
High
Отображает наибольшее значение
серии
Low
Отображает наименьшее значение
серии
Median
Вычисляет медианное значение серии
Mode
Вычисляет значение исходной серии,
которое повторяется
Multiply
Умножает значения исходной серии
Pareto
Диаграмма Парето – зависимость
серии от серии причин
85
Окончание табл. 7.2
Тип диаграммы
Рисунок
Математическая функция
Smoothing
Сглаживает значения серии
Subset
Выводит часть функции
Subtract
Отображает значение вычитаемых входных
данных в порядке убывания
Y=f(x)
Строит график заданной функции
Выбрав нужный тип графика, можно приступить к настройке параметров. Рассмотрим только основные разделы. Раздел General (основные
настройки) позволяет настроить, как график будет меняться при работе с
мышью (Mouse); при масштабировании (Zoom) и скроллировании (Scroll);
как будет выглядеть курсор мыши (Cursor); шрифт (Fonts); цветовую палитру графика (Palette) и выделение частей графика (Hover).
Раздел Axes (оси) – настройка осей координат (изменение, подписи, сетка и
др.). Titles (заголовки) – подписи к графику. Legend (легенда) – расшифровка
обозначений на графике. Panel (панель) – настройка панели (фона) графика.
Paging (страницы) – разбиение данных на страницы (экраны). Walls (границы) –
границы графика. 3D (объем) – настройка объема графика (позволяет строить
трехмерные поверхности). Data (данные) позволяет заполнить данные графика.
Export (экспорт) – позволяет экспортировать (сохранять) полученный график в
виде картинки или метаданных. Print (печать) – печать полученного графика.
Для программного добавления точек на график используется функция:
function AddXY (Const AXValue, AYValue: Double; Const AXLabel: String;
AColor: TColor) : Longint;
Здесь AXValue, AYValue – значения координат X и Y; AXLabel –
название ряда данных; AColor – цвет графика. Сама функция возвращает позицию в списке значений графика.
Например, если необходимо поместить на график 100 точек, распределенных по синусоиде, то потребуется следующий код (считается, что уже создана серия данных Series1):
for I := 1 to 100 do
Series1.AddXY(0.02*PI*I, Sin(0.02*PI*I), '' , clRed);
86
Коэффициент (0.02) перед X и Y (Sin) позволяет масштабировать график
для более наглядного вывода на экран.
Еще несколько интересных функций TChart будут рассмотрены в примере.
7.2. Создание программы «Электрокардиограмма»
Задача. Написать программу, считывающую данные электрокардиограммы, предварительно записанные в текстовый файл.
Окно программы представлено на рис. 7.4.
автоскроллер
Рис. 7.4. Программа отображения сигнала ЭКГ
Процесс создания программы проходит по следующему алгоритму:
1. Запустить Delphi.
2. Сохранить проект («work7.dpr», «main.pas»).
3. Настроить вид экрана:
• изменить заголовок окна на «График сигнала ЭКГ» Caption; вывод
формы в центре экрана: свойство Position установить в poScreenCenter;
• поместить на форму панель (Panel, вкладка Standard). Настроить ее
свойства:
○ Align alRight;
○ Caption '';
• на панель поместить элементы:
87
○ два элемента SpinEdit (вкладка Samples). Назвать их: свойство Name –
верхний SEValueX (элемент для указания числа точек, которые будут отображаться по горизонтали) и нижний SEStepX (элемент указывает шаг изменения
значений элемента SEValueX);
○ элемент ComboBox (вкладка Standard) для возможности отображения
всех данных сразу (масштабировать график в пределах поля вывода графика). Свойство Name заменить на SBAllPoint. Свойство Caption – на «Все доступные измерения». Checked – False;
○ еще один элемент ComboBox для указания автоскроллирования данных на графике. Его свойства: Name – CBAutoScroll; Caption – «Автоскроллирование»; Checked – False;
○ элемент SpinEdit (вкладка Samples) для ввода величины сдвига при
скроллировании. Его свойство Name – SEScroll;
○ элемент UpDown (вкладка Win32) для скроллирования графика. Его
свойства: Name – UDScroll; Orientation – upVertical;
○ поместить кнопку BitBtn (вкладка Additional). Настроить кнопку для
закрытия программы: свойство Kind установить в значение bkClose. Свойство Caption установить в значение «В&ыход»;
• на форму поместить элемент Timer (вкладка System) для осуществления автоскроллирования. Его свойство Name – TScroll;
• на форму поместить элемент для построения графика TChart (вкладка
TChartStd). Его свойства: Name – CEKG; Align – alClient – распахнуто на
всю доступную часть формы.
• Настройка всех основных элементов готова!
• Настроить элемент для построения графика CEKG (поставленный на
форму на предыдущем шаге) – щелкнуть на него мышкой дважды – запустится «Мастер». Настроить этот элемент:
○ добавить график, нажав на кнопку Add в пункте Series;
○ назвать этот график EKG (кнопка Title);
○ настроить цвет графика на красный: Series EKG Format
Format Color выбрать красный цвет;
○ выбрать сплошную линию: Series EKG Format Style выбрать значение Solid;
○ убрать легенду графика: Series EKG General Legends Visible снять галочку;
○ разрешить горизонтальное скроллирование графика: Chart General
Allow Scroll Horisontal;
88
○ настроить масштаб: Chart Axis Left Axis, а также Right Axis,
Top Axis и Depht Axis оставить в значении «Автоматически» свойство
Automatic оставлено с галочкой (масштаб подстраивается автоматически).
А вот в свойстве Bottom Axis галочку со свойства Automatic снять и скорректировать свойство вручную: Min (минимальное значение) – поставить 0, Max
(максимальное значение) – поставить 10000, Increment (шаг изменения свойства) – поставить значение 1000;
○ изменить заголовок графика: Chart Titles написать «Электрокардиограмма»;
○ подписать оси графика: ось ординат Chart -> Axis -> Title для
LeftAxis настроить Style -> Title -> написать «мкВ», так как на графике данные отображаются в микровольтах. Задать угол отображения: Angle установить в 0 и Position в end. Аналогично настроить вторую ось (BottomAxis) –
подпись изменить на «мкс» (данные записаны с частотой одна запись в одну
микросекунду), угол и позицию задать аналогично оси ординат.
4. Форма настроена!
5. Запрограммировать событие активации формы – при активной форме
выбрать в Object Inspector на вкладке Events событие onActivate и щелкнуть по нему. В текст программы вписать событие:
var
I,R : Integer; // значения по X и Y
F : TextFile; // файл с данными
begin
// очистить график
Series1.Clear;
// открыть файл с ЭКГ
AssignFile(F,'EKG.txt');
{$I-}
// открыть для чтения
Reset(F);
{$I+}
// если файл не открыт, закрыть программу
if IOResult <> 0 then
Close;
// начальное значение по X
i := 0;
89
// пока не конец файла
while not EOF(F) do
begin
inc(i);
// увеличить счетчик
readln(F,R); // считать данные из файла
Series1.AddXY(i, R, '' , clRed); // добавить точку в график
end;
CloseFile(F); // закрыть файл
// по горизонтали первые 10000 измерений
SEValueX.Value := 10000;
// шаг изменения горизонтальных значений – 1000 измерений
SEStepX.Value := 1000;
end;
6. Запрограммировать изменение значения в элементе SEValueX, дважды щелкнув по нему. Вписать текст:
// изменять масштабирование графика от начала 0
// до указанного в SEValueX.Value значения
CEKG.Axes.Bottom.Minimum := 0;
CEKG.Axes.Bottom.Maximum := SEValueX.Value;
7. Запрограммировать изменение значения в элементе SEStepX, дважды
щелкнув по нему. Вписать текст:
// установить шаг масштабирования графика
SEValueX.Increment := SEStepX.Value;
8. Для возможности сохранять «старый» масштаб при просмотре всех
значений по оси абсцисс и возможности его восстановить ввести глобальную
переменную Max. Для этого в тексте программы после строки {$R *.dfm} добавить описание этой переменной:
var
Max : Integer;
9. Запрограммировать возможность просмотреть на графике сразу все
значения по оси абсцисс. Дважды щелкнуть на элементе CBAllPoint и вписать текст:
// если выбраны все измерения, то настроить свойство
// отображения графика на автоматическое
// иначе в соответствии со значением SEValueX.Value
CEKG.Axes.Bottom.Automatic := CBAllPoint.Checked;
If CEKG.Axes.Bottom.Automatic then
begin
90
// если значение автоматическое, то запомнить «старое» значение
Max := SEValueX.Value;
// установить в элемент SEValueX.Value максимальное значение
SEValueX.Value := Round(CEKG.Series[0].MaxXValue);
end
else
begin
// вернуть «старое» значение
SEValueX.Value := Max;
// выполнить перепостроение графика
SEValueX.OnChange(Sender);
end;
10. Запрограммировать автоскроллирование графика. Дважды щелкнуть
на элемент TScroll и вписать текст:
// скроллировать график на величину, указанную в SEScroll
CEKG.Axes.Bottom.Scroll(SEScroll.Value);
11. Запрограммировать включение/выключение автоскроллирования.
Для этого щелкнуть дважды на элементе CBAutoScroll и вписать текст:
// разрешить или запретить автоскроллирование
TScroll.Enabled := CBAutoScroll.Checked;
12. Запрограммировать скроллирование графика при изменении значения UPScroll. Скроллирование графика будет изменяться на величину, заданную в элементе SEScroll. Дважды щелкнуть на элементе UPScroll и вписать текст:
// провести скроллирование влево (–) или вправо (+)
if Button = btNext then
CEKG.Axes.Bottom.Scroll(SEScroll.Value)
else
CEKG.Axes.Bottom.Scroll(-SEScroll.Value);
13. Программа готова!
Индивидуальное задание. Модифицировать созданную программу для
выведения графика функции, заданной в зависимости от номера варианта
(табл. 7.3). Обеспечить возможность программно изменять: начальные и конечные значения диапазона на оси абсцисс (по умолчанию назначить начальным значением 0, а конечным – 500); коэффициент k (по умолчанию присвоить k значение 0,02).
91
Таблица 7.3
№
Функция
Условие
1
y sin(k x) (cos(k x))2
–
2
y (cos(k x) sin(k x))2
–
3
y cos(sin(k x)) 2k x
–
4
y cos(k x)(k x)2
–
5
y sin(k x)(k x)2
–
6
y k x cos(k x)
x>0
7
y k x sin(k x)
x>0
sin(k x)
cos(k x)
8
y
9
y k x sin(k x)
10
y
k x
cos(k x)
x>0
11
y
1
cos(k x)
–
12
–
–
y k x 20sin(k x)
–
13
y sin(k x)
cos(k x)
sin(k x 5)
x>0
14
y sin(k x)
sin(k x)
cos(k x 5)
–
2
15
sin(k x)
y
cos(k x)
cos(k x)
y
sin(k x)
2
16
17
y esin(k x) cos(k x)
–
18
y esin(k x)
–
19
y ecos(k x)
–
20
sin( k x )
cos( k x )
–
ye
–
x>0
Итоги. В седьмой теме был изучен компонент TChart, позволяющий без
особого труда строить различные графики функций.
При построении демонстрационной программы получены навыки использования компонента TChart для отображения графика ЭКГ, данные которого предварительно были сохранены в текстовом файле.
92
8. ВЫПОЛНЕНИЕ КУРСОВОЙ РАБОТЫ.
ВАРИАНТЫ РАБОТ
В процессе выполнения курсового проекта студент должен составить алгоритм и написать реализующую его программу.
На защите курсового проекта студент предъявляет работающую программу и отчет.
Отчет должен включать следующие разделы: титульный лист; задание
на курсовое проектирование; основной текст, содержащий словесное описание алгоритма работы программы; структурную схему алгоритма программы; распечатку программы; для расчетных программ – расчет контрольного
примера с помощью программы и выполненный вручную.
Варианты курсовых работ
1. Создание программы расчета биоритмов человека на определенный
срок.
2. Программирование стрелочного таймера.
3. Построение графика электрокардиограммы по заданным параметрам
PQRST.
4. Выдача гороскопа для введенной даты рождения.
5. Построение психодиагностического теста для оценки типа темперамента.
6. Нахождение корней степенного уравнения (показатель степени 4).
7. Преобразование арифметических операций во введенной строке в
польскую запись.
8. Построение строчного калькулятора.
9. Создание программы для статистических расчетов в фармакологии и
токсикологии (использование методов альтернативного анализа).
10. Создание графического редактора.
11. Создание программы выравнивания текста по ширине (справа и слева).
12. Создание программы разбиения слов текста на слоги.
13. Создание программы для расчета статистических показателей в работе практического врача-организатора здравоохранения.
14. Создание программы для расчета показателей, используемых в
пульмонологии.
15. Расчет системы линейных уравнений.
93
16. Создание программы, реализующей простейшие операции (сложение, вычитание, умножение и деление) с комплексными числами.
17. Создание программы для расчетов кардиогемодинамических показателей.
18. Создание программы вычисления показателей работы почек.
19. Создание программы расчета средних показателей эксперимента
(среднее арифметическое, среднее гармоническое, среднее кубическое и др.).
20. Заполнение шахматной доски ходами коня, чтобы конь побывал на
каждом поле.
21. Перевод чисел из одной системы счисления в другую (двоичная, десятичная, шестнадцатеричная, римские числа).
22. Размещение восьми ферзей на шахматном поле так, чтобы ни один
ферзь не оказался под ударом.
23. Написание шифровальщика и дешифровальщика текста.
24. Создание электронного варианта программы «Мадагаскарские шашки».
25. Создание программы для оценки степени соответствия эмпирических и теоретических данных по различным критериям.
26. Создание архиватора и разархиватора файлов.
27. Программа умножения матриц. Размерность матрицы задается.
28. Написание программы создания правильного тетраэдра с возможностью его вращения.
29. Построение самостоятельно пополняющегося словаря перевода с одного языка на другой. (Задается текст; программа, просматривая текст, переводит все слова, имеющиеся в словаре. При отсутствии слова в словаре выдается запрос о его переводе и введенное слово и перевод заносятся в словарь.)
30. Написание программы прохода через вершины графа, используя соединяющие его дуги, при условии, что проходить по дуге можно только один раз.
94
Заключение
Пособие содержит семь тем; каждая тема заканчивается рассмотрением практической задачи, решение которой основано на приведенных теоретических сведениях. Пособие содержит начальные сведения по построению программ, предоставляя студенту исходную информацию по программированию в RAD Studio, являясь основой для решения задач, выполняемых на старших курсах.
Также данное пособие является основой для создания системы управления базами данных (СУБД) психодиагностического назначения, которая будет рассмотрена во втором семестре в курсе «Информационные технологии»
и логически завершит рассмотрение вопросов программирования для создания программ медико-технического назначения.
95
Список рекомендуемой литературы
Архангельский А. Я. Программирование в Delphi 5. 2-е изд. М.: БИНОМ, 2000.
Бельтюков М. В. Информационные технологии: учеб.-метод. пособие.
СПб.: Изд-во СПбГЭТУ «ЛЭТИ», 2019.
Вирт Н. Алгоритмы и структуры данных. СПб.: Невский диалект, 2001.
ГОСТ 19.701-90 (ИСО 5807-85). Схемы алгоритмов, программ, данных и
систем. Условные обозначения и правила выполнения. М.: Изд-во стандартов, 1990.
Дантеманн Д., Мишел Д., Тейлор Д. Программирование в среде Delphi.
Киев: DiaSoft Ltd., 1995.
Иванов Ю. И., Погорелюк О. Н. Обработка результатов медикобиологических исследований на микрокалькуляторах. М.: Медицина, 1990.
Культин Н. Delphi 4. Программирование на языке Object Pascal. СПб.:
БХВ – Санкт-Петербург, 1999.
Сван Т. Delphi 4. Библия разработчика. Киев; М.; СПб.: Диалектика,
1998.
Тюкачев Н. А., Илларионов И. В., Хлебостроев В. Г. Программирование
графики в Delphi. СПб.: БХВ – Санкт-Петербург, 2008.
96
Содержание
Введение ................................................................................................................... 3
1. ЗНАКОМСТВО СО СРЕДОЙ ПРОГРАММИРОВАНИЯ RAD STUDIO ..... 6
1.1. Теоретические сведения .............................................................................. 6
1.2. Создание программы «Моя первая программа» ..................................... 13
2. УСЛОВНЫЕ ОПЕРАТОРЫ ............................................................................. 16
2.1. Теоретические сведения ............................................................................ 16
2.2. Создание программы «Попадание точки в фигуру» .............................. 24
3. ОПЕРАТОРЫ ЦИКЛА...................................................................................... 29
3.1. Теоретические сведения ............................................................................ 29
3.2. Создание программы «Степенные ряды» ................................................ 37
4. ТИП ДАННЫХ «МАССИВ»............................................................................ 42
4.1. Теоретические сведения ............................................................................ 42
4.2. Создание программы «Работа с массивом» ............................................ 48
5. ГРАФИЧЕСКИЕ ПРИМИТИВЫ ..................................................................... 54
5.1. Теоретические сведения ............................................................................ 54
5.2. Создание программы «Графические примитивы» ................................. 60
6. РАБОТА С ТЕКСТОВОЙ ИНФОРМАЦИЕЙ ................................................ 68
6.1. Теоретические сведения ............................................................................ 68
6.2. Создание программы «Редактор текста» ................................................. 75
7. РАБОТА С ГРАФИКАМИ ............................................................................... 82
7.1. Теоретические сведения ............................................................................ 82
7.2. Создание программы «Электрокардиограмма» ...................................... 87
8. ВЫПОЛНЕНИЕ КУРСОВОЙ РАБОТЫ. ВАРИАНТЫ РАБОТ .................. 93
Заключение............................................................................................................. 95
Список рекомендуемой литературы .................................................................... 96
97
Бельтюков Михаил Витальевич
Программирование в среде RAD Studio
для решения медико-технических задач
Учебно-методическое пособие
Редактор Н. В. Кузнецова
––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
Подписано в печать 26.10.20. Формат 60×84 1/16.
Бумага офсетная. Печать цифровая. Печ. л. 6,25.
Гарнитура «Times New Roman». Тираж 77 экз. Заказ
.
––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
Издательство СПбГЭТУ «ЛЭТИ»
197376, С.-Петербург, ул. Проф. Попова, 5
98
