Если у вас возникли сложности с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой - мы готовы помочь.
Предоплата всего
Подписываем
ЛАБОРАТОРНАЯ РАБОТА № 9
ОСНОВЫ ЯЗЫКА OBJECT PASCAL. СОЗДАНИЕ ПРОСТЕЙШИХ ПРОГРАММ
В СРЕДЕ Delphi
1. Цель работы
Изучение основ языка Object Pascal и технологии работы с консольными приложениями в системе Delphi.
2. Основные теоретические положения
Delphi представляет собой систему визуального программирования, называемую также системой RAD (Rapid Application Development – быстрая разработка приложе ний). Разработка приложения состоит из двух взаимосвязанных этапов:
- создание пользовательского интерфейса приложения;
- определение функциональности приложения.
Пользовательский интерфейс приложения определяет способ взаимодействия пользователя и приложения, т. е. внешний вид формы (форм) при выполнении приложения и то, каким образом пользователь управляет приложением. Интер фейс конструируется путем размещения в форме компонентов, называемых интерфейсными компонентами или элементами управления. Создается пользова тельский интерфейс приложения с помощью окна Формы, которое в среде раз работки представляет собой модель формы времени выполнения.
Функциональность приложения определяется процедурами, которые выполня ются при возникновении определенных событий, например, происходящих при действиях пользователя с элементами управления формы. Таким образом, в процессе разработки приложения в форму помещаются ком поненты, для них устанавливаются необходимые свойства и создаются обработ чики событий.
Простейшее приложение. Создадим для примера простейшее приложение. Сразу же после создания нового приложения Delphi предлагает разработчику «пустую» форму. Данная форма не является пустой в буквальном смысле сло ва – она содержит основные элементы окна Windows: заголовок Formx, кнопки сворачивания, разворачивания и закрытия окна, изменения размеров окна и кнопку вызова системного меню окна. Именно эта форма отображается при первом запуске Delphi в окне формы.
Любое приложение Windows выполняется в соответствующем окне. Даже если оно ничего не делает в смысле функциональности, т. е. является пустым, то все равно должно иметь свое окно. Delphi – это среда разработки приложений под Windows, поэтому для любого разрабатываемого приложения автоматически предлагается форма, для которой уже созданы два файла – с описанием и модулем.
Итак, простейшее приложение создается автоматически каждый раз в начале работы над новым проектом и является отправной точкой для дальнейших дей ствий. Это приложение имеет минимум того, что нужно любому приложению, выполняемому в среде Windows, и ни одним элементом больше.
Простейшее приложение представляет собой заготовку или каркас, обеспечивающий разработчика всем необходимым для каждого приложения вообще. Так, не нужно писать свой обработчик событий клавиатуры или драйвер мыши, а также создавать пакет процедур для работы с окнами. Более того, нет необхо димости интегрировать драйвер мыши с пакетом для работы с окнами. Это все уже выполнено создателями Delphi, и каркас приложения представляет собой полностью завершенное и функционирующее приложение, которое просто «ничего не делает».
Поясним, что значит фраза «ничего не делает». Окно (а вместе с ним и прило жение) действительно ничего не делает с точки зрения пользователя – оно не предоставляет функциональности, специфичной для каждого приложения. Вме сте с тем это пустое окно выполняет достаточно большую работу с точки зрения программиста. Например, оно ожидает действий пользователя, связанных с мышью и клавиатурой, и реагирует на изменение своего размера, перемещение, закрытие и некоторые другие команды.
Изнутри Windows представляет собой систему с индексами, контекста ми, обратными вызовами и множеством других сложнейших элементов, которые надо знать, которыми нужно управлять и в которых очень легко запутаться. Од нако поскольку эти элементы имеются в каждом функционирующем приложе нии Windows, достаточно написать их один раз и в дальнейшем уже пользоваться готовыми блоками. Именно это и осуществляет система Delphi, избавляя тем самым программиста от сложной рутинной работы. При конструировании приложения разработчик добавляет к простейшему при ложению новые формы, управляющие элементы, а также новые обработчики событий.
Разработка пользовательского интерфейса приложения. Пользовательский интерфейс приложения составляют компоненты, которые раз работчик выбирает в Палитре компонентов и размещает в Форме, т. е. компо ненты являются своего рода строительными блоками. При конструировании интерфейса приложения действует принцип – «что видите, то и получаете», и разработчик при создании приложе ния видит форму почти такой же, как и при его выполнении.
Компоненты являются структурными единицами и делятся на визуальные (видимые) и невизуальные (системные). При этом понятия «видимый» и «невидимый» относятся только к этапу выполнения, на этапе проектирования видны все компоненты приложения.
К визуальным компонентам относятся, например, кнопки, списки или переключатели, а также собственно форма. Так как с помощью визуальных компонентов пользователь управляет приложением, их также называют управляющими компо нентами или элементами управления. Именно визуальные компоненты образуют пользовательский интерфейс приложения.
К невизуальным компонентам относятся компоненты, выполняющие вспомогательные, но не менее важные действия, например, таймер Timer или набор дан ных Table (компонент Timer позволяет отсчитывать интервалы времени, а ком понент Table представляет собой записи таблицы базы данных). При создании интерфейса приложения для каждого компонента выполняются следующие операции:
• выбор компонента в Палитре компонентов и размещение его в форме;
• изменение свойств компонента.
Разработчик выполняет эти операции в окне Формы, используя Палитру компонентов и Инспектор объектов. Выбор компонента в Палитре компонентов выполняется щелчком мыши на нужном компоненте, например на кнопке Button, в результате чего его значок принимает утопленный (нажатый) вид. Если после этого щелкнуть на свобод ном месте формы, то на ней появляется выбранный компонент, а его значок в Палитре компонентов принимает обычный (ненажатый) вид. Значки компонентов отражают назначение компонентов, и при наличии небольших практических навыков выбор нужного компонента происходит достаточно быстро. Кроме то го, при наведении на каждый компонент указателя мыши отображается всплывающая подсказка с информацией о его назначении.
Обозначения типов объектов в Delphi, в том числе компонентов, начинаются с буквы Т. Иногда типы (TButton, TLabel) используются вместо имен (Button, Label) для обозначения компонентов. После размещения компонента в форме система Delphi автоматически вносит изменения в файлы модуля и описания формы. В описание класса формы (файл модуля формы) для каждого нового компонента добавляется строчка формата <Имя компонента>: <Тип компонента>;
Имя нового компонента является значением его свойства Name, а тип совпадает с типом выбранного в Палитре компонента. Например, для кнопки Button эта строчка первоначально будет иметь вид:
Button: TButton;
Для размещения в форме нескольких одинаковых компонентов удобно перед выбором компонента в Палитре компонентов нажать и удерживать клавишу <Shift>. В этом случае после щелчка мыши в области формы и размещения там выбранного компонента его значок в Палитре остается утопленным, и каждый последующий щелчок в форме приводит к появлению в ней еще одного такого же компонента. Для отмены выбора этого компонента достаточно выбрать дру гой компонент или щелкнуть мышью на изображении стрелки в верхней строке Па литры компонентов.
После размещения компонента в форме можно с помощью мыши изменять его положение и размеры. В случае нескольких компонентов можно выполнять выравнивание или перевод того или иного компонента на передний или задний план. При этом действия разработчика не отличаются от действий в среде обычного графического редактора. По умолчанию компоненты выравниваются в форме по линиям сетки, что определяет флажок Snap to grid (Выравнивать по сетке), входящий в набор пара метров интегрированной среды разработки. По умолчанию шаг сетки равен восьми пикселям, а сетка при проектировании отображается на поверхности формы.
Внешний вид компонента определяется его свойствами, которые становятся доступными в окне Инспектора объектов (Object Inspector, рис. 4.1), когда компонент выделен в форме и вокруг него появились маркеры выделения. Доступ к свойствам са мой формы осуществляется аналогично, однако в выбранном состоянии форма не выделяется маркерами. Для выделения (выбора) формы достаточно щелкнуть в любом ее месте, свободном от других компонентов. В раскрывающемся списке, расположенном в верхней части окна Инспектора объектов, отображаются имя компонента и его тип.
Выбрать тот или иной ком понент и, соответственно, получить доступ к его свойствам можно в спи ске Инспектора объектов (Structure, рис. 4.2). Такой способ выбора удобен в случаях, когда компо нент полностью закрыт другими объектами.
В нижней части окна Инспектора объектов слева приводятся имена всех свойств компонента, которые доступны на этапе разработки приложения. Спра ва для каждого свойства стоит его значение. Отметим, что кроме этих свойств компонент может иметь и свойства, которые доступны только во время выполне ния приложения.
Свойства (Properties) представляют собой атрибуты, определяющие способ отображения и функционирования компонентов при выполнении приложения. Первоначально значения свойств задаются по умолчанию. После помещения компонента в форму его свойства можно изменять в процессе проектирования или в ходе вы полнения приложения.
Управление свойствами в процессе проектирования заключается в изменении значений свойств компонентов непосредственно в окне формы или с помощью Инспектора объектов. Разработчик может изменить значение свойства компонента, введя или выбрав нужное значение. При этом одновременно изменяется соответствующий компонент, т. е. уже при проектировании видны результаты сделанных изменений. Например, при изменении заголовка кнопки (свойство Caption) оно сразу же отображается на ее поверхности.
Для подтверждения нового значения свойства достаточно нажать клавишу <Enter> или перейти к другому свойству или компоненту. Отмена изменений производится клавишей <Esc>. Если введено недопустимое для свойства значе ние, то выдается предупреждающее сообщение, а изменение значения отверга ется. Изменения свойств автоматически учитываются в файле описания формы, используемом компилятором при создании формы, а при изменении свойства Name изменения вносятся и в описание класса формы.
Для таких свойств компонентов как, например, Color (цвет), Caption (заголовок) и Visible (видимость) имеются значения по умолчанию. Для обращения к компоненту в приложении предназначено свойство Name, ко торое образуется автоматически следующим образом: к имени компонента до бавляется его номер в порядке помещения в форму. Например, первая кнопка Button получает имя Button1, вторая - Button2 и т. д. Первоначально от свойства Name получает свое значение и свойство Caption.
Обычно разработчик предпочитает дать компонентам более информативные имена, чем имена по умолчанию. Значения свойств, связанных с размерами и положением компонента (напри мер, Left и Top), автоматически изменяются при перемещении компонента мышью и настройке его размеров. Если в форме выделено несколько компонентов, то в окне Инспектора объектов доступны свойства, общие для всех этих компонентов. При этом сделанные в ок не Инспектора объектов изменения действуют на все выделенные компоненты. Для установки значений свойств в Инспекторе объектов используются подклю чающиеся автоматически редакторы свойств:
• простой (текстовый) – значение свойства вводится или редактируется как обычная строка символов, которая интерпретируется как числовой или стро ковый тип Delphi; используется для таких свойств, как Caption, Left, Height и Hint;
• перечисляемый – значение свойства выбирается в раскрывающемся списке. Список раскрывается щелчком на стрелке, которая появляется при установке указателя мыши в области значения свойства. Используется для таких свойств, как FormStyle, Visible и ModalResuit.
• множественный – значение свойства представляет собой комбинацию значе ний из предлагаемого множества. В окне Инспектора объектов слева от име ни свойства множественного типа стоит знак «+». Формирование значения свойства выполняется с помощью дополнительного списка, раскрываемого двойным щелчком на имени свойства. Этот список содержит перечень всех допустимых значений свойства, справа от каждого значения можно указать True или False. Выбор True означает, что данное значение включается в комбинацию значений, а False – нет;
• объекта – свойство является объектом и, в свою очередь, содержит другие свойства (подсвойства), каждое из которых можно редактировать отдельно. Используется для таких свойств, как Font, Item и Lines. В области значения свойства-объекта в скобках указывается тип объекта, на пример, (TFont) или (TString). Для свойства-объекта слева от имени может стоять знак «+», в этом случае управление его свойствами выполняется так же, как и для свойства множественного типа, т. е. через раскрывающийся список. Этот список в левой части содержит имена подсвойств, а в правой – значения, редактируемые обычным способом. В области значения может отображаться кнопка с тремя точками. Это означает, что для данного свойст ва имеется специальный редактор, который вызывается нажатием этой кноп ки. Так, для свойства Font открывается стандартное окно Windows для уста новки параметров шрифта.
При выполнении приложения значения свойств компонентов (доступных в окне Инспектора объектов) можно изменять с помощью инструкций присваивания, например, в обработчике события создания формы. Так, изменение заголовка кнопки Button1 можно выполнить следующим образом:
Button1. Caption: = ' Закрыть ‘;
Отметим, что есть свойства времени выполнения, недоступные через «Инспектор объектов», с которыми можно работать только во время выполнения приложения. К таким свойствам относятся, например, число записей RecordCount набора данных или поверхность рисования Canvas визуального компонента.
Функциональность приложения. На любой стадии разработки интерфейсной части приложение можно запустить на исполнение. После компиляции на экране появляется форма приложения, которая выглядит примерно так же, как она была сконструирована на этапе раз работки. Форму можно перемещать по экрану, изменять ее размеры, сворачи вать и разворачивать, а также закрывать нажатием соответствующей кнопки в заголовке или другим способом. То есть форма ведет себя, как обычное окно
Реакция на приведенные действия присуща каждой форме и не зависит от назначения приложения и его особенностей. В форме, как правило, размещены компоненты, образующие интерфейс приложения, и задача разработчика – оп ределить для этих компонентов нужную реакцию на те или иные действия поль зователя, например, на нажатие кнопки или выбор переключателя. Эта реакция и определяет функциональность приложения.
Допустим, что при создании интерфейса приложения в форме была размещена кнопка Button1, предназначенная для закрытия окна. По умолчанию эта кнопка получила имя и заголовок Button1, однако заголовок (свойство Caption) посредством окна Инспектора объектов было заменено более осмысленным – «Закрыть». При выполнении приложения кнопку Button1 можно нажимать с по мощью мыши или клавиатуры. Кнопка отображает нажатие визуально, однако никаких действий, связанных с закрытием формы, не выполняется. Подобное происходит потому, что для кнопки не определена реакция на какие-либо дей ствия пользователя, в том числе и на ее нажатие.
Чтобы кнопка могла реагировать на то или иное событие, для него необходимо создать или указать процедуру обработки, которая будет вызываться при воз никновении этого события. Для создания процедуры обработки события, или обработчика, нужно, прежде всего, выделить в форме кнопку и перейти на стра ницу Events (События) окна Инспектора объектов, где указываются все возмож ные для данной кнопки события. Так как при нажатии кнопки возникает событие OnClick, следует создать обра ботчик именно этого события. Нужно сделать двойной щелчок в области значения события OnClick, в результате Delphi автоматически создает в модуле формы за готовку процедуры-обработчика. При этом окно Редактора кода переводится на передний план, а курсор устанавливается в то место процедуры, где программист должен написать код, выполняемый при нажатии кнопки Button1. Поскольку кнопка должна закрывать окно, в этом месте нужно указать Form1.Close или просто Close. Код модуля формы имеет следующий вид:
var
Form1:Tform1;
implementation
{$r *.dfm}
procedure TForm1.ButtonClick (Sender: Tobject);
begin
Form1.Close;
end;
end.
Здесь полужирным начертанием выделен код, набранный программистом; все остальное среда Delphi создала автоматически, в том числе и включение заго ловка процедуры-обработчика в описание класса формы ныли.
Среда Delphi обеспечивает автоматизацию набора кода при вызове свойств и методов объектов и записи стандартных конструкций языка Object Pascal. Так, после указания имени объекта и разделяющей точки автоматически появляется список, содержащий доступные свойства и методы этого объекта. При необхо димости с помощью комбинации клавиш <Ctrl>+<пробел> можно обеспечить принудительный вызов этого списка. Имя выбранного свойства или метода ав томатически добавляется справа от точки. Если метод содержит параметры, то отображается подсказка, содержащая состав и типы параметров.
Перечень стандартных конструкций языка вызывается нажатием комбинации клавиш <Ctrl>+<J>. После выбора требуемой конструкции автоматически до бавляется ее код. Например, при выборе условной инструкции в коде появится следующий текст:
If then
Else
Имя обработчика TForm1.Button1Click образуется прибавлением к имени компонента имени события без префикса On. Это имя является значением события, для которого создан обработчик, в нашем случае – для события нажатия кнопки OnClick. При изменении через окно Инспектора объектов имени кнопки происходит автоматически переименование этой процедуры во всех файлах (.dfm и .pas) проекта.
Аналогично создаются обработчики для других событий и других компонентов. Для удаления процедуры-обработчика достаточно удалить код, который программист внес в нее самостоятельно. После этого при сохранении или компиляции модуля обработчик будет удален автоматически из всех файлов проекта. При удалении какого-либо компонента все его непустые обработчики остаются в модуле формы.
Вместо создания нового обработчика для события можно выбрать существующий обработчик, если такой имеется. Для этого нужно в окне Инспектора объектов щелчком на стрелке в области значения свойства раскрыть список процедур, которые можно использовать для обработки этого события. События объекта тоже являются свойствами и имеют определенный для них тип. Для каждого события можно назначить обработчик, принадлежащий к типу этого события. После выбора в списке нужной процедуры она назначается обработчиком события.
Одну и ту же процедуру можно связать с несколькими событиями, в том числе для различных компонентов. Такая процедура называется общим (разделяемым) обработчиком и вызывается при возникновении любого из связанных с ней событий. В теле общего обработчика можно предусмотреть действия, позволяющие определить, для какого именно компонента или события вызвана процедура, и в зависимости от этого выполнить нужные команды.
Пример №1. Создание элементарного проекта
Компьютерная программа – это набор элементарных программ процессора, представленных в файле в виде последовательности байтов (машинный код). Программа пишется на одном из языков программирования, как обычный текстовый документ. Такой документ называется исходным текстом, исходным документом или исходным кодом программы. Основные команды языка программирования называются операторами и записываются с помощью специальных символов или ключевых слов. Прежде чем начать составлять программу необходимо продумать и записать на бумаге алгоритм ее работы, представляющий собой строгое, формальное и однозначное описание процесса решения задачи. Процесс создания алгоритма – самый важный и порой самый сложный.
После того как задача формализована (составлен алгоритм ее решения) и составлен исходный текст программы, он автоматически переводится в набор инструкций процессора с помощью специальной программы называемой компилятором.
Программирование приложений на языке Delphi будем осуществлять в среде Borland Developer Studio 2006, представляющей собой интегрированную оболочку разработчика, работающего с языками программирования C++ и Delphi.
В среде Delphi for Microsoft Win32 можно создавать консольные приложения практически любой сложности. Исходный текст программы готовится с помощью встроенного редактора исходных текстов, который отличается широкими возможностями цветового выделения различных элементов текста программы и предоставляет возможность быстрого ввода часто встречающихся конструкций. Для создания приложения, необходимо войти в среду Borland Developer Studio 2006 (ярлык в верхней части рис.4.3), загрузить компоненту этой среды Delphi for Microsoft Win32, набрать команду FileèNewèVCL Forms Application – Delphi for Win32 (красные стрелки на рис. 4.1).
В качестве первого примера построим проект (Смотри папку Lst4, файл Project4_1.bdsproj), который позволит вводить имена в элемент управления редактирования, а также добавлять новые имена в список. Кроме того, проект предусматривает возможность сортировки и очистки окна списка, а также закрытие самого окна.
Создание проекта начнем с создания новой формы. С этой целью необходимо выбрать элемент меню FileèNewè «VCL Forms Application – Delphi for Win32» (красные стрелки на рис.1).
Рис. 4.3 Создание консольного приложения (часть 1)
Помещение компонента в форму. Переместите курсор мыши в окно Палитры компонентов (Tool Palette, рис.4.4) и, щелкнув левой кнопкой мыши по значку «+», раскройте нужную вам группу компонентов Standard.
Переместите курсор мыши на компонент элемента управления редактированием (TEdit) и щелкните левой кнопкой мыши. Это позволит выбрать необходимый компо нент. Затем переместите мышь в верхний левый угол окна формы и снова щелкните левой кнопкой мыши. Элемент управления редактированием (Edit) должен теперь оказаться видимым в форме.
Переместите курсор мыши на компонент окно списка - TListBox. Для того чтобы добавить TListBox в форму, переместите курсор мыши куда-нибудь ниже элемента управления редактированием в форме, теперь нажмите и держите левую кнопку мыши при перемещении мыши вниз и влево. Это устанавливает расположение и размер окна спис ка в форме. Когда окно списка станет приблизительно соответствовать нужному разме ру, отпустите левую кнопку мыши. Теперь у вас в форме появится окно списка, кроме уже имеющегося там элемента управления редактированием.
Элементы управления, которые вы помещаете в форму, не будут автоматически «вы равниваться», когда вы их устанавливаете в форме, и после того, как форме появилось несколько элементов их желательно «подравнять». Не беспокойтесь об этом, подравнять элементы управления в форме никогда не поздно. Мы вернемся к этому после того, как установим все кнопки. Выравнивать легче, когда все, что предполагается поместить в форму, уже помещено.
Перемещение серии компонентов одного типа. Добавление кнопок в форму происходит легче, чем добавление элементов управле ния редактированием и окна списка, поскольку Delphi позволяет нам по мещать сразу несколько компонентов одного и того же типа без необходимости выбора компонента из палитры каждый раз. Для того, чтобы добавить четыре кнопки, установите курсор мыши на компонент кноп ки (TButton) в палитре компонентов, затем, удерживая нажатой клавишу Shift на клавиатуре, щелкните левой кнопкой мыши. Это позволяет выбрать компонент кнопки, и сообщает Delphi, что мы собираемся устанавливать в форму более чем одну из них. Отпустите клавишу Shift, переместите курсор мыши туда, куда вы хотите поставить первую кнопку, и щелкните левой кнопкой мыши. Переместите курсор мыши немного вниз, туда, где вы хотите поставить следующую кнопку, и щелкните левой кнопкой мыши еще раз. Повторите то же для третьей и четвертой кнопок. После того, как вы установили четвертую кнопку в форму, переместите курсор мыши на кнопку с изображением стрелочки, которая расположена не первой строке палитры компонентов, и щелкните левой кнопкой мыши. Это «отменяет выбор» компонента кнопки так, что теперь мы не будем добавлять кнопки в форму каждый раз, как только мы щелкаем левой кнопкой мыши.
Преобразование внешнего вида компонентов. Если все сделано правильно, все компоненты находятся «там, где надо», но они разбросаны беспорядочно, и вероятно окно списка не точно того размера, который вам необходим. Это легко поправить, воспользовавшись инструментальными средствами выравнивания Delphi и линиям координатной сетки окна формы. Для того чтобы переместить компонент, установите курсор мыши на компонент, который вы хотите переместить, нажмите и держите левую кнопку мыши. Затем переместите компонент на его новую позицию и отпустите левую кнопку мыши.
Для изменения размера компонента установите курсор мыши на компонент, размер которого вы хотите изменить, и щелкните левой кнопкой мыши. При этом происходит отображение восьми небольших голубых маркеров (рис. 4.5), на границе компонента.
Затем установите курсор мыши на один из маркеров, держите нажатой левую кнопку мыши и переместите мышь так, чтобы увеличить, или уменьшить размер компонента. Когда компонент достигнет нужного размера, отпустите левую кнопку мыши. Маркеры сверху, снизу и по сторонам компонента позволяют перемещать эти края рамки компонента. Маркеры на углах перемещают сразу две стороны рамки, которые пересекаются в этом углу. Вышеуказанных инструкций должно быть достаточно для перемещения и изменения размера окна списка так, чтобы он оказался выровненным по отношению к элементу управления редактированием. Вы можете использовать тот же метод для каждой из четырех кнопок, однако у Delphi имеется средство, позволяющее сделать это гораздо быстрее. Для того чтобы выравнить кнопки, переместите курсор мыши в верхнюю точку формы, выше первой кнопки, которую вы установили в форму, и проведите прямую линию вниз по форме, которая будет пересекать все четыре кнопки. Затем нажмите и держите левую кнопку мыши при перемещении курсора мыши вниз и влево, рисуя пунктирную рамку вокруг четырех кнопок в форме. Расширяйте рамку до тех пор, пока она не включит в себя все четыре кнопки, и затем отпустите левую кнопку мыши. Появившиеся небольшие темно серые квадраты маркеров в каждом углу каждой из четырех кнопок, указывают на то, что четыре кнопки теперь выбраны как группа, и действия над ними будут производиться как над группой. Для того чтобы выравнить кнопки, мы используем средство выравнивания, которое вы можете получить, выбирая EditèAlign (РедактированиеèВыравнивание) из главного меню, или щелкнув правой кнопкой мыши, пока указатель ее находится в форме, и выбирая EditèPositionèAlign из всплывающего меню. Delphi развернет окно диалога выравнивания.
Наша задача выравнить кнопки по левым сторонам и разместить их с равными интервала ми в том пространстве, которое они занимают. Теперь в части окна диалога с названием Horizontal (Горизонтальный) необходимо выбрать «Left sides» (Левые стороны), а в части Vertical (Вер тикальный) необходимо выбрать «Space equally» (Равные интервалы). Нажмите кнопку Ok, и Delphi произведет выравнивание кнопок так, согласно вашим указаниям.
Четыре кнопки все еще должны быть выбраны как группа, поскольку нам необходимо переместить их на их исходную позицию. Просто переместите курсор мыши на один из маркеров одной из кнопок, нажмите и зафиксируйте левую кнопку мыши, и переместите элементы управления на их новую позицию. Когда вы перенесете их туда, где вы хотите их видеть, отпустите левую кнопку мыши. Затем переместите курсор мыши вправо так, чтобы он не попадал на какой-либо компонент, и нажмите левую кнопку мыши. Это освободит элементы управления так, что они больше не будут рассматриваться как группа. Как только вы разместили элементы управления, переместите курсор мыши в нижний левый угол рамки окна формы, нажмите и держите левую кнопку мыши, и изменяй те размер окна формы целиком так, чтобы избавиться от ненужного пространства в окне.
Сохранение результатов проектирования. Предварительно приготовьте отдельную папку, в которой у вас будут храниться рабочие файлы всех ваших приложений в среде Delphi. Существуют два файла, которые нужно сохранять – исходный код модуля и файл проекта. Выберите из главного меню FileèSave All «ФайлèСохранить Все» (рис. 4.1, зеленые стрелки).
Delphi покажет окно диалога сохранения файла Save Unit* (рис. 4.6). В верхней части окна имеется поле ввода с именем «Папка» найдите в нем приготовленную ранее вами папку.
В
нижней части того же окна (рис. 4.6) Delphi покажет поле ввода имен сохраняемых файлов
Имя файла Unit*
Тип файла Delphi Unit (*.pas)
Введите в первую строку окна редактирования, например Unit 4_1 и нажмите «Сохранить», оставив вторую строку без изменения. Delphi сохранит исходный код модуля присвоив ему имя Unit 4_1.pas.
Delphi сохранит файл модуля, а затем покажет другое окно «Save Project As …» (Сохранить Проект Как…) диалога сохранения файла с заголовком
Имя файла Project*
Тип файла Borland Developer Studio Project (*.bdsproj) Введите в первую строку окна редактирования Project4_1 и нажмите «Сохранить», оставив вторую строку без изменения. Delphi сохранит файл проекта присвоив ему имя Project4_1.bdsproj и вернется в окно формы.
Сделав это единожды, вы сможете сохранять проект в любое время, просто нажи мая кнопку Save или Save All на панели инструментальных средств Delphi (рис. 4.1, зеленые стрелки).
Не присваивайте файлу проекта имя идентичное имени файла исходного кода модуля. Такой проект работать не будет. Delphi требует, чтобы эти два имени отличались.
Выполнение программы. Это и есть ваша первая рабочая программа. На самом деле программа ничего не будет делать, но все компоненты будут работать так, как это предполагалось. Для того чтобы протестировать это, просто на жмите F9. Delphi скомпилирует и выполнит вашу программу. Вы можете вводить текст в элемент управления редактированием, пере ходить с помощью клавиши Tab с одного элемента управления на другой, и нажимать на кнопки, переводя их в нажатое состояние и обратно. Когда вы закончите экспериментировать с вашей с программой, нажмите Alt+F4, чтобы возвратиться в Delphi.
Изменение свойств объектов. Теперь, когда у нас есть спроектированный и работающий интерфейс пользователя, нам необходимо сделать так, чтобы интерфейс пользователя действительно что-то делал. Нам также необходимо изменить названия на кнопках и очистить элемент управления редактированием так, чтобы он был пуст после того, как программа загрузится. Все это реализуется в окне Инспектора Объектов.
В первую очередь давайте повысим информативность интерфейсного окна, изменив заголовок самой формы и кнопок на ней присутствующих. С целью изменения заголовка формы, переместим курсор мыши на пустое место в форме (не на компонент) и сделаем щелчок. Это действие выбирает форму как объект, который мы хотим рассмотреть. Затем щелкните на панель заголовка окна Object Inspector, чтобы сделать его активным. Вы увидите свойства формы, отобра женные в окне Object Inspector. В первой строке Object Inspector Вы увидите текущее наименование интерфейсного окна, выделенное жирным шрифтом – Formx. Активизируйте свойства Вашего компонента (Properties), щелкнув клавишей по нему. Раскройте группу свойств компонента Action (Действие), щелкнув по знаку «+». Свойства компонента, входящие в состав данной группы перечислены в левой стороне окна, а их значения в правой. Для того чтобы изменить заголовок формы, щелк ните на свойство Caption (Заголовок) и наберите «Демонстрационное окно №1» в области значения. Текст на панели заголовка окна формы должен измениться, сразу после ввода.
Для того чтобы очистить от текста элемент управления редактированием, щелкните на нем в окне формы, чтобы его выбрать, затем щелкните на панели заголовка окна Инспектора Объектов. Окно Инспектора Объектов отобразит свойства для выбранного элемента управления редактированием. Для того чтобы изменить текст в элементе управления редактированием, щелкните на свойстве Text (Текст) в окне Инспектора Объектов. Это выделит текст, «Editx», который представляет собой текущее значение этого свойства, подсветкой. Нажмите клавишу Delete, чтобы убрать этот текст. При этом также убирается текст элемента управления редактированием в окне формы. Это – единственное изменение, которое мы должны сделать для элемента управления редактированием.
Теперь займемся нашими кнопками. Щелкните на первой кнопке, Button1 (Кнопка1), в окне формы, затем щелкните на панели заголовка окна Инспектора Объектов. Свойства для первой кнопки будут показаны на странице Свойств.
Первая кнопка – кнопка «Добавить». Щелкните на свойстве Caption (Заголовок), введите &Добавить и нажмите Enter. Текст на первой кнопке в окне формы должен измениться на тот, который вы ввели в Инспекторе Объектов. Символ амперсанд указывает Delphi присваивает символу «Д» в «Добавить» статус горячей клавиши – позволяя кнопке быть «нажа той» с клавиатуры, при нажатии Alt+Д. Кроме того Delphi делает букву «Д» подчеркнутой при отображении кнопки (см. рис. 4.12, красная стрелка). Мы хотим, чтобы кнопка «Добавить» была в форме кнопки, нажатой по умолчанию (то есть должна нажиматься каждый раз, когда мы нажимаем Enter при работе с формой), для чего нам необходимо изменить свойство MiscellaneousèDefault (По умолчанию) из False (Ложь) в True (Истина) (см. рис. 4.7).
Чтобы это сделать, щелкните на свойстве Default в окне Инспектора Объектов, затем выполните двойной щелчок на подсвеченном False. Это изменит величину свойства на True. Свой ства типа True/False могут быть переключены двойным щелчком на них (т. е. вы можете переключать значение True/False на противоположное двойным щелчком на свойстве). Обратите внимание, что вокруг кнопки появляется жирная линия – для визуального указания того, что теперь это кнопка нажата по умолчанию. Вторая кнопка – кнопка «Сортировать». Щелкните по этой кнопке в окне формы, затем щелкните на окне Инспектора Объектов. Измените Caption для этой кноп ки на &Сортировать. Повторите данный процесс с третьей и четвертой кнопками, изменяя их Caption соответственно на &Очистить и &Закрыть. Итак, разработка интерфейса пользователя завершена.
Разработка программной части (Папка Lst4, файлы Unit4_1.pas и Project4_1.bdsproj). Теперь, завершив интерфейс пользователя, разработаем программную часть ответных действий, при нажатии на любую из четырех кнопок. Короче говоря, это что-то, что наша программа собирается делать, заключается в следующем: когда нажимается кнопка «Добавить», программа берет текст из элемента управ ления редактированием и добавляет его в окно списка, после чего очищает элемент управления редактированием. Когда нажимается кнопка «Сортировка», программа сортирует и перерисовывает содержимое окна списка. Когда нажимается кнопка «Очистить», окно списка очищается. При нажатии кнопки «Закрыть» интерфейсное окно полностью закрывается. Для того чтобы все это заработало, необходимо написать некоторый код для каждой кнопки. Давайте начнем с кнопки «Добавить».
Нажмите на кнопку «Добавить» в окне формы, затем нажмите на закладку Events (События) в верх ней части окна Инспектор Объектов (рис. 4.8).
Вы должны увидеть список событий, на которые этот компонент может отреагировать. В данном примере нас интересует событие OnClick – функция, которая выполняется при «нажатии» на кнопку. Используйте двойной щелчок в поле значений справа от события OnClick в окне инспектора объектов. Это заставляет Delphi перейти из окна формы в окно модуля.
Курсор вертикальной панели редактирования должен быть позиционирован на том месте, где вам следует ввести код реакции на событие OnClick кнопки «Добавить». Введите следующие две строки, в тело процедуры между словами begin и end (см. рис. 4.9):
Listbox1.Items.Add(Edit1.Text);
Edit1.Text:= ‘’ // где ‘’ – две одинарные кавычки
Рис. 4.9. Фрагмент окна модуля описания процедуры реакции на событие OnClick кнопки «Добавить»
Первая строка добавляет некоторый элемент в окно списка, а вторая строка очищает элемент управления редактированием.
Нажмите клавишу «F12» или щелкните на кнопку «Toggle Form/Unit» (Переключение Форма/Модуль) на панели горячих кнопок (третья кнопка слева в нижнем ряду панели инструментов), чтобы перевести окно формы на передний план. Затем щелкните на кнопке «Сортировка» в окне формы, и выполните двойной щелчок на поле значений события OnClick в окне Инспектора Объектов. Это вновь выведет окно модуля на передний план и позиционирует курсор туда, куда вам следует вставить код для события кнопки OnClick. (Каждая кнопка имеет свое собст венное множество событий, включающее свое собственное событие OnClick.) Введите эту строку кода в окне модуля:
Listbox1.Sorted := True;
Для того чтобы добавить событие OnClick кнопке «Очистить», переведите окно формы на передний план (нажав F12), нажмите на кнопке «Очистить», затем выполните двойной щелчок на поле значения события OnClick в Инспекторе Объектов. Далее введите эти две строки кода в окне модуля:
Listbox1.Clear;
Listbox1.Sorted := False;
Теперь добавим событие OnClick кнопке «Exit», введя всего одну строку в окне модуля: Close; (см. рис. 4.10)
Рис. 4.10 Фрагмент окна модуля описания процедур реакции на события OnClick для кнопок «Сортировать», «Очистить» и «Exit»
Снова переведите окно формы на передний план, нажав F12 (см. рис.13.3), выберите FileèSave Project, чтобы сохранить вашу работу (рис. 4.3, зеленая стрелка).
Рис. 4.11. Расположение компонентов на макете визуального приложения
Сохранение программы. Перед первым запуском программы ее исходный текст необходимо сохра нить. Для этого щелкните на командной кнопке FileèSave All (Сохранить все) или Save As (Сохранить как) на панели инструментов (см. синие стрелки на рис. 4.3). Система Delphi попросит указать место для сохранения главного файла Project4_1. Измените, имя в окошке «Имя файла» и укажите в окошке «Папка» любую подходящую папку. Сохранив свой файл в нужной папке, закройте все приложения: FileèClose All (см. зеленые стрелки на рис. 4.3).
Чтобы откомпилировать и сразу запустить данную программу, достаточно нажать клавишу F9. В папке, где был сохранен файл с исходным текстом, появится испол нимый файл программы – Project1.exe. Программа будет тут же автоматически запущена из среды Delphi. На экране откроется окно консольного приложения. Программа должна работать точно так, как мы описали в начале этого раздела (рис. 4.12).
Для выхода из программы нажмите Alt+F4. Как видите, разработка приложений интерфейса пользователя с помощью Delphi – в основном вопрос проектирования, с весьма небольшим количеством фактического программирования. Есть ситуации, в которых программирование необходимо, но интерфейс пользователя к этому не имеет никакого значения.
Рис.4.12. Порядок расположения информации на визуальном приложении демонстрационного примера №1 после нажатия кнопки «Сортировать»
После окончательной отладки приложения (или какого-либо промежуточного этапа его отладки в нетривиальном случае) необходимо записать отлаженную версию приложения в память энергонезависимого носителя (FileèSave All, рис. 4.3 – зеленная стрелка).
Выход из среды Borland Developer Studio 2006 необходимо осуществлять только после закрытия всех приложений (FileèClose All, рис. 4.3 – синяя стрелка).
Разработка интерфейса пользователя включает элементы управления для операций добавления, перемещения и изменения размеров в форме. Данный пример программы, дает хороший обзор основных шагов, входящих в построение приложения с помощью Delphi.
2.2. Константы и переменные
Область видимости и время жизни.
Такие элементы программы, как константы, переменные, функции и процедуры, могут использоваться только в области их видимости, которая зависит от того места, в котором определен элемент. При определении области видимости используется понятие логического блока. Логический блок состоит из раздела объявлений и составного оператора. В логических блоках размещаются операторы ответственные за реализацию отдельной ветки алгоритма в конкретном модуле. Составной оператор начинается с ключевого слова begin (начало) и заканчивается ключевым словом end (конец). После ключевого слова end всегда ставится точка с запятой (исключением является головной модуль, в котором после end ставится точка).
Область видимости константы, переменной, функции и других элементов, объявленных в головном файле программы, в функции или процедуре, ограничивается тем блоком, в котором элемент объявлен.
Если во вложенном блоке какой-то идентификатор внешнего блока переопределен (т.е. объявлен заново), то в этом вложенном блоке виден только переопределенный идентификатор. Во вложенном блоке, где переменная объявлена повторно, видна только эта новая переменная. А во внешнем блоке видна только внешняя переменная.
Переменные.
Переменная, это, по сути, некоторая область в памяти компьютера, для которой в данной программе предусмотрено уникальное имя и содержимое которой в ходе работы программы может изменяться. Когда переменной присваи вается новое значение, ее старое значение теряется. Все используемые в про грамме переменные должны быть объявлены в разделе описания переменных. При этом не только устанавливается сам факт существования переменной, но и задается ее тип, определяющий, какие значения может принимать данная переменная. Раздел описания переменных может содержать несколько строк, каждая из которых разделена двоеточием. В левой части такой строки содержится идентификатор переменной (либо их перечень разделенных запятыми), а в правой части указывается тип данных, которому принадлежит переменная. Каждая строка в разделе описания переменных завершается символом – точка с запятой. Ключевое слово var присутствует в тексте программы в единственном экземпляре. Число строк переменных, следующих за словом var, не ограниченно:
var a,b,c: real;
Здесь объявлено три переменные типа Real.
Константы и константные выражения. Object Pascal позволяет оперировать в программе объектами внешне похожими на переменные, но значения которых, в отличие от переменных, не изменяются в ходе выполнения программы. Такие объекты называются константами. При этом блокируется возможность их случайного изменения как результат ошибки программиста. Объявление именованной константы является указанием для компилятора заменить во всем тексте идентификатор константы на ее значение. Цель объявления именованных констант – сделать текст программы более осмысленным и обеспечить возможность изменения при необходимости ее значения лишь в одном месте (в разделе объявления констант), а не по всему тексту программы. Константы объявляются с помощью ключевого слова const, с которого начинается раздел объявления констант. После него следуют объявления констант в форме:
<идентификатор константы> = <константное выражение>;
Примеры констант:
Const NAME = ‘Alekc’;
RADIAN = Pi/180; //Коэффициент пересчета градусов в радианы
PI2 = 2*Pi; //удвоенное число Пи
MTMAX = 5.5;
Константные выражения вычисляются компилятором в процессе компиляции и заменяются в выполняемом файле вычисленными значениями, что способствует сокращению времени исполнения программы. Константы, являющиеся целыми числами, записываются в десятичном формате. Константы действительных чисел – в десятичном виде с точкой или с указанием порядка после символа «е». Значения строковых констант заключаются в одинарные кавычки и могут содержать последовательность любых символов. Если строковая константа состоит из нескольких строк, то отдельные строки могут объединяться операцией «+».
const C1 = ‘Начало строки’+’Продолжение строки’;
В значение строковой константы можно включать и различные непечатаемые символы типа #13 «возврат каретки» или #14 «перевод строки» соответствующие коду ASCII.
Типизированные константы.
Типизированные константы, несмотря на свое неудачное название и, несмотря на то, что они объявляются в разделе констант, в действительности являются не константами, а переменными, инициализируемыми при их объявлении, т.е. получающими начальное значение. Типизированные константы могут использоваться для задания начальных значений локальным переменным, а при жела нии – и глобальным переменным. Типизированная константа объявляется выражением:
const <идентификатор> : <тип> = <константное выражение>;
Например:
const MTK: integer = 5;
MTK2: double = 31*Pi/180;
В дальнейшем тексте программы с типизированными константами можно обращаться как с обычными переменными, изменяя, когда требуется, их значения. Впрочем, это можно делать только при включенной опции {$J+} (эта директива компилятора включена по умолчанию). Если же включена директива {$J-}, то изменять во время выполнения значения типизированных констант невозможно. В этом случае они становятся просто именованными константами.
2.3. Простые типы данных
Простые типы данных не содержат в себе других типов и их данные содержат всего одно значение. Простые данные в программе относятся к одному из следующих типов: порядковые, вещественные и строковые типы, а также указатели.
Порядковые типы включают в себя целочисленные, символьные, логические, перечислимые и интервальные типы.
Целочисленные типы.
Целочисленные типы используются для представления целых типов. Это такие типы как: Shortint (1 байт со знаком), Byte (1 байт без знака), Smallint (2 байта без знака), Word (2 байта без знака), Integer (4 байта со знаком), Cardinal (4 байта без знака), Longint (4 байта со знаком), Longword (4 байта без знака), Int64 (8 байтов со знаком). Родовыми типами, т.е. типами, обеспечивающими максимальную производительность, являются Integer и Cardinal.
При увеличении значения переменной, уже имеющей максимальное для данного типа значение, произойдет циклический переход к минимальному значению и наоборот. Для записи целых чисел можно использовать цифры и знаки «+» и «–». При отсутствии знака число считается положительным. Если число записано в 16-ричной системе, то перед ним ставится знак «$» без пробела.
Символьные типы обеспечивают хранение одного символа. К символьным типам относятся: AnsiChar (1 байт без знака), WideChar (2 байта без знака) и Char (1 байт без знака). Тип AnsiChar использует систему кодирования символов ANSI (Американского национального института стандартов), тип WideChar - систему Unicode (международный набор символов). Набор символов Unicode позволяет кодировать, в частности, и символы всех национальных алфавитов. Первые 256 символов Unicode совпадают с колом ANSI. Родовым типом является тип Char, ко торый эквивалентен типу AnsiChar.
Для операций с символами разработаны стандартные функции:
Ord (X) – возвращает порядковый номер значения, принадлежащего одному из порядковых типов;
Chr (X) – возвращает символ с кодом, равным целому значению выражения X;
UpCase (X) – преобразует символ X к верхнему регистру.
Логические типы это типы Boolean, ByteBool, WordBool и LongBool. Из них в программе рекомендуется использовать родовой тип Boolean, остальные типы введены в целях совместимости с другими системами программирования. Тип Boolean представлен двумя возможными значениями: true «истина» и false «ложь».
Перечислимый тип задается непосредственно перечислением всех значений (имен), которые может принимать переменная данного типа. Отдельные значе ния указываются через запятую, а весь список значений заключается в круглые скобки. В Object Pascal допускается образование новых типов данных путем перечисления всех допустимых значений. При этом каждое значение представляет собой некоторый идентификатор, а их перечень заключается в круглые скобки. Например, если в программе описаны переменные, значения которых соответствуют дням недели, то соответствующий тип данных можно представить следующим образом:
Type Day = (Su, Mo, Th, We, To, Fr, St);
...
Var X1, Y1, Z1: Day;
Объявленный здесь тип является перечислимым. Перемен ные X1, Y1, Z1 могут принимать одно из перечисленных значений. Попытка присвоить им любое другое значение вызовет программную ошибку.
Второй возможный вариант определения переменных перечислимого типа X1, Y1, Z1 может быть оформлен следующим образом:
Var X1, Y1, Z1: (Su, Mo, Th, We, To, Fr, St);
Здесь перечислимый тип определяется анонимно, однако первый вариант является предпочтительным, т.к. он более наглядный. Достоинством перечислимых типов является то, что они облегчают контроль значений переменных, т. к. переменной нельзя присвоить не перечисленное предварительно значение. К определенным недостаткам их использования отно сится то, что при вводе и выводе значений перечислимых типов нельзя указы вать имена соответствующих переменных в процедурах ввода/вывода.
Интервальные типы описываются путем задания двух констант, определяющих границы допустимых для данных типов значений. Компилятор для каждой опера ции с переменной интервального типа по возможности проверяет, находится ли значение переменной внутри установленного для нее интервала, и в случае его выхода за границы выдает сообщение об ошибке. На этапе выполнения програм мы при выходе значения интервального типа за границы интервала сообщение об ошибке уже не выдается, однако значение переменной будет неверным.
Интервал можно задать только для порядкового типа, т. е. для любого простого типа, кроме вещественного. Обе определяющие интервал константы должны принадлежать одному из простых типов, а значение первой константы должно быть меньше значения второй. Таким образом, при создании нового типа данных задаются две константы, определяющие диапазон возможного изменения переменной. Приведем два возможных варианта объявления переменных интервального типа.
Первый вариант:
Type
TypeD = 1..31;
TypeY: = – 5..15;
TypeAZ: = ‘A’..’Z’;
…
var
D1: TypeD;
Y1: TypeY;
AZ1: TypeAZ;
Второй вариант:
D1: 1..31;
Y1: - 5..15;
AZ1: ‘A’..’Z’;
Приведенные выше два варианта объявления переменных D1, Y1, AZ1 эквивалентны. Интервальный тип можно задать, определив границы диапазона именами констант:
const min = 1; max = 7;
…
Type NWD = min..max;
…
var day1,day2 : NWD;
В последнем примере переменные day1 и day2 имеют тип NWD и могут принимать значения в интервале от 1 до 7.
Вещественные типы.
Вещественные типы предназначены для работы с действительными числами: Real (8 байт), Real48 (6 байт), Single (4 байта), Double (8 байт), Extended (10 байт), Comp (8 байт) и Currency (8 байт). Родовым типом вещественных чисел является тип Real, который соответствует типу Double. Запись вещественных чисел возможна в формах с фиксированной и с плавающей точкой. Вещественные числа с фиксированной точкой записываются по обычным правилам, т. е. целая часть отделяется от дробной десятичной точ кой. Перед числом может указываться знак «+» или «–». Если знак отсутствует, то число считается положительным. Для записи вещественных чисел с плаваю щей точкой указывается порядок числа со знаком, отделенный от мантиссы символом е (или е). Типы Comp и Currency служат для представления вещественных чисел с фиксированной точкой и введены для точных расчетов денежных сумм. Тип Comp фактически представляет целые числа, но относится к вещественным типам. При присваивании переменной этого типа вещественного значения оно автоматически округляется до ближайшего целого.
Для операций с вещественными числами разработаны стандартные функции:
• Round (X) – округленное значение выражения X;
• Trunc (Х) – целая часть значения выражения X.
Строковые типы.
Строковые типы занимают промежуточное положение между простыми и структурированными типами данных. Строковые типы (строки) представлены следующими типами. Тип ShortString представляет собой строку, которая фактически является массивом из 256 элементов — array[0. .255]. Нулевой байт этого массива (строки) указывает длину строки. Язык Delphi поддерживает также подтипы типа ShortString, максимальная длина которых изменяется в диапазоне от 0 до 255 символов. Они обозначаются целым числом в квадратных скобках, который указывается справа от ключевого слова String. Например, инструкции:
var str25: string [25];
или
type tstr = string [25];
var str25 : tstr;
обеспечивают объявление строковой переменной с именем str25, максимальная длина которой составляет 26 символов, т. е. столько, сколько требует описание типа, плюс 1 байт.
Типы Ansistring и Widestring представляют собой динамические массивы, максимальная длина которых фактически ограничена размером основной памя ти компьютера. В типе Ansistring для символов используется кодировка ANSI, а в типе Widestring – кодировка Unicode.
В наборе символов Unicode каждый символ представляется двумя байтами. Это значит, что в кодировке Unicode строка представляет собой последовательность двухбайтовых слов. Первые 256 символов Unicode соответст вуют карте набора символов ANSI.
Родовым типом является тип string, который может соответствовать как типу ShortString, так и типу Ansistring, что определяется директивой компилятора $н (по умолчанию используется {$н+}, и тип string соответствует типу Ansistring). Так как строки фактически являются массивами символов, для обращения к отдельному символу строки достаточно указать имя строковой переменной и позицию этого символа в квадратных скобках. Основным типом строк широко используемых в настоящее время являются строки с нулевым символом в конце. Этот вид строк поддерживается многими языками программирования и системами. Строки с нулевым символом в конце представляют собой массивы символов с индексами, начинающимися с нуля. В конце такого массива обязательно должен храниться нулевой символ (#0), говорящий об окончании строки. Информация о текущей длине строки содержится в ее нулевом байте, к которому можно обратиться так же, как и к остальным элементам строки, например
j:=ord(m[0]); или i:=ord(n[0]);
где Ord стандартная функция (см. раздел «Символьные типы»).
2.4. Простые и структурированные операторы Object Pascal.
Операторы Object Pascal подразделяются на две группы: простые и структурированные. Простые операторы не содержат в себе других операторов; структурированные включают в себя другие операторы – как простые, так и структурированные. К простым операторам относятся оператор присваивания, оператор перехода (GOTO) и пустой оператор, а к структурированным – составной оператор (BEGIN…END), услов ные операторы (IF и CASE) и операторы цикла (WHILE, REPEAT и FOR).
Простые операторы.
Оператор присваивания записывается в виде:
<P> := <W>;
В состав оператора присваивания входит знак присваивания :=, который делит этот оператор на две части. Левая часть оператора <P> – содержит переменную или типизированную константу любого типа, а в правой части находится выражение <W> (состоящее из идентификаторов кон стант, переменных, функций и знаков операций), которое необходимо вычислить. После вычисления полученное значение присваивается переменной, указанной в левой части оператора. При этом тип переменной должен быть совместим с ти пом вычисленного выражения.
Оператор передачи управления.
Оператор передачи управления имеет вид:
goto mtk,
где mtk – метка, которой помечен оператор в теле программы, выполнение которого последует непосредственно после выполнения оператора goto. Другими словами оператор goto позволяет прервать последовательный ход выполнения операторов и передать управление в произвольную точку кода, помеченную специальной меткой. Метки, на которые может передаваться управление, объявляются ключевым словом Label, после которого следует список меток. Все три элемента данной конструкции: объявление меток, сами метки и операторы goto, должны располагаться в рамках одного блока. Каждая метка может обозначаться допустимым идентификатором или числом от 0 до 9999. Например, следующее объявление
Label mtk1, mtk2, 3;
объявляет три метки: mtk1, mtk2 и 3.
В тексте программы метка отмечает точку, в которую передается управление оператором goto. Метка может располагаться в любом месте блока, как после оператора goto, передающего на нее управление, так и до этого оператора. Надо только иметь в виду; что передача управления извне внутрь цикла может приводить к непредсказуемым последствиям, так что таких ситуаций следует избегать. Не разрешается также передавать управление на метку, расположенную в другом блоке.
Сама точка передачи управления, помечается меткой, после которой ставится двоеточие и следует оператор, на который передается управление. Например:
Mtk1: Read (m);
Пустой оператор.
Пустой оператор не выполняет никаких действий и в тексте программы о его присутствии свидетельствует только один символ «точка с запятой». Нам уже известно, что в конце составного оператора, перед ключевым словом end, точка с запятой необязательна. Однако, в случае, когда рядом со словом end расположена метка, перед меткой обязательно должна присутствовать точка с запятой, назначение которой в данном случае – послужить разделителем между последним реальным оператором и пустым оператором.
Структурированные операторы.
Составной оператор.
Составной оператор представляет собой последовательность некоторых операторов, которые выполняются в том порядке, в каком они содержатся в тексте программы. При этом ключевые слова BEGIN и END являются так называемыми операторными скобками, в которые заключены операторы, вхо дящие в составной оператор. Когда, в зависимости от определенного условия, требуется обеспечить последовательное выполнение некоторого набора опера торов, без составного оператора не обойтись. Составной оператор имеет следующий вид:
begin P1; P2; … ; Pn end;
Здесь P1 – Pn – операторы, образующие составной оператор; ключевые слова BEGIN и END – операторные скобки. Составной оператор может включать другие составные операторы (т.е. составным может быть любой из операторов P1 – Pn, причем допускается любой уровень вложенности).
Пример №2. Вычисление корней квадратного уравнения
В качестве примера рассмотрим программу вычисления корней квадратного уравнения
a · X2 + b · X + c = 0
Для упрощения задачи будем считать, что коэффициент «а» не равен нулю, а дискриминант уравнения (b2 – 4ac) неотрицателен. Назовем наш проект Project4_2 (см. также папку «Lst_4» файл Project4_2.bdsproj).
Для эффективной работы приложения нам понадобятся следующие компоненты: Label, Edit, Button. Компоненты Edit и Button нами рассмотрены в примере №1. Компонент Label, называемый также меткой представляет собой простой текст, не редактируемый в процессе функционирования программы. Он чаще всего используется в качестве заголовка для других компонентов, не имеющих своего свойства Caption.
Для реализации нашего приложения будем использовать следующие компоненты:
- две кнопки Button с текстом в свойстве Caption «Вычислить» и «Exit» (рис. 4.13);
- три однострочных редактора Edit для занесения переменных значений коэффициентов a, b и c;
- семь компонентов Label, имеющих соответствующие записи в свойстве Caption, причем два последних используются для визуализации значений переменных Х1 и Х2. (см. красные стрелки на рис. 4.13).
Раздел описания переменных var представлен пятью идентификаторами типа real (рис.4.13, зеленые стрелки), три из которых коэффициенты уравнения (a,b и c) вводятся пользователем программы, а два оставшихся (Х1 и Х2) корни уравнения – результат решения задачи, получаемый при нажатии на клавишу «Вычислить». Слово real после этого перечня (через двоеточие) указывает на то, что переменные могут принимать только вещественные значения.
При нажатии на кнопку «Вычислить» реализуются следующие действия (рис. 4.13, синие стрелки):
- с помощью функции StrToFloat(x), содержимое редакторов Edit1-Edit3 переводится в формат с плавающей запятой. Полученные значения присваиваются соответственно переменным a, b и c;
- вычисляются значения переменных Х1 и Х2 по соответствующим формулам с использованием стандартных функций возведения в квадрат (Sqr) и извлечения квадратного корня (Sqrt);
- полученные результаты с помощью стандартной функции FloatToStr(X) переводятся в строковый тип и визуализируются через свойство Caption компонентов Label7 и Label8.
Для запуска программы в меню Run выбираем одноименный пункт. В результате программа запускается на выполнение. Результат выполнения программы показан на рис.4.13 (нижний слева).
Загрузочный (исполняемый) файл данной программы имеет то же имя, но с другим расширением: Project4_2.exe (см. папку LST_4).
При этом программа выполняется только в том случае, если в ней нет ошибок. Если же без ошибок не обошлось, курсор позиционирует в месте предполагаемой ошибки (на следующей за ошибочной строкой позиции, которая выделяется красным фоном, см., например, рис 4.14).
Рис. 4.14 Листинг программы с ошибкой
При вводе исходных данных, может возникнуть ситуация их некорректности, например несоответствие вводимого данного, тому типу с которым работает программа. Такое положение недопустимо, т.к. полученный результат будет заведомо неправильным. При обнаружении такой ситуации пользователь, получает от отладчика (Debugger) предупреждающее сообщение (рис.4. 15).
Пусть при вводе коэффициента «а» сделан некорректный ввод типа, например «1.0». Но формат float не работает с точкой в качестве разделителя (в качестве разделителя используется запятая). В связи с этим и появилось предупреждающее сообщение. При этом пользователь может выйти из программы (кнопка Break) или продолжить ее (кнопка Continue).
2.5. Условные операторы IF и CASE
К условным операторам относятся операторы IF и CASE. Условный оператор один из важнейших операторов в Object Pascal, позволяющий изменять последовательность выполнения операторов в зависимости от некоторого условия, представляющего собой логическое выражение. Если значение этого выражения равно true, то выполняется одна группа операторов, если false – другая или не выполняется ничего. Условия это логические выражения, в которых происходит сравнение значений выражений, вызов функций, возвращающих значения типа boolean и комбинирование этих значений с помощью логических операций. В Object Pascal используется шесть операций сравнения данных: = (равно); <> (не равно); > (больше); < (меньше); >= (больше или равно); <= (меньше или равно). Если используются логические операции типа and или or и т. д., то связанные с ними проверки необходимо заключить в круглые скобки:
m = n;
p>3;
(m+n <>p) and (p>=5);
(m - p <> 10) or (N=3) = false;
Условный оператор выбора IF предназначен для выполнения тех или иных действий в зависимости от истинности или ложности некоторого условия. Синтаксис оператора имеет вид:
if Lw then Op1 else Op2; //Перед ключевым словом else точка с запятой не ставится
При выполнении этого оператора сначала вычисляется некоторое логическое выражение Lw (условие), в случае истинности которого выполняется оператор Op1, а в случае ложности – оператор Op2. Использованные здесь ключевые слова if, then и else имеют смысл «если», « то» и «в противном случае» соответственно.
Часто используется сокращенный вариант оператора if.
if Lw then Op1;
Здесь, если условие Lw истинно, выполняется оператор Op1. В противном случае управление просто передается следующему (за оператором Op1) оператору в программе. Можно сказать, что первый вариант оператора if осуществляет выбор между двумя действиями, а второй – между действием и отсутствием действия.
Как правило, в качестве условия используется переменная логического типа (типа boolean) либо один из операторов сравнения. Результат сравнения всегда является значением логического типа.
Во многих программах, в зависимости от некоторого условия, часто требуется выполнить не одно, а последовательность действий. В этом случае необходимо использовать составные операторы begin и end:
if Lw then begin
Op11; Op12; .. ,Op1n
end
else begin
Op21; Op22; .., Op2n
end;
Здесь Op11 – Op1n и Op21 – Op2n – наборы некоторых операторов, образующих составные операторы. Допускается вложенность операторов if.
Пример №3. Определение кратности вводимых чисел
Напишем небольшую программу, которая анализирует вводимые числа с клавиатуры и сообщает, делиться ли введенное число Х1 на Х2, и если нет, показывает остаток от деления и просит осуществить повторный ввод числа (папка «Lst_4» файл Project4_3.bdsproj).
Стандартные функции Int и Frac, используемые в данной программе, возвращают соответственно целую и дробную части от аргумента функции типа real.
Рис. 4.16. Листинг и результаты реализации программы « Определение кратности вводимых чисел» (проект Project4_3)
Пример №4. Реализация алгоритма « по условию…»
Рассмотрим еще один пример. Пусть имеется некоторая переменная Х1. И если она положительна, требуется извлечь из нее квадратный корень, ес ли отрицательна – извлечь корень из абсолютного ее значения, а если равна нулю – прибавить к Х2 число 2.
Решение этой задачи на Delphi может иметь вид (рис. 4.17, см. также папку «Lst_4» файл Project4_4.bdsproj).
Рис. 4.17. Листинг проекта Project4_4
Листинг программы приведен на рис. 4.17, здесь Sqrt функция извлечения квадратного корня, а функция Abs – нахождение абсолютного значения.
При вложении операторов if один в другой может возникнуть синтаксическая неоднозначность – к какому из двух ключевых слов if относится ключевое слово else в операторе. Компилятор ассоциирует ключевое слово else с ближайшим ключевым словом if, расположенным в тексте программы выше и еще не связанным с иным ключевым словом else (см. рис. 4.17, красная стрелка).
Условный оператор выбора CASE. Когда требуется осуществить проверку множества условий, например, реализовать один из семи возможных вариантов в зависимости от того, чему равно значение переменной Х, приходится записывать длинные цепочки из условных операторов ‘if … then … else’. Подобная запись весьма громоздка и преобразуется компилятором в не очень эффективный машинный код. В Паскале имеется более удобный оператор выбора case, позволяющий более наглядно и удобно описать выбор нужного варианта в зависимости от целого ряда условий. Условный оператор выбора CASE является обобщением условной инструкции и позволяет сделать выбор из произвольного числа имеющихся вариантов, т. е. организовать ветвление на произвольное число направлений. Этот оператор состоит из выражения, называемого селектором, списка вариантов (Op1 – Opn) и необязательной ветви else. Формат оператора выбора:
case ws of
a: Op1;
b: Op2;
..
n: Opn;
else Opn+1
end;
Выражение-селектор ws должно быть порядкового типа. Каждый из вариантов выбора (Op1 – Opn) представляет собой список констант, отделенных двоеточием от относящейся к данному варианту инструкции, возможно, составной. Список констант выбора состоит из произвольного количества уникальных значений и диапазонов, отделенных друг от друга запятыми. Границы диапазона записываются двумя константами через разделитель «..». Тип констант должен совпадать с типом выражения-селектора.
Инструкция выбора выполняется следующим образом:
- вычисляется значение выражения-селектора;
- производится последовательный просмотр вариантов на предмет совпадения значения выражения-селектора с константами и значениями из диапазонов соответствующего списка;
- если для очередного варианта этот поиск успешный, то выполняется инструкция этого варианта, после чего выполнение инструкции выбора заканчивается.
- если все проверки оказались безуспешными, то выполняется инструкция, стоящая после слова else (если она имеется).
Пример:
case DayN of
1..5 : strD := ‘Рабочий день недели’;
6,7 : strD := ‘Выходной день недели’;
else strD := ‘ ‘;
end;
В зависимости от значения целочисленной переменной DayN, содержащей номер дня недели, присваивается соответствующее значение строковой переменной strD.
Рассмотрим еще один пример. Реализуем программу электронного переводчика, ограничившись переводом английского на русский дней недели.
Для реализации программы воспользуемся операторами IF и CASE. Структурно программа подразделяется на два сегмента.
В первом сегменте (красная стрелка, рис. 4.18), с помощью оператора IF анализируется введенный через компонент Edit1 идентификатор дня недели. Идентификатор это либо английское слово (с прописной или строчной буквы), либо цифра, соответствующая порядковому номеру дня недели.
Во втором сегменте, посредством оператора CASE (синяя стрелка, рис. 4.18) через свойство Caption компонента Label2 день недели на русском языке визуализируется на экране (см. папку «Lst_4» файл Project4_5.bdsproj).
Рис. 4.18. Фрагмент программы электронного переводчика
3. Задание на лабораторную работу и требования к отчету
Для успешного выполнения лабораторной работы требуются знания в объеме 2-го раздела лабораторной работы № 4, а также соответствующих разделов курса лекций. Ниже приводится описание вариантов заданий по лабораторной работе №4. Программа должна быть оформлена в виде приложения Delphi и написана на языке Object Pascal. Текст программы должен содержать комментарии. Отчет по лабораторной работе оформляется в печатном виде. Он должен содержать фамилию, имя и отчество студента, номер и описание индивидуального задания (можно в листинге в виде вводного комментария) и листинг самой программы не содержащий сообщений об ошибках с соответствующими комментариями.
Вариант 1.
1.1 Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формулам: Y1 = max(X1+Х2; Х32+X1) и Y2=min(X1 + ; Х+X1), где X1, X2, X3 – значения вещественных чисел, введенных в три текстовых поля.
1.2.Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: вычислить периметр и площадь треугольника по координатам его вершин.
Вариант 2.
2.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формулам: Y1 = max(X1+Х23; Х3+X1) и Y2=min(X1+Х2; Х3+X12), где X1, X2, X3 – значения целых чисел, введенных в три текстовых поля.
2.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: по заданным коэффициентам и правым частям уравнений системы
найти ее решение в предположении, что определитель системы не равен нулю.
Вариант 3.
3.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формулам: Y1 = 2*X1*Х3 – / Х3 и Y2=min(X12+Х2; Х3+X1), где X1, X2, X3 – значения вещественных чисел, введенных в три текстовых поля.
3.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: вычислить дробную часть среднего геометрического n (0 < n < 12) заданных положительных чисел
Вариант 4.
4.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формулам: Y1 =(X1+Х2)*(Х3+X1) и Y2=(X1+Х2)/(Х3+X1), Y=min(Y1;Y2), где X1, X2, X3 – значения вещественных чисел, введенных в три текстовых поля.
4.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: найти произведение цифр заданного целого числа.
Вариант 5.
5.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формулам: Y1 = max(X1*Х2; Х3*X12; 15,125) и Y2=min(X1*Х2; Х3*X1), где X1, X2, X3 – значения вещественных чисел, введенных в три текстовых поля.
5.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: определить число, полученное выписыванием в обратном порядке цифр заданного целого числа.
Вариант 6.
6.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формулам: Y1 = max(X1-Х2; Х3-X1) и Y2=min(X1+Х2; Х3+X1), где X1, X2, X3 – значения целых чисел, введенных в три текстовых поля, при условии, что Y1 всегда > или = 0.
6.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи. Даны три вещественных положительных числа. Определить:
- принципиальную возможность построения треугольника с такими размерами его сторон;
- является ли этот треугольник равносторонним, равнобедренным или прямоугольным.
Вариант 7.
7.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формулам: Y1 = max(X12- Х2; Х3-X1) и Y2=min(X1-Х2; Х3+X13), Y3=Y1+Y2, где X1, X2, X3 – значения целых чисел, введенных в три текстовых поля.
7.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: найти вещественные корни уравнения . Если таковых не имеется – сообщить об этом.
Вариант 8.
8.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которого осуществляется вычисление арифметического выражения по формуле: Y = max(X12/Х2; Х33/X1), где X1, X2, X3 – значения вещественных чисел, введенных в три текстовых поля.
8.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: определить, равна ли сумма двух первых цифр заданного четырехзначного числа сумме двух его последних цифр.
Вариант 9.
9.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которого осуществляется вычисление арифметического выражения по формуле: Y = min(X1-Х2; Х3+X1; X1; X32), где X1, X2, X3 – значения вещественных чисел, введенных в три текстовых поля.
9.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: определить, равна ли сумма трех первых цифр заданного пятизначного числа произведению двух его последних цифр.
Вариант 10.
10.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметического выражения по формулам: Y = X1/Х2 + (Х3)Х4, где X1, X2, X3 – значения вещественных чисел, введенных в три текстовых поля, а Х4 – целое, причем не большее 4.
10.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: определить больше, меньше или равен квадрат заданного трехзначного числа кубу суммы цифр этого же числа.
Вариант 11.
11.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формулам: Y1 = max(X1+Х2; Х3+X1) и Y2=min(X1+Х2; Х3+X1), где X1, X2, X3 – значения целых чисел, введенных в три текстовых поля.
11.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: определить, если среди первых шести цифр из дробной части частного от деления двух положительных вещественных чисел одинаковые повторяющиеся последовательности цифр.
Вариант 12.
12.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формуле: Y = max(X1/Х2; Х3/X1), где X1, X2, X3 – значения вещественных чисел, введенных в три текстовых поля.
12.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: определить координаты точки пересечения двух прямых, описываемых уравнениями и , либо вывести сообщение, что эти прямые совпадают, не пересекаются или вообще не существуют.
Вариант 13.
13.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формулам: Y1 = max(X1-Х2; Х3-X1) и Y2=min(X1-Х2; Х3+X1), где X1, X2, X3 – значения целых чисел, введенных в три текстовых поля.
13.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: определить, равно ли произведение первых двух цифр заданного многозначного числа сумме трех его последних цифр.
Вариант 14.
41.1 Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формулам: Y1 = max(X1+Х2; Х32+X1) и Y2=min(X1 + ; Х+X1), где X1, X2, X3 – значения вещественных чисел, введенных в три текстовых поля.
14.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: определить больше, меньше или равен квадрат заданного трехзначного числа кубу суммы цифр этого же числа.
Вариант 15.
15.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формулам: Y1 = max(X12- Х2; Х3-X1) и Y2=min(X1-Х2; Х3+X13), Y3=Y1+Y2, где X1, X2, X3 – значения целых чисел, введенных в три текстовых поля.
15.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: вычислить дробную часть среднего геометрического n (0 < n < 12) заданных положительных чисел
Вариант 16.
16.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формулам: Y1 =(X1+Х2)*(Х3+X1) и Y2=(X1+Х2)/(Х3+X1), Y=min(Y1;Y2), где X1, X2, X3 – значения вещественных чисел, введенных в три текстовых поля.
16.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: определить, равна ли сумма двух первых цифр заданного четырехзначного числа сумме двух его последних цифр.
Вариант 17.
17.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формулам: Y1 = max(X1+Х2; Х3+X1) и Y2=min(X1+Х2; Х3+X1), где X1, X2, X3 – значения целых чисел, введенных в три текстовых поля.
17.2.Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: вычислить периметр и площадь треугольника по координатам его вершин.
Вариант 18.
18.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которого осуществляется вычисление арифметического выражения по формуле: Y = min(X1-Х2; Х3+X1; X1; X32), где X1, X2, X3 – значения вещественных чисел, введенных в три текстовых поля.
18.2. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: определить число, полученное выписыванием в обратном порядке цифр заданного целого числа.
Вариант 19.
19.1. Разработать пользовательский интерфейс с использованием компонентов TEdit, TButton и TLabel, с помощью которых осуществляется вычисление арифметических выражений по формулам: Y1 = max(X1-Х2; Х3-X1) и Y2=min(X1+Х2; Х3+X1), где X1, X2, X3 – значения целых чисел, введенных в три текстовых поля, при условии, что Y1 всегда > или = 0.
12.9. Разработать дизайн визуального приложения, составить алгоритм и написать программу для решения следующей задачи: определить координаты точки пересечения двух прямых, описываемых уравнениями и , либо вывести сообщение, что эти прямые совпадают, не пересекаются или вообще не существуют.
PAGE 26
EMBED Package
Рис. 4.4 Tool Palete
Рис. 4.5 Маркеры изменения размера компонента
Рис. 4.6 Окно диалога сохранения файла
Рис. 4.1 Инспектор объектов
Рис. 4.2 Список инспектора объектов
Рис. 4.7. Свойство MiscellaneousèDefault
Рис.4.8. Закладка
Рис.4.13. Визуальное приложение проекта 4_2
Отсутствует признак конца строки строкистроки
Рис. 4.15. Предупреждающее сообщение отладчика