extracted_text:






тема 2 вопрос 27
состав проекта. управление проектами в delphi
Проект Delphi
Любой проект имеет, покрайней мере, шесть файлов, связанных с ним. Три из них относятся к
управлению проектом из среды и напрямую программистом не меняются. Вот эти файлы :
Главный файл проекта, изначально называется PROJECT1.DPR.
Первый модуль программы /unit/, который автоматически появляется в начале работы.
Файл называется UNIT1.PAS по умолчанию, но его можно назвать любым другим именем, вроде
MAIN.PAS.
Файл главной формы, который по умолчанию называется UNIT1.DFM, используется
для сохранения информации о внешнем виде главной формы.
Файл PROJECT1.RES содержит иконку для проекта, создается автоматически.
Файл, который называется PROJECT1.OPT по умолчанию, является текстовым файлом
для сохранения установок, связанных с данным проектом. Например, установленные Вами директивы
компилятор
а сохраняются здесь.
Файл PROJECT1.DSK содержит информацию о состоянии рабочего пространства.
Разумеется, если сохранить проект под другим именем, то изменят название и файлы с расширением
RES, OPT и DSK.
После компиляции программы получаются файлы с расширениями:
DCU  скомпилированные модули
EXE  исполняемый файл
DSM  служебный файл для запуска программы в среде, очень большой, рекомендуется стирать его
при окончании работы.
~PA, ~DP  backup файлы Редактора.
Пункт меню "File"
Если нужно сохранить проект, то Вы выбираете пункт главного меню "File" (с помощью мышки или по
клавише Alt+F). Пункт меню "File" выглядит следующим образом:
New Project
Open Project
Save Project
Save Project As
Close Project

New Form
New Unit
New Component
Open File
Save File
Save File As
Close File

Add File
Remove File

Print

Exit

1 PREV1.DPR
2 PREV2.DPR
Как Вы можете видеть, здесь есть шесть секций; вот их назначение: 





Первая секция дает возможность управления проектом вцелом.
Вторая секция дает контроль над формами, модулями и компонентами проекта.
Третья позволяет добавлять и удалять файлы из проекта.
Четвертая управляет печатью.
Пятая секция  выход из Delphi
Шестая секция предоставляет список ранее редактировавшихся проектов; Вы можете
быстро открыть нужный.
Как Вы увидите позже, большинство операций из пункта меню "File" можно выполнить с помощью
Менеджера Проекта (Project Manager), который можно вызвать из пункта меню View. Некоторые
операции доступны и через SpeedBar. Данная стратегия типична для Delphi: она предоставляет
несколько путей для решения одной и той же задачи, Вы сами можете решать, какой из них более
эффективен в данной ситуации.
Каждая строка пункта меню "File" объяснена в Справочнике. Выберите меню "File" и нажмите F1,
появится экран справочника, как на рис.1.
Рис.1: Delphi включает подсказку, как использовать пункт меню "File".
Большинство из пунктов первой секции очевидны. "New Project" начинает новый проект, "Open
Project" открывает существующий проект и т.д.
Первые два пункта второй секции позволяют Вам создать новую форму или новый модуль. Выбирая
"New Form", Вы создаете новую форму и модуль, связанный с ней; выбирая "New Unit", Вы создаете
один модуль.
"New Component" вызывает диалог для построения заготовки нового визуального компонента. В
результате создается модуль, который можно скомпилировать и включить в Палитру Компонент.
"Open File" открывает при необходимости любой модуль или просто текстовый файл. Если модуль
описывает форму, то эта форма тоже появится на экране.
При создании нового модуля Delphi дает ему имя поумолчанию. Вы можете изменить это имя на что
нибудь более осмысленное (например, MAIN.PAS) с помощью пункта "Save File As".
"Save File" сохраняет только редактируемый файл, но не весь проект.
"Close File" удаляет файл из окна Редактора.
Нужно обратить внимание: Вы должны регулярно сохранять проект через File | Save Project либо через
нажатие Ctrl+S.
Управление проектом
Теперь, когда Вы знаете о создании проекта с помощью пункта меню "File", перейдем к Менеджеру
Проектов, который помогает управлять проектом. Менеджер Проектов, рис.3, разделен на две части.
Верхняя  панель с управляющими кнопками. Нижняя  список модулей, входящих в проект.
Рис.3: Кнопки сверху используются для удаления и добавления модулей в проект. 














Вы можете использовать кнопки с плюсом и минусом для добавления и удаления файлов в проекте.
Эти изменения влияют на файлы с исходным текстом, то есть, если добавить в проект модуль, то
ссылка на него появится в файле с расширением DPR.
Краткое описание других кнопок :
Третья слева кнопка  просмотр текста модуля, на котором стоит курсор.
Четвертая  просмотр формы, если есть таковая для данного модуля
Пятая  вызов диалога настройки проекта, сам диалог будет рассмотрен позже.
Последняя  сохранение изменений на диске.
Обзор других пунктов меню
Пункт меню "File" обсуждался ранее. Далее рассматриваются другие важные пункты  "Edit", "Search",
"View" и "Compile", но менее подробно. Далее, снова подробно, рассказывается о "Options".
Пункт меню "Edit"
"Edit" содержит команды "Undo" и "Redo", которые могут быть очень полезны при работе в редакторе
для устранения последствий при неправильных действиях, например, если случайно удален нужный
фрагмент текста.
Отметьте для себя, что Справочник (online help) объясняет как нужно использовать пункт меню
Options | Environment для настройки команды "Undo". Возможность ограничить возможное количество
команд "Undo" может пригодиться, если Вы работаете на машине с ограниченными ресурсами.
Команды "Cut", "Copy", "Paste" и "Delete"  как во всех остальных приложениях Windows, но их
можно применять не только к тексту, но и к визуальным компонентам.
"Bring To Front", "Send To Back", "Align" и "Size" обсуждались в Уроке № 2. Оставшиеся четыре
пункта помогают быстро "приукрасить" внешний вид формы.
Пункт меню "Search"
В "Search" есть команда "Find Error" (поиск ошибки), которая поможет отследить ошибку периода
выполнения программы. Когда в сообщении об ошибке указан ее адрес, Вы можете выбрать пункт
меню Search | Find Error и ввести этот адрес. Если это представится возможным, то среда переместит
Вас в то место программы, где произошла ошибка.
Пункт меню "View"
Составляющие пункта меню "View":
Project Manager (Менеджер Проекта).
Project Source  загружает главный файл проекта (DPR) в Редактор
Установка, показывать или нет Object Inspector на экране.
Установка, показывать или нет Alignment Palette. То же самое доступно из пункт меню
Edit | Align.
Browser  вызов средства для просмотра иерархии объектов программы, поиска
идентификатора в исходных текстах и т.п.
Watch, Breakpoint и Call Stack  связаны с процедурой отладки программы и будут
обсуждаться позднее.
Component List  список компонент, альтернатива Палитре Компонент. Используется
для поиска компонента по имени или при отсутствии мыши.
Window List  список окон, открытых в среде Delphi.
Toggle Form/Unit, Units, Forms  переключение между формой и соответствующим
модулем, выбор модуля или формы из списка.
New Edit Window  открывает дополнительное окно Редактора. Полезно, если нужно,
например, просмотреть две разных версии одного файла.
SpeedBar и Component Palette  установки, нужно ли их отображать.
Пункт меню "Compile"
В пункте меню "Compile" проект можно скомпилировать (compile) или перестроить (build). Если
выбрать Compile или Run, то Delphi перекомпилирует только те модули, которые изменились со
времени последней компиляции. Build all, с другой стороны, перекомпилирует все модули, исходные
тексты которых доступны. Команда Syntax Check только проверяет правильность кода программы, но
не обновляет DCU файлы. В самом низу  пункт Information, который выдает информацию о программе: размеры сегментов
кода, данных и стека, размер локальной динамической памяти и количество скомпилированных строк.
Пункт меню "Run"
Можно использовать "Run" для компиляции и запуска программы и для указания параметров
командной строки для передачи в программу. Здесь же имеются опции для режима отладки.
Пункт меню Options | Project
"Options" наиболее сложная часть системного меню. Это центр управления, из которого вы можете
изменять установки для проекта и для всей рабочей среды Delphi. В "Options" есть семь пунктов:
Project Environment Tools Gallery
Open Library
Install Components
Rebuild Library
Первые четыре пункта вызывают диалоговые окна. Ниже приведено общее описание пункта меню
"Options":
Project  выбор установок, которые напрямую влияют на текущий проект, это могут
быть, к примеру, директивы компилятора проверки стека (stack checking) или диапазона (range
checking).
Environment  конфигурация самой среды программирования (IDE). Например, здесь
можно изменить цвета, используемые в Редакторе.
Tools  позволяет добавить или удалить вызов внешних программ в пункт главного
меню "Tools". Например, если Вы часто пользуетесь какимнибудь редактором или отладчиком, то
здесь его вызов можно добавить в меню.
Gallery  позволяет определить специфические установки для Эксперта Форм и
Эксперта Проектов и их "заготовок". Эксперты и "заготовки" предоставляют путь для ускорения
конструирования интерфейса программы.
Последние три пункта позволяют сконфигурировать Палитру Компонент.
Диалог из пункта Options | Project включает пять страниц:
На странице Forms перечислены все формы, включенные в проект; Вы можете указать,
нужно ли автоматически создавать форму при старте программы или Вы ее создадите сами.
На странице Application Вы определяете элементы программы такие, как заголовок,
файл помощи и иконка.
Страница Compiler включает установки для генерации кода, управления обработкой
ошибок времени выполнения, синтаксиса, отладки и др.
На странице Linker можно определить условия для процесса линковки приложения
Страница Directories/Conditionals  здесь указываются директории, специфичные для
данного проекта.
Все установки для проекта сохраняются в текстовом файле с расширением OPT и Вы можете вручную
их исправить.
Страница Forms










На странице Forms можно выбрать главную форму проекта. Изменения, которые Вы сделаете,
отобразятся в соответствующем файле DPR. Например, в нижеследующем проекте, Form1 является
главной, поскольку появляется первой в главном блоке программы:
program Project1;uses
  Forms,
  Unit1 in 'UNIT1.PAS' {Form1},
  Unit2 in 'UNIT2.PAS' {Form2};
{$R *.RES}begin Application.CreateForm(TForm1, Form1);
  Application.CreateForm(TForm2, Form2);
  Application.Run;end.
Если изменить код так, чтобы он читался
begin
  Application.CreateForm(TForm2, Form2);
  Application.CreateForm(TForm1, Form1);
  Application.Run;end.
то теперь Form2 станет главной формой проекта.
Вы также можете использовать эту страницу для определения, будет ли данная форма создаваться
автоматически при старте программы. Если форма создается не автоматически, а по ходу выполнения
программы, то для этого нужно использовать процедуру Create.
Кстати, в секции Uses имя формы в фигурных скобках является существенным для Менеджера
Проектов и удалять его не стоит. Не нужно вообще ничего изменять вручную в файле проекта, если
только Вы не захотели создать DLL, но об этом позднее.
Страница Applications
На странице Applications, см. рис.5, вы можете задать заголовок (Title), файл помощи (Help file) и
пиктограмму (Icon) для проекта.
Страница Compiler Ранее уже говорилось, что установки из пункта меню "Options | Project"
сохраняются в соответствующем файле с расширением OPT. Давайте рассмотрим директивы
компилятора на странице Compiler (рис.6).
Следующая таблица показывает, как различные директивы отображаются в OPT файле, на странице
Compiler и внутри кода программы:
OPT FileOptions Page
Force Far Calls
Word Align Date
PentiumSafe FDIV
Smart Callbacks
Windows (3.0) Stack
Editor Symbol
{$F+}
{$A+}
{$U+}
{$K+}
{$W+}
R
S
I
Range Checking
Stack Checking
IO Checking
{$R+}
{$S+} Q
V
B
X
T
P
D
{$B+}
Overflow Checking{$Q+}
Strict Var Strings {$V+}
Complete Boolean
Evaluation
Extended Syntax {$X+}
Typed @ Operator {$T+}
Open Parameters {$P+}
Debug Information {$D+}
Страница Linker
Теперь давайте перейдем к странице Linker,
Если буфер линковщика расположен в памяти, то линковка происходит быстрее.
Размер стека (Stack Size) и локальной динамической памяти (Heap Size) весьма важны. Delphi
устанавливает по умолчанию и Stack Size, и Heap Size в 8192 байт каждый. Вам может понадобиться
изменить размер стека в программе, но обычно это не более 32Кб. В сумме эти два размера не должны
превышать 64Кб, иначе будет выдаваться ошибка при компиляции программы.
Страница Directories/Conditionals
Страница Directories/Conditionals, рис.8, дает возможность расширить число директорий, в которых
компилятор и линковщик ищут DCU файлы.
В файле DELPHI.INI содержится еще один список директорий. Запомните, что в OPT файле  список
директорий для конкретного проекта, а в файле DELPHI.INI  список относится к любому проекту.
Output directory  выходная директория, куда складываются EXE и DCU файлы, получающиеся при
компиляции.
Search path  список директорий для поиска DCU файлов при линковке. Директории перечисляются
через точку с запятой ;
Conditional defines  для опытного программиста и на первом этапе создания проекта не требуется.
Для информации можно вызвать Справочник (online help).
Конфигурация среды программирования (IDE)
Пункт меню "Options | Environment" предоставляет Вам большой набор страниц и управляющих
элементов, которые определяют внешний вид и работу IDE. Delphi позволяет сделать следующие
важные настройки:
Определить, что из проекта будет сохраняться автоматически
Можно менять цвета IDE
Можно менять подсветку синтаксиса в РедактореМожно изменить состав Палитры
КомпонентУказать "горячие клавиши" IDE
Первая страница пункта меню "Options | Environment" показана на рис.9
1.
2.
3.
4. В группе "Desktop Contents" определяется, что будет сохраняться при выходе из Delphi. Если выбрать
Desktop Only  это сохранит информацию о директориях и открытых окнах, если выбрать Desktop And
Symbols  это сохранит то же самое плюс информацию для броузера (browser).
В группе "Autosave" указывается, что нужно сохранять при запуске программы. Если позиция Editor
Files выбрана, то сохраняются все модифицированные файлы из Редактора при выполнении команд
Run|Run, Run|Trace Into, Run|Step Over, Run|Run To Cursor или при выходе из Delphi. Если позиция
Desktop выбрана  сохраняется рабочая среда при закрытии проекта или при выходе из Delphi. Если
Вы позже откроете проект, то он будет иметь тот же вид, что и при его закрытии.
В группе "Form Designer" можно установить, показывать ли сетку (grid) на экране и выравнивать ли
объекты по ней, и размер ячеек сетки.
В группе "Debugging": опция Integrated Debugging  использовать ли встроенный отладчик; Step
Program Block  отладчик остановится на первой строке модуля, в котором есть отладочная
информация; Break On Exception  останавливать ли программу при возникновении исключительной
ситуации; Minimize On Run  свертывать ли Delphi при запуске программы. После закрытия
программы среда Delphi восстанавливается. Hide Designers On Run  прячет окна Дизайнера
(Инспектор Объектов, формы) при запуске приложения.
Show Compiler Progress  показывать ли окно, в котором отражается процесс компиляции программы.
"Gallery"  указывает, в каких случаях нужно предоставлять "галерею" (коллекцию заготовок и
экспертов).
Страницы Editor Options, Editor Display и Editor Colors позволяют Вам изменить цвета и "горячие"
клавиши, используемые IDE. Страница Editor Display показана на рис.10, а Editor Colors  на рис.11.
Рис.10: Страница Editor Display.
Существует несколько способов изменить назначение "горячих" клавиш, используемых Редактором.
Например, многие пользователи привыкли, что по клавише F5 максимизируется окно Редактора. Для
этого им надо использовать расположение клавиш, называемое "Classic" (Keystroke mapping : Classic).
Всего есть четыре вида конфигурации клавиш:
"Default"  характерно для Microsoft. Если Вы новичок в Windows или уже привыкли к
этому расположению клавиш, то это подойдет.
"Classic"  более известно ветеранам Borland C++ и Borland Pascal. Поддерживает
многие комбинации клавиш WordStar и отладчик управляется старым добрым способом.

 
Остальные два вида  имитируют редакторы Epsilon и BRIEF. Подойдут, если вы с
ними знакомы.
Точное описание назначения клавиш можно найти в Справочнике (в Help | Topic Search набрать "key
mapping"). Цвета IDE можно изменить на странице Editor Colors.
И, наконец, Editor Options (рис.12).
Рис.12: На странице Editor Options можно настроить тонкие детали работы Редактора.
Многие из установок на данной странице не очень важны для большинства пользователей, поэтому
остановимся лишь на некоторых.
"Use syntax highlight"  выделять ли цветом синтаксические конструкции в Редакторе Исходного
текста. "Find text at cursor"  если включено, то при поиске (Ctrl+F) в качестве подстроки для поиска
будет браться то слово, на котором стоит курсор.
Установки сохраняются в файле DELPHI.INI, который находится в директории Windows.
Управление проектом
Как известно, в Windows любая программа представляет собой exeфайл, который является
исполняемым, т.е. может быть запущен как отдельное приложение. Понятно, что разрабатывая
программу, в итоге нужно получить именно exeфайл, чтобы его можно было запустить на
компьютере, где не установлена среда, в которой эта программа была создана. В языках
программирования для DOS, в частности Turbo Pascal, всё довольно просто  весь программный код
сохраняется в одинединственный файл, а в итоге получается exeфайл. Довольно просто и удобно.
При переходе в Windows всё становится гораздо сложнее. Оконное приложение Windows не может
быть сохранено в одном файле. Если в среде DOS программы можно называть именно программами,
то в объектноориентированном программировании они называются проектами. Всё достаточно
просто  программа представляет собой совокупность некоторого числа файлов различного типа,
определённым образом связанных между собой. Очевидно, что всю эту группу логично назвать
проектом.
В этой статье мы познакомимся с самыми основными типами файлов, которые включены в любой
проект, созданный на Delphi. На самом деле типов файлов гораздо больше, но эти  базовые.
*.dpr  файл проекта
Это главный файл всего проекта. Если этот файл отсутствует, запустить программу будет
невозможно. В файле хранятся все основные параметры приложения, а также информация об окнах,
которые в приложение включены. Файл представляет собой свободно читаемый код. Посмотреть
содержимое этого файла можно командой меню Project > View Source. В более новых версиях Delphi
файл проекта имеет другое расширение  .bdsproj (в Borland Developer Studio 2006), .dproj (в Delphi
2007 и далее). Обратная совместимость поддерживается.
*.dfm  файл описания формы
В этом файле содержится описание всех объектов, которые расположены на форме, а также
информация обо всех их свойствах. При этом в этот файл сохраняются только те свойства объектов,
которые были принудительно изменены. Это объясняется тем, что все свойства любого объекта имеют
значения по умолчанию (т.е. заранее установленные). Соответственно нет смысла хранить значения
абсолютно всех свойств  достаточно запомнить только те, которые имеют значение, отлиное от
начального. Все остальные свойства принимают своё исходное значение и таким образом вся форма
восстанавливается.
*.pas  модуль (самостоятельный, либо модуль формы)
Именно этот файл больше всего похож на файл программ Turbo Pascal. В этом файле находится
код программы. Модули могут быть отдельными от конкретных проектов  в этом случае их можно
подключить к любому проекту и использовать. Как правило, в отдельных модулях находятся
вспомогательные функции, либо какиелибо объекты. Помимо этого модуль есть у каждой формы. В результате *.pasфайл неразрывно связан с файлом *.dfm, а форма соответственно описывается этими
двумя файлами  один содержит её состояние и объекты, а второй  код программы, относящийся к
этой форме. Следует отметить, что модули значительно облегчают процесс написания программы и
ориентацию в больших модулях  отдельные элементы большого модуля можно вынести в несколько
модулей и просто подключить их к проекту.
*.res  файл ресурсов
Это дополнительный файл. В нём находятся данные различных типов  это могут быть тексты,
изображения, звуки и т.д. К примеру, для проекта этот файл создаётся автоматически и в нём
сохраняется иконка (значок) приложения, а также некоторая информация о проекте.
Вот и все основные файлы, информацию о которых обязательно нужно знать. Чтобы перенести
проект, достаточно следующих файлов: *.dpr, *.dfm и *.pas. Имея эти файлы проект можно
восстановить, а программу  запустить. Желательно также наличие *.resфайла(ов), но тем не менее
это не обязательно. Если *.resфайл, сопоставленный проекту будет отсутствовать, то при открытии
проекта Delphi предупредит, что файл не найден и спросит, что нужно сделать. Достаточно
проигнорировать сообщение и файл будет создан автоматически при следующем запуске программы.
*.dof, *.cfg  файлы конфигурации проекта
В этих файлах хранятся опции текущего проекта (которые настраиваются в окне Project  Options).
При отсутствии этих файлов будут использоваться стандартные параметры.
*.dcu, *.obj  объектные файлы
Эти файлы представляют собой уже скомпилированные модули. При очередной компиляции
Delphi создаёт для каждого pasфайла соответствующий dcuфайл. Это существенно ускоряет
компиляцию в дальнейшем, т.к. имеющиеся файлы просто включаются в конечный exeфайл, а не
обрабатываются заново. OBJфайлы  это тоже скомпилированные модули, но применяющиеся в С++.
При работе в Delphi эти файлы не используются, но при необходимости их можно сформировать.
*.~*  временные файлы
Файлы, расширение которых начинается со знака тильды ("~"), являются временными. Это
означает, что они не несут какойлибо важной информации и используются в других целях (например,
для ускорения компиляции). Эти файлы можно смело удалять, если они мешают. Чем больше проект,
тем обычно больше появляется временных файлов.
Работа с проектом
Ну а теперь пришло время рассказать о базовых операциях с проектом,
Меню File содержит все основные команды управления проектом
Создание нового проекта
Для создания "чистого листа" следует выбрать в меню File > New > Application. В
разных версиях Delphi содержимое подменю New может немного отличаться, но всё
основное присутствует всегда. После этого создаётся новый проект, такой, какой
появляется при запуске Delphi.
Открытие существующего проекта (или файла)
Для этого существует команда File > Open... Выбрав файл *.dpr, откроется проект, а
выбрав какойлибо другой файл (например, *.pas или *.dfm) откроется чтолибо другое (например, отдельная форма).
Сохранение
С сохранением есть несколько тонкостей. Исходя из того, что проект представляет
собой совокупность нескольких файлов, можно сделать вывод, что сохранять нужно все
эти файлы, а не какойто в отдельности. Выбрав File > Save, Вы сохраните только текущую
форму, но не более того, а проект останется "висеть в воздухе". File > Save As...
стандартный пункт, который делает то же самое, что и Save, только позволяет
пересохранить файл (форму) под другим именем. Команда Save Project As... сохраняет
файл проекта (*.dpr). Таким образом, чтобы сохранить проект полностью, нужно сохранить
каждую из форм и сам проект. Делать это по отдельности достаточно неудобно, поэтому
существует команда, облегчающая этот процесс: File > Save All. При вызове этой команды
сначала появится диалог для сохранения формы (если форм несколько, то и диалогов
будет несколько), а затем диалог для сохранения проекта. После того, как все диалоги
отработали, можно с уверенностью сказать, что проект сохранён полностью.
Железное правило: каждый проект должен быть сохранён в отдельном каталоге!
Если в один каталог сохранить несколько проектов, то все файлы перемешаются и можно
отправлять всё в корзину. Этого нельзя делать ни в коем случае!
Запуск и остановка программы
Теперь, когда проект сохранён, программу можно и запустить и посмотреть, что же получилось.
Ещё одно правило, которое желательно соблюдать: перед запуском программы проект нужно
сохранить. Мгновенный вопрос: зачем? Конечно, делать это или нет  решать Вам, но бывают случаи,
когда программа зависает (по вине самого программиста например), а с ней зависает и оболочка
Delphi. В этом случае ничего не остаётся делать, как "убивать" Delphi через Диспетчер задач
Windows. Понятно, что изменения, которые были внесены в проект, теряются. Однако не всё так
плохо. Случаи зависания Delphi IDE достаточно редки. Как правило, если программа зависает, Delphi
позволяет её просто уничтожить из памяти и продолжить работу. Процесс сохранения проекта перед
запуском можно поручить оболочке: меню Tools > Environment Options..., вкладка Preferences, блок
Autosave options  опция Editor files.
Запомните следующие основные горячие клавиши:
Ctrl+F9  компиляция программы. Что такое компиляция? Говоря простым языком  создание
выходного (exe) файла программы. Следует отметить, что имя выходного файла совпадает с именем
проекта, т.е. именем *.dprфайла и не может быть изменено. Выходной файл создаётся в том же
каталоге, где расположение *.dprфайл. Однако компиляция просто "собирает" всю программу, но не
запускает её.
F9  запуск. В отличие от компиляции, это уже полноценный запуск программы из оболочки
Delphi, однако не совсем такой, каким является запуск приложения из Windows. Запуск происходит
под отладчиком. Но об этом позже.
Ctrl+F2  остановка выполнения программы. Это именно то, о чём сказано чуть выше. Если нужно
экстренно завершить работу программы, нужно активировать какое=либо из окон оболочки Delphi и
нажать это сочетание клавиш. Программа будет остановлена и можно будет безболезненно
продолжить работу.
Все эти команды доступны и напрямую из меню: Run > Run, Project > Compile, Run > Program
Reset.
Все основные команды управления проектом вынесены также в виде кнопок на панели
инструментов:
Свойства проекта Окно свойств проекта
Для проекта можно установить множество разнообразных параметров. Все они находятся
в окне Project > Options. В частности, на вкладке Application можно указать заголовок
проекта, который будет отображаться на кнопке программы на панели задач. Совет: всегда
прописывайте заголовок своей программе, не оставляйте стандартного "Project1"  это резко
бросается в глаза. На этой же вкладке можно выбрать иконку (значок) для приложения
файл *.ico размером 32х32 пикселя. В блоке Output settings можно указать расширение
выходного файла. Заполнять это поле не обязательно  по умолчанию файлу присваивается
расширение .exe. Однако в некоторых случаях эта настройка бывает полезной. Например,
экранные программызаставки представляют собой те же исполняемые exeфайлы, только
имеют расширение .scr. Неудобно каждый раз после внесения изменений в программу, чтобы
протестировать заставку, переименовывать файл. А прописав в указанное поле "scr"
проблема мигом решится.

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

file_name: тема 2 вопрос 27.docx

intro:
Проект Delphi
Любой проект имеет, по-крайней мере, шесть файлов, связанных с ним. Три из них относятся к управлению проектом из среды и напрямую программистом не меняются. Вот эти файлы :
•	Главный файл проекта, изначально называется PROJECT1.DPR.
•	Первый модуль программы /unit/, который автоматически появляется в начале работы. Файл называется UNIT1.PAS по умолчанию, но его можно назвать любым другим именем, вроде MAIN.PAS.
•	Файл главной формы, который по умолчанию называется UNIT1.DFM, используется для сохранения информации о внешнем виде главной формы.
•	Файл PROJECT1.RES содержит иконку для проекта, создается автоматически.
•	Файл, который называется PROJECT1.OPT по умолчанию, является текстовым файлом для сохранения установок, связанных с данным проектом. Например, установленные Вами директивы компилятор
а сохраняются здесь.

title: Лекция "управление проектами в delphi"


extracted_text:
структура модуля в delphi назначение секций private protected public published
тема 2 вопрос 28
Модули  это программные единицы, предназначенные для размещений фрагментов
программ. С помощью содержащегося в них программного кода реализуется вся
поведенческая сторона программы. Любой модуль имеет следующую структуру [Более
точное описание структуры модуля приводится в п. 12.1.]: заголовок секция
интерфейсных объявлений секция реализации терминатор Заголовок открывается
зарезервированным словом Unit за которым следует имя модуля и точка с запятой. Секция
интерфейсных объявлений открывается зарезервированным словом Interface, a секция
реализации  словом implementation. Терминатором модуля, как и терминатором
программы, является end с точкой. Следующий фрагмент программы является
синтаксически правильным вариантом модуля:
unit Unit1;
interface
// Секция интерфейсных объявлений
implementation
// Секция реализации
end.
В секции интерфейсных объявлений описываются программные элементы (типы, классы,
процедуры и функции), которые будут “видны” другим программным модулям, а в секции
реализации раскрывается механизм работы этих элементов. Разделение модуля на две
секции обеспечивает удобный механизм обмена алгоритмами между отдельными частями
одной программы. Он также реализует средство обмена программными разработками
между отдельными программистами. Получив откомпилированный “посторонний” модуль,
программист получает доступ только к его интерфейсной части, в которой, как уже
говорилось, содержатся объявления элементов. Детали реализации объявленных процедур,
функций, классов скрыты в секции реализации и недоступны другим модулям.
Щелкните по закладке Unit1 окна кода, и вы увидите такой текст:
 unit Unit1;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls,
Forms, Dialogs, StdCtrls, Buttons, ExtCtrls;
type
TfmExample = class(TForm)
Panel1: TPanel;
bbRun: TBitBtn;
bbClose: TBitBtn;
edinput: TEdit;
IbOutput: TLabel;
mmOutput: TMemo;
private
{ Private declarations } public
{ Public declarations } end;
var
fmExample: TfmExample;
implementation
$R *.DFM}
end. Весь этот текст сформирован Delphi, но в отличие от файла проекта программист может
его изменять, придавая программе нужную функциональность. В интерфейсной секции
описан один тип (класс  fmExample) и один объект (переменная fmExample).
Вот описание класса:
type
TfmExample = class(TForm)
Panell: TPanel;
bbRun: TBitBtn;
bbClose: TBitBtn;
edinput: TEdit;
IbOutput: TLabel;
mmOutput: TMemo;
private
{ Private declarations } public
{ Public declarations } end;
Как мы увидим дальше, классы служат основным инструментом реализации мощных
возможностей Delphi. Класс является образцом, по которому создаются объекты, и
наоборот, объект  это экземпляр реализации класса. Образцы для создания элементов
программы в Object Pascal называются типами, таким образом, класс TfmExamplel это
тип. Перед его объявлением стоит зарезервированное слово type (тип), извещающее
компилятор о начале раздела описания типов.
Стандартный класс TForm реализует все нужное для создания и функционирования
пустого Windowsокна. Класс TfmExamplel порожден от этого класса, о чем
свидетельствует строка
TfmExample = class(TForm)
в которой за зарезервированным словом class в скобках указывается имя родительского
класса. Термин “порожден” означает, что класс TfmExample унаследовал все возможности
родительского класса TForm и добавил к ним собственные в виде дополнительных
компонентов, которые, как вы помните, мы вставили в форму fmExample. Перечень
вставленных нами компонентов и составляет значительную часть описания класса.
Свойство наследования классамипотомками всех свойств родительского класса и
обогащения их новыми возможностями является одним из фундаментальных принципов
объектноориентированного программирования. От наследника может быть порожден
новый наследник, который внесет свою лепту в виде дополнительных программных
заготовок и т. д. В результате создается ветвящаяся иерархия классов, на вершине которой
располагается самый простой класс TObject (все остальные классы в Delphi порождены от
этого единственного прародителя), а на самой нижней ступени иерархии  мощные классы
потомки, которым по плечу решение любых проблем.
Объект fmExampie формально относится к элементам программы, которые называются
переменными. Вот почему перед объявлением объекта стоит зарезервированное слово var
(от англ. variables  переменные).
Текст модуля доступен как Delphi ,так и программисту. Delphi автоматически
вставляет в текст модуля описание любого добавленного к? форме компонента, а
также создает заготовки для обработчиков событии; программист может
добавлять свои методы в ранее объявлённые классыйнаполвять обработчики событий
конкретным .содержа,нием, вставлять собственные переменные, типы, константы и
т. д. Совместное с Delphi владение текстом модуля будет вполне успешным, если
программист будет соблюдать простое правило , он не должен удалять или изменять
строки которые вставлены не им, а Delphi.
Модули в Delphi
Разработав некоторую функцию, программист может использовать ее в другой программе,
поместив текст этой функции в раздел implementation. Однако этот способ неудобен, т. к. приходится набирать текст функции зановоили копировать его из текста другой
программы.
Создание модуля
Delphi позволяет программисту поместить свои функции и процедуры в отдельный модуль,
а затем использовать процедуры и функции модуля в своих программах, указав имя модуля
в списке модулей, необходимых программе (инструкция uses).
Чтобы приступить к созданию модуля, нужно сначала закрыть окно формы и окно модуля
формы (в ответ на вопрос о необходимости сохранения модуля следует выбрать No, т. е.
модуль, соответствующий закрытой форме, сохранять не надо). Затем из меню File нужно
выбрать команду New | Unit. В результате открывается окно редактора кода, в котором
находится сформированный Delphi шаблон модуля. Его текст приведен в листинге 6.7.
Листинг 6.7. Шаблон модуля
1.unit Unitl;
2.interface
3.implementation
4.end.

Начинается модуль заголовком — инструкцией unit, в которой указано имя модуля. Во
время сохранения модуля это имя будет автоматически заменено на имя, указанное
программистом.
Слово interface отмечает раздел интерфейса модуля. В этот раздел программист должен
поместить объявления находящихся в модуле процедур и функций, которые могут быть
вызваны из других модулей, использующих данный.
В раздел implementation (реализация) нужно поместить процедуры и функции, объявленные
в разделе interface. В качестве примера в листинге 6.8 приведен модуль программиста,
который содержит рассмотренные ранее функции isint и IsFloat.
Листинг 6.8. Модуль программиста

01.unit myjunit;
02.interface // объявления процедур и функции,
03.// доступных программам,
04.// использующим этот модуль
05.function Islnt(ch : char) : Boolean;
06.// функция Islnt проверяет, является ли символ
07.// допустимым во время ввода целого числа
08.function IsFloat(ch : char; st: string) : Boolean;
09.// Функция IsFloat проверяет, является ли символ допустимым
10.// во время ввода дробного числа
11.// ей — очередной символ
12.// st — уже введенные символы
13.implementation // реализация
14.// проверяет, является ли символ допустимым
15.
16.// во время ввода целого числа
17.function Islnt(ch : char] : Boolean;
18.begin
19.if [ch >= ' 0 ' ) and (ch <= ' 9 ' ] // цифры
20.or (ch = #13) // клавиша
21.or (ch = #8) // клавиша
22.then Islnt := True // символ допустим
23.else Islnt := False; // недопустимый символ
24.end; // проверяет, является ли символ допустимым
25.
26.// во время ввода дробного числа 27.function IsFloat (ch : char; st . string) : Boolean;
28.// ch — очередной символ
29.// at — уже введенные символы
30.begin
31.if (ch >= '0') and (ch <= ' 9 ' ) // цифры
32.or (ch = #13) // клавиша
33.or (ch = #8) // клавиша
34.then
35.begin
36.IsFloat := True; // символ верный
37.Exit; // выход из функции
38.end;
39.case ch of
40.'': if Length(st) = 0 then IsFloat : True;
41.',': if (Pos(',',st) = 0)
42.and (stfLength(st)] >= ' 0 ' )
43.and (st[Length(st)] <= ' 9 ' )
44.then // разделитель можно ввести только после цифры
45.// и если он еще не введен
46.IsFloat := True;
47.else // остальные символы запрещены
48.IsFloat := False;
49.end;
50.// это раздел инициализации
51.// он а данном случае не содержит инструкция
52.end.

Сохраняется модуль обычным образом, т. е. выбором из меню File команды Save, Вместе с
тем, для модулей повторно используемых процедур и функций лучше создать отдельную
папку, нажав ее, например, Units.
Использование модуля
Для того чтобы в программе могли применяться функции и процедуры модуля,
программист должен добавить этот модуль к проекту и указать имя модуля в списке
используемых модулей (обычно имя модуля программиста помещают в конец
сформированного Delphi списка используемых модулей).
В листинге 6.9 приведен вариант программы Поездка на дачу. Процедура обработки
события onkeypress в полях ввода исходных данных обращается к функции IsFloat, которая
находится в модуле my_unit.pas, поэтому в списке используемых модулей указано имя
модуля my_unit.
Листинг 6.9. Использование функции из модуля программиста

01.unit fazenda_;
02.interface
03.uses
04.Windows, Messages, SysOtils, Variants, Classes, Graphics, Controls,
05.Forms, Dialogs, StdCtrls,
06.my_unit; // модуль программиста
07.type
08.TForml = class(TForm)
09.Editl: TEdit; // расстояние
10.Edit2: TEdit; // цена литра бензина
11.Edit3: TEdit; // потребление бензина на 100 км
12.CheckBoxl: TCheckBox; // True — поездка туда и обратно
13.Buttonl: TButton; // кнопка Вычислять 14.Label4: TLabel; // поле вывода результата расчета
15.Labell: TLabel;
16.Label2: TLabel;
17.Label3: TLabel;
18.procedure EditlKeyPress(Sender: TObject; var Key: Char];
19.procedure Edit2KeyPress(Sender: TObject; var Key: Char);
20.procedure Edit3KeyPress(Sender: TObject; var Key: Char);
21.procedure ButtonlClicklSender: TObject);
22.private
23.1 Private declarations )
24.public
25./ Public declarations }
26.end;
27.var
28.Forml: TForml;
29.implementation
30.1$R *.dfm}
31.// нажатие клавиши в поле Расстояние
32.procedure TForml.EditlKeyPress(Sender: TObject; var Key: Char);
33.begin
34.if Key = Char(VK_RETURN)
35.then Edit2.SetFocus // переместить курсор в поле Цена
36.else If not IsFloat(Key,Edit2.Text) then Key := Chr(O);
37.end;
38.
39.// нажатие клавиши в поле Цена
40.procedure TForml.Edit2KeyPress(Sender: TObject; var Key: Char);
41.begin
42.if Key = Char(VK_RETURN|
43.then Edit3.SetFocus // переместить курсор в поле Потребление
44.else If not IsFloat(Key,Edit2.Text) then Key := Chr(O);
45.end;
46.// нажатие клавиши в поле Потребление
47.procedure TForml.Edit3KeyPress(Sender: TObject; var Key: Char];
48.begin
49.if Key = Char(VK_RETURN)
50.then Buttonl.SetFocus // // сделать активной кнопку Вычислить
51.else If not IsFloat(Key,Edit2.Text) then Key := Chr(O);
52.end;
53.// щелчок на кнопке Вычислить
54.procedure TForml.ButtonlClicklSender: TObject);
55.var
56.rast : real; // расстояние
57.cena : real; // цена
58.potr : real; // потребление на 100 км
59.summ : real; // сумма
60.mes: string;
61.begin
62.rast := StrToFloat(Editl.Text);
63.eena := StrToFloat(Edit2.Text);
64.potr := StrToFloat(Edit3.Text);
65.summ := rast / 100 * potr * cena;
66.if CheckBoxl.Checked then
67.suiim ; = зшпт * 2 ; 68.mes := 'поездка на дачу1;
69.if CheckBoxl.Checked then
70.mes := mes + ' и обратно';
71.mes := mes + 'обойдется в ' + FloatToStrFfsumm,ffGeneral,4,2}
72.+ ' руб.';
73.Label4.Caption := mes;
74.end;
75.end.

После добавления имени модуля в список модулей, используемых приложением, сам
модуль нужно добавить в проект. Для этого из меню Project надо выбрать команду Add to
Project и в открывшемся диалоговом окне — имя файла модуля. В результате добавления
модуля к; проекту в окне редактора появится вкладка с текстом добавленного к проекту
модуля.
Увидеть структуру проекта можно в окне Project Manager, которое появляется в
результате выбора соответствующей команды из меню View.
После добавления модуля к проекту и включения его имени в список используемых
модулей (инструкция uses) можно выполнить компиляцию программы.
Любой вновь создаваемый класс может содержать секции (разделы), определяемые
зарезервированными словами published (опубликованные), private (закрытые), protected
(защищенные), public (доступные) и automated (автоматизированные). Внутри каждой
секции вначале определяются поля, а затем  методы и свойства.
Секции определяют области видимости элементов описания класса. Секция public не
накладывает ограничений на область видимости перечисляемых в ней полей, методов и
свойств  их можно вызывать в любом другом модуле программы. Секция published также
не ограничивает область видимости, однако в ней перечисляются свойства, которые
должны быть доступны не только на этапе исполнения, но и на этапе конструирования
программы (т. е. в окне Инспектора объектов). Секция published используется только при
разработке нестандартных компонентов. Замечу, что среда Delphi помещает описания
компонентов, вставленных в форму, в специальную секцию без названия, которая
располагается сразу за заголовком класса и продолжается до первой объявленной секции.
Эта секция  published. Программисту не следует помещать в нее собственные элементы
описания класса или удалять из нее элементы, вставленные средой. Секция private сужает
область видимости до минимума: закрытые элементы описания доступны только внутри
методов данного класса и подпрограммах, находящихся в том же модуле, где описан класс.
Элемент, объявленный в секции private, становится недоступным даже ближайшим
потомкам класса, если они размещаются в других модулях. Секция protected доступна
только методам самого класса, а также любым его потомкам, независимо от того,
находятся ли они в том же модуле или нет. Наконец, секция automated используется только
для объявления свойств и методов, которые будут добавлены к так называемому
интерфейсу OLEобъектов Автоматизации; область видимости членов этой секции не
ограничена.
В Object Pascal разрешается сколько угодно раз объявлять любую секцию, причем порядок
следования секций не имеет значения. Любая секция может быть пустой.
Следующий фрагмент кода поясняет области видимости.
Unit Unit1;
Interface
Uses Controls, Forms;
type
TForm1 = class (TForm)
Button1: TButton; // Эта секция обслуживается Delphi // Ее элементы доступны всем
// Эта секция доступна в модуле Uniti
private
FIntField: Integers
Procedure SetValue(Value: Integers);
Function GetValue: Integer;
published
// Эта секция доступна в любом модуле
Property IntField: read GetValue write SetValue;
protected // Эта секция доступна классампотомкам
Procedure Proc1;
public // Эта секция доступна в любом модуле Procedure Proc2;
end;
var
Formi: TForm1;
Implementation Procedure TFormI.Proc1 ;
Buttoni.Color := clBtnFace;1
// Так можно
FIntField := 0;
// Так можно
IntField := 0;1
// Так можно Proc1;
// Так можно Proc2;1
// Так можно
end;
begin
Form1.Button1.Color := clBtnFace; // Так можно
Form1.FIntField := 0; // Так можно
Form1.IntField := 0; // Так можно
Form1.Proc1; // Так нельзя!
Form1.Proc2; // Так можно
end.
Unit Unit2;
Interface
Uses Controls, Unit1;
type
TForm2 = class(TFormI) Button2: TButton;
Procedure Button2Click(Sender: TObject);
end;
var
Form2: TForm2;
Implementation
Procedure TForm2.Button2Click(Sender: TObject);
begin
Buttoni.Color := clBtnFace; // Так можно
FIn'tField := 0; // Так нельзя!
IntField := 0; // Так можно
Proc1; // Так можно
Proc2; // Так можно
end;
begin
Form1.Buttoni.Color := clBtnFace; // Так можно Form1.FIntField := 0; // Так нельзя!
Form1.IntField := 0; // Так можно
Form1.Proc1; //Так нельзя!
Form1.Proc2; // Так можно
end.
При объявлении классапотомка разрешается перемещать элементы класса из одной
области видимости в другую. Для предыдущего примера допустимо такое объявление:
type
TForm2 = class(Tform1)
Public
Procedure Proc1;
end;
После этого в модуле unit2 возможно такое обращение:
Form2.Proc1;
После перемещения в секцию private элемент объявления становится невидим потомкам
(если потомок, как это обычно бывает, объявляется в другом модуле), и, следовательно,
его уже нельзя переместить в другую секцию.
Класс может объявляться только в интерфейсной области модуля или в самом начале
области реализации. Нельзя определять классы в разделе описаний подпрограмм.

file_name: тема 2 вопрос 28.docx

description:
приходится набирать текст функции зановоили копировать его из текста другой
программы.
Создание модуля
Delphi позволяет программисту поместить свои функции и процедуры в отдельный модуль,
а затем использовать процедуры и функции модуля в своих программах, указав имя модуля
в списке модулей, необходимых программе (инструкция uses).
Чтобы приступить к созданию модуля, нужно сначала закрыть окно формы и окно модуля
формы (в ответ на вопрос о необходимости сохранения модуля следует выбрать No, т. е.
модуль, соответствующий закрытой форме, сохранять не надо). Затем из меню File нужно
выбрать команду New | Unit. В результате открывается окно редактора кода, в котором
находится сформированный Delphi шаблон модуля. Его текст приведен в листинге 6.7.
Листинг 6.7. Шаблон модуля
1.unit Unitl;
2.interface
3.implementation
4.end.

Начинается модуль заголовком — инструкцией unit, в которой указано имя модуля. Во
время сохранения модуля это имя будет автоматически заменено на имя, указанное
программистом.
Слово interface отмечает раздел интерфейса модуля. В этот раздел программист должен
поместить объявления находящихся в модуле процедур и функций, которые могут быть
вызваны из других модулей, использующих данный.
В раздел implementation (реализация) нужно поместить процедуры и функции, объявленные
в разделе interface. В качестве примера в листинге 6.8 приведен модуль программиста,
который содержит рассмотренные ранее функции isint и IsFloat.
Листинг 6.8. Модуль программиста

01.unit myjunit;
02.interface // объявления процедур и функции,
03.// доступных программам,
04.// использующим этот модуль
05.function Islnt(ch : char) : Boolean;
06.// функция Islnt проверяет, является ли символ
07.// допустимым во время ввода целого числа
08.function IsFloat(ch : char; st: string) : Boolean;
09.// Функция IsFloat проверяет, является ли символ допустимым
10.// во время ввода дробного числа
11.// ей — очередной символ
12.// st — уже введенные символы
13.implementation // реализация
14.// проверяет, является ли символ допустимым
15.
16.// во время ввода целого числа
17.function Islnt(ch : char] : Boolean;
18.begin
19.if [ch >= ' 0 ' ) and (ch <= ' 9 ' ] // цифры
20.or (ch = #13) // клавиша <enter></enter>
21.or (ch = #8) // клавиша
22.then Islnt := True // символ допустим
23.else Islnt := False; // недопустимый символ
24.end; // проверяет, является ли символ допустимым
25.
26.// во время ввода дробного числа

description:
27.function IsFloat (ch : char; st . string) : Boolean;
28.// ch — очередной символ
29.// at — уже введенные символы
30.begin
31.if (ch >= '0') and (ch <= ' 9 ' ) // цифры
32.or (ch = #13) // клавиша <enter></enter>
33.or (ch = #8) // клавиша <bacspace></bacspace>
34.then
35.begin
36.IsFloat := True; // символ верный
37.Exit; // выход из функции
38.end;
39.case ch of
40.'': if Length(st) = 0 then IsFloat : True;
41.',': if (Pos(',',st) = 0)
42.and (stfLength(st)] >= ' 0 ' )
43.and (st[Length(st)] <= ' 9 ' )
44.then // разделитель можно ввести только после цифры
45.// и если он еще не введен
46.IsFloat := True;
47.else // остальные символы запрещены
48.IsFloat := False;
49.end;
50.// это раздел инициализации
51.// он а данном случае не содержит инструкция
52.end.

Сохраняется модуль обычным образом, т. е. выбором из меню File команды Save, Вместе с
тем, для модулей повторно используемых процедур и функций лучше создать отдельную
папку, нажав ее, например, Units.
Использование модуля
Для того чтобы в программе могли применяться функции и процедуры модуля,
программист должен добавить этот модуль к проекту и указать имя модуля в списке
используемых модулей (обычно имя модуля программиста помещают в конец
сформированного Delphi списка используемых модулей).
В листинге 6.9 приведен вариант программы Поездка на дачу. Процедура обработки
события onkeypress в полях ввода исходных данных обращается к функции IsFloat, которая
находится в модуле my_unit.pas, поэтому в списке используемых модулей указано имя
модуля my_unit.
Листинг 6.9. Использование функции из модуля программиста

01.unit fazenda_;
02.interface
03.uses
04.Windows, Messages, SysOtils, Variants, Classes, Graphics, Controls,
05.Forms, Dialogs, StdCtrls,
06.my_unit; // модуль программиста
07.type
08.TForml = class(TForm)
09.Editl: TEdit; // расстояние
10.Edit2: TEdit; // цена литра бензина
11.Edit3: TEdit; // потребление бензина на 100 км
12.CheckBoxl: TCheckBox; // True — поездка туда и обратно
13.Buttonl: TButton; // кнопка Вычислять

intro: Модули - это программные единицы, предназначенные для размещений фрагментов программ. С помощью содержащегося в них программного кода реализуется вся поведенческая сторона программы. Любой модуль имеет следующую структуру [Более точное описание структуры модуля приводится в п. 12.1.]: заголовок секция интерфейсных объявлений секция реализации терминатор Заголовок открывается зарезервированным словом Unit за которым следует имя модуля и точка с запятой. Секция интерфейсных объявлений открывается зарезервированным словом Interface, a секция реализации - словом implementation. Терминатором модуля, как и терминатором программы, является end с точкой. Следующий фрагмент программы является синтаксически правильным вариантом модуля:

информатика

group: Дисциплины

title: Лекция "Структура модуля в delphi "


extracted_text:
тема 2 вопрос 29
Библиотека визуальных компонентов Delphi
Эта библиотека объектов включает в себя стандартные объекты построения
пользовательского интерфейса, объекты управления данными, графические объекты,
объекты мультимедиа, диалоги и объекты управления файлами, управление DDE и OLE.
Библиотека визуальных компонентов (Visual Component Library — VCL) Delphi содержит
множество предопределенных типов компонентов, из которых пользователь может строить
свою прикладную программу. Палитра компонентов расположенна справа в полосе
инструментальных панелей интегрированной среды разработки Delphi.

Поскольку число страниц в палитре велико и не все закладки видны на экране
одновременно, в правой части палитры компонентов имеются две кнопки со стрелками,
направленными влево и вправо. Эти кнопки позволяют перемещать отображаемую на
экране часть палитры.
Чтобы перенести компонент на форму, надо открыть соответствующую страницу
библиотеки и указать курсором мыши необходимый компонент. При этом кнопка
указатель, размещенная в левой части палитры компонентов, приобретет вид не нажатой
кнопки. Это значит, что программист находится в состоянии, когда собирается поместить
компонент на форму. Чтобы поместить выбранный компонент на форму надо сделать
щелчок мышью в нужном месте формы.
Есть и другой способ поместить компонент на форму – достаточно сделать двойной
щелчок на пиктограмме компонента, и он автоматически разместится в центре формы.
Если компонент был выбран, но его не следует размещать на форме, то достаточно нажать
кнопку указателя. Это прервет процесс размещения компонента, и программа вернется в
нормальный режим, в котором можно выбрать другой компонент или выполнять какуюто
команду.
Имена компонентов, соответствующих той или иной пиктограмме, можно узнать из
всплывающей подсказки, появляющейся, если задержать над этой пиктограммой курсор
мыши. Если выбрать в палитре компонент и нажать клавишу F1, то отобразится справка по
типу данного компонента.

Имена на ярлычках выглядят, например, так: MainMenu, Button и т.д. Однако, в Delphi
все имена классов в действительности начинаются с символа «Т», например, TMainMenu,
TButton.
Палитра имеет ряд страниц, на которых скомпонованы пиктограммы всех компонентов,
предопределенных в Delphi.

Некоторые страницы из палитры компонентов
Наименование
страницы
Назначение компонентов страницы
Standard
Стандартная, содержащая наиболее часто используемые компоненты
Additional
Дополнительная, являющаяся дополнением стандартной
Win32
32битные компоненты в стиле Windows 95/98 и NT System
Системная, содержащая такие компоненты, как таймеры, плееры и ряд
других
BDE
Компоненты доступа к данным баз данных
Data Access
Компоненты связи с данными
Data Controls
Компоненты отображения данных баз данных
Internet
Компоненты для приложений, работающих с Интернет
Rave Reports
Компоненты для быстрой подготовки отчётов с данными баз данных
Dialogs
Компоненты диалогов: открыть, сохранить файл и др.
Samples
Образцы компонентов: SpinButton, SpinEdit, Calendar и другие

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

Визуальные компоненты VCL и ООП
Все то, что было сказано о классах, является лишь прелюдией к основной составляющей
Delphi  библиотеке визуальных компонент. Ну а поскольку компоненты VCL, в своей
массе, рассчитаны именно на визуальное программирование, то с этого момента мы
наконецто перейдем к примерам качественно нового уровня, создаваемым в визуальной
среде Delphi.
Библиотека VCL
Библиотека визуальных компонентов содержит множество классов, которые вы можете
использовать в своих приложениях. Она написана на языке Object Pascal и непосредственно
связана с интегрированной средой разработки Delphi. В частности, все кнопки,
расположенные на палитре компонент являются ни чем иным, как представлением
визуальных компонент VCL.
Вместе с тем, многие классы VCL не являются визуальными компонентами. Например,
существует специальный класс TStringList, используемый для работы с группами строк,
или же класс TRegistry, предназначенный для работы с реестром Windows. Но все классы в
Delphi, как мы знаем, происходят от общего предка  класса TObject, а прочие классы
являются его наследниками в том или ином поколении, образуя иерархию классов. Следующим классом в иерархии классов VCL, после TObject, является класс TPersistent. В
дополнение к методам TObject он имеет так же методы для присвоения данных свойствам
и для обмена объектов данными между собой (метод Assign). Параллельно классу
TPersistent существуют так же классы TException и TIniFile. Первый из них предназначен
для работы с исключительными ситуациями (т.е. обеспечивает обработку ошибок времени
выполнения), а второй инкапсулирует методы для работы с INIфайлами.
Если же говорить именно о компонентах, а не о какихто абстрактных классах, то их
прародителем является класс TComponent, являющийся прямым потомком класса
TPersistent. Именно происходящие от TComponent классы являются компонентами Delphi,
в том числе теми, что отображаются на палитре компонент. Помимо класса TComponent, у
TPersistent имеются еще 2 потомка  класс TClipboard, предназначенный для работы с
буфером обмена Windows и класс TStrings, являющийся основой для уже упоминавшегося
класса TStringList.
При всем этом компоненты, происходящие от класса TComponent, не обязательно
являются визуальными. Если же говорить именно о визуальных компонентах, то нам
следует продвинуться еще дальше, к классу TControl, являющимся общим предком для
всех элементов графического интерфейса в созданных при помощи Delphi приложениях
Windows. Но реальные компоненты, как правило, происходят не от самого класса TControl,
а от 2 его разновидностей, представленных, в случае для Windows, классами TWinControl и
TGraphicControl. Отметим, что полноценными оконными элементами управления (с
поддержкой ввода с клавиатуры, визуальной реакцией на действия пользователя и т.д.)
являются только наследники класса TWinControl. Что касается компонент, происходящих
от TGraphicControl, то они являются облегченным вариантом элементов интерфейса, не
требующими поддержки всех функциональных возможностей управления со стороны
операционной системы. Такими элементами являются, например, статические картинки,
используемые в оформлении программ (вроде логотипа в окне About) и т.п.
Другими наследниками класса TComponent, являются такие классы, как TScreen и
TApplication. Класс TScreen инкапсулирует в себе свойства и методы, необходимые для
работы с экраном, на котором запущено приложение. А класс TApplication является
основой для самого графического приложения, обеспечивая его взаимодействие с
операционной системой и выполняя рад иных вспомогательных действий вроде поддержки
системного меню или перехвата и обработки нажатий клавиатуры.
Таким образом, если представить все рассмотренные здесь классы в виде некой
древовидной структуры, выстроив ее по направлению от TObject до TWinControl, то мы
получим фрагмент иерархии классов VCL, относящийся к визуальным компонентам и
захватывающий некоторые ближайшие ответвления (рис. 8.1).
Рис. 8.1. Фрагмент иерархии классов VCL от TObject до TWinControl
Еще одним важным подспорьем в изучении VCL, помимо иерархии классов, является
исходный код самой библиотеки VCL, поставляемый вместе с Delphi. Обычно они
располагаются в каталоге Source, вложенном в тот каталог, в который вы установили саму
Delphi, например, C:\Program Files\Borland\Delphi\Source.
Класс TComponent
Теперь настало время более подробно ознакомиться с классами, на которых основываются
компоненты VCL. Начнем с основы  класса TComponent. В дополнение к методам своего
родителя  класса TPersistent, он имеет ряд собственных методов, а также здесь впервые появляются свойства. Именно благодаря свойствам, определенным в этом классе, одни
компоненты могут владеть другими. На практике это означает, что когда на такой
компонент, как форма (окно), вы помещаете другой компонент, скажем, кнопку, то кнопка
становится составной частью формы. Благодаря этой особенности при создании основного
компонента, все принадлежащие ему компоненты будут созданы автоматически. Равно как
и при удалении такого компонента, все принадлежащие ему компоненты так же удаляются
автоматически.
Рассмотрим свойства класса TComponent более подробно, для чего обратимся к таблице
8.1
Таблица 8.1. Основные свойства TComponent
Описание
Свойство
Число принадлежащих (дочерних) компонентов
ComponentCount Integer
Номер компонента в списке родительского компонента
владельца
ComponentIndex Integer
Тип
Components
array of
TComponent
ComponentState TComponentState
Name
Owner
Tag
String
TComponent
Integer
Список всех принадлежащих компонентов
Указывает на текущее состояние компонента, может
принимать значения csLoading, csReading, csWriting,
csDestroying, csDesigning, csAncestor, csUpdating,
csFixups, csFreeNotification, csInline, csDesignInstance
Определяет имя компонента, по которому к нему
следует обращаться из кода программы
Ссылается на компонент, являющийся владельцем
данного компонента
Хранит число, которое можно использовать в
произвольных целях
Важно отметить, что многие из этих свойств доступны только для чтения, т.е. их нельзя
изменить явно, присвоив им то или иное значение. Плный доступ допустим только для
свойств Name, Tag и ComponentIndex. Кроме того, свойства Name и Tag являются
опубликованными, и, соответственно, они будут видны в инспекторе объекта уже на этапе
разработки программы.
Что касается методов, то их для класса TComponent определено предостаточно, однако
подавляющее большинство из них используется либо для реализации какихлибо
внутренних механизмов взаимодействия в VCL, либо имеет весьма специфическое
предназначение. Что касается более приземленных методов, то среди них можно выделить
группу из 4 методов, предназначенных для манипулирования принадлежащими
компонентами:
 DestroyComponents  разрушает все принадлежащие компоненты
 FindComponent  возвращает ссылку на принадлежащий компонент по его имени,

если такового не найдется, то возвращает nil;
InsertComponent  добавляет компонент, указанный в качестве параметра, в качестве
принадлежащего. При этом он заносится в самый конец списка Components;
 RemoveComponent  удаляет указанный в качестве параметра компонент из списка
Components.
В качестве своего непосредственного родителя класс TComponent имеют такие
компоненты, как таймер (TTimer), невизуальные компоненты для доступа к данным
(TDataSet, TDataSource), компоненты для взаимодействия через DDE и другие. От него же
ведут свою "родословную" многие основополагающие классы, на основе которых строятся
другие компоненты. Самым интересным среди них, безусловно, является класс TControl, на
основе которого построены все визуальные компоненты в Delphi. Именно на основе класса
TControl можно изучить общие свойства всех элементов интерфейса (окон, кнопок, текстовых надписей, окон редактирования и т.д.), которые только можно создать в
приложении.
Свойства визуальных компонент
Как уже было отмечено, все визуальные компоненты происходят от класса TControl. Всего
для этого класса определено около 100 методов и свыше 50 свойств, и это  помимо
свойств и методов, унаследованных от TComponent. Причем многие из них, особенно если
рассматривать свойства, довольно часто используются при практической разработке
приложений в контексте того или иного визуального компонента, начиная от окнаформы,
и заканчивая текстовыми подписями.
Рассмотрим такие свойства, обратившись к таблице 8.2.
Таблица 8.2. Основные свойства класса TControl
Свойство
Action
Тип
TBasicAction
Constraints
Cursor
TSizeConstraints Определяет минимальные и максимальные размеры
TCursor
Align
TAlign
Anchors
TAnchors
AutoSize
Boolean
Caption
Sttring
ClientHeight
Integer
ClientWidth
Integer
Color
TColor
DragCursor
TCursor
DragKind
TDragKind
DragMode
TDragMode
Enabled
Boolean
Font
Height
HelpContext
TFont
Integer
Integer
HelpKeyword
String
HelpType
THelpType
Описание
Определяет действие, связанное с данным элементом
Определяет выравнивание элемента относительно
родительского элемента. Допустимые значения: alNone,
alTop, alBottom, alLeft, alRight, alClient, alCustom
Определяет, по каким краям данный элемент
привязывается к родительскому. Допустимые значения
akTop, akLeft, akRight, akBottom
Определяет, может ли размер элемента изменяться
автоматически, в зависимости от содержимого
Определяет текстовую строку, идентифицирующую
элемент длЯ пользователя
Определяет высоту внутреннего пространства элемента,
доступную для размещения других элементов в пикселях
Определяет ширину внутреннего пространства элемента,
доступную для размещения других элементов в пикселях
Определяет цвет фона элемента. Цвет задается при
помощи ключевых слов (clNone, clAqua и т.д.) или
числовым значением в диапазоне $7FFFFFFF
1..$7FFFFFFF
элемента, задаваемые четырьмя целыми
Определяет тип курсора. Например, crDefault, crNone и т.д.
Определяет тип курсора в момент перетаскивания.
Например, crDefault, crNone и т.д.
Определяет, будет ли элемент при перетаскивании просто
перемещаться или должен быть пристыкован, может
принимать значения dkDrag, dkDock
Определяет, как должны инициироваться операции drag
anddrop и draganddock. Допустимые значения dmManual,
dmAutomatic
Определяет, должне ли элемент реагировать на событиЯ
клавиатуры, мыши и таймера
Определяет атрибуты шрифта длЯ текстового наполнения
элемента.
Определяет высоту элемента в пикселях
Определяет индекс раздела в файле справки, относящегося
к этому элементу
Определяет ключевое слово в файле справки,
относящегося к этому элементу
Определяет, по какому критерию должно производиться
обращение к файлу справки, по слову (htKeyword), или по Hint
Left
Name
Parent
String
Integer
String
TWinControl
ParentColor
Boolean
ParentFont
Boolean
ParentShowHint Boolean
PopupMenu
TPopupMenu
ShowHint
Boolean
Text
String
Top
Visible
Width
Integer
Boolean
Integer
номеру (htContext)
Определяет текст всплывающей подсказки
Определяет горизонтальную координату левой стороны
элемента в пикселях по отношению к родительскому
Определяет имя элемента
Определяет родительский элемент, в целом аналогична
свойству Owner, но всегда ссылается на элемент типа
TWinControl
Определяет, должен ли элемент унаследовать фоновый
цвет у содержащего объекта
Определяет, должен ли элемент унаследовать оформление
шрифта у содержащего объекта
Определяет, должен ли элемент унаследовать показ
подсказки у содержащего объекта
Определяет всплывающее (контекстное) меню, связанное с
данным элементом
Определяет, показывать или нет всплывающую подсказку
для данного элемента
Определяет текст, который должен быть отображен
элементом. В зависимости от типа элемента, используется
либо свойство Text, либо Caption
Определяет вертикальную координату верхней стороны
элемента в пикселях по отношению к родительскому
Определяет, должен ли компонент быть видимым
Определяет ширину элемента в пикселях
Достаточно создать новый проект в Delphi (File > New > Application), и щелкнуть по окну
первой формы, созданной для приложения (Form1), чтобы увидеть многие из
перечисленных в таблице свойств в окне инспектора объекта. Разумеется, учитывая то, что
класс TForm, на основе которого создаются формы, является наследником
рассматриваемого класса TControl далеко не в первом поколении, а на каждом этапе
добавляются все новые и новые свойства, то список доступных свойств будет большим,
нежели в таблице.
Между тем, из приведенных здесь свойств, некоторых может и не оказаться среди перечня
свойств того или иного компонента. Это объясняется тем, что они скрываются за
ненадобностью. Например, для формы не предусмотрено такого свойства, как DragCursor,
поскольку для окна оно бессмысленно  как известно, операции типа "перетащи и брось" в
Windows с окнами не производятся.
С теми или иными исключениями и дополнениями данные свойства имеются и для других
визуальных компонент  будь то кнопки, поля редактирования текста, списки, рамки,
переключатели и т.д. Причем общее их количество довольно сильно варьируется в
зависимости от конкретного компонента. Свою долю вносит и версия Delphi, поскольку от
версии к версии могут добавляться какиелибо новые свойства. В результате для Delphi 7
мы имеем 60 свойств для формы, 33  для кнопки и 47  для поля редактирования текста
(рис. 8.2). Рис. 8.2. Инспектор объекта со свойствами формы, кнопки и текстового поля
Из тех свойств, что всегда доступны для любого объекта в VCL, можно выделить такие,
как Tag и Name. Если же брать визуальные компоненты, то для них всегда актуальны так
же свойства, отвечающие за размеры (Height, Width и т.д.), вид курсора, шрифт, связь со
справочной системой и т.д.
СОВЕТ
Всегда можно получить подсказку по любому интересующему вас свойству, выбрав его в
инспекторе объекта и нажав на клавишу F1.
Что касается методов, предоставляемых классом TControl, то, с одной стороны, их еще
больше, чем свойств, а с другой  сама суть их использования еще более зависима от того, в
контексте какого компонента тот или иной метод используется. По этой причине мы будем
рассматривать их постепенно, преимущественно по мере ознакомления с конкретными
компонентами.
События
Вся работа Windows построена вокруг событий. Событием является нажатие на
клавиатуру, движения и щелчки мышки, действия внутренних устройств компьютера и т.д.
Причем каждое событие генерирует сообщение, которое необходимо перехватить и
обработать. При этом операционная система производит предварительную сортировку всех
этих сообщений, и направляет приложению только ту их часть, которая к нему относится.
И все равно таких сообщений множество, поскольку даже если пользователь всего лишь
проведет указателем мышки над окном приложения, это инициирует целый поток
сообщений.
К счастью, Delphi большую часть работы по обработке событий берет на себя. Фактически,
при разработке приложений, использующему Delphi разработчику необходимо всего лишь
установить собственные обработчики на те события, которые ему действительно
необходимо обработать. Типичный пример  нажатие на клавишу мышки. Причем, опять
таки, благодаря Delphi, не понадобиться отслеживать различные фазы нажатия (кнопка
опущена  кнопка отжата  кнопка отпущена), как и следить за тем, от какого источника
пришел сигнал (т.е. был ли это щелчок мышкой, или нажатие Enter, или было использовано
сочетание горячих клавиш).
Отметим, что события, как часть класса VCL, впервые появляются, начиная как раз с
класса TControl. Таким образом, в дополнение к полутора сотням свойств и методов этого
класса, мы получим еще некоторое количество событий. Собственно говоря, событие
представляет собой ничто иное, как свойство процедурного типа, предназначением
которого является обеспечение реакции на те или иные действия. Когда такому свойству
присваивают значение, то фактически указывается метод, вызываемый при наступлении
данного события. Подобные методы называют обработчиками событий (event handlers).
События в Delphi подразделяются на несколько типов, в зависимости от того, что
представляет собой то или иное событие. Простейшим и одним из наиболее распространенных является тип TNotifyEvent, характерный для обычных уведомляющих
событий. В VCL этот тип описан следующим образом:
type TNotifyEvent = procedure(Sender: TObject) of object;
Единственный параметр Sender здесь обозначает объект, являющийся источником
возникшего события.
Рис. 8.3. Инспектор объекта со списком событий для формы, кнопки и текстового поля
Переходя от общих слов к делу, вновь обратим свое внимание на инспектор объекта.
Можно заметить, что помимо закладки свойств (properties), он содержит еще и вторую
закладку  события (events). На ней приводится список событий, которые могут быть
обработаны данным объектом (рис. 8.3).
Подобно свойствам, многие события повторяются для разных объектов. Наиболее
распространенным типом является событие OnClick, которое происходит в момент щелчка
мышкой  оно существует практических у всех визуальных компонент.
Для того чтобы назначить обработчик событию, при разработке приложения в среде Delphi,
достаточно сделать двойной щелчок по полю нужного события в инспекторе объекта.
Например, если выбрать форму и дважды щелкнуть по строке инспектора объектов
напротив надписи "OnClick", то Delphi автоматически сгенерирует весь нужный код.
Прежде всего, это будет заготовка для самого обработчика событий:
procedure TForm1.FormClick(Sender: TObject); begin end;
Кроме того, если теперь посмотреть объявление самой формы, то можно будет увидеть,
что в часть объявлений класса TForm1 добавилось объявление этой процедуры:
procedure FormClick(Sender: TObject);
Таким образом, нам остается лишь добавить свой код в тело процедуры, созданной для
обработчика события щелчка мышкой по форме. Пусть это будет смена заголовка окна с
предлагаемого по умолчанию значения (Form1) на все ту же фразу "Hello, World!". Для
этого достаточно обратиться к свойству Caption объекта Form1, и назначить ему новое
значение. В итоге, вся процедура примет следующий вид:
procedure TForm1.FormClick(Sender: TObject); begin Form1.Caption:='Hello, World!'; end;
Теперь, если запустить такое приложение на выполнение (нажав F9), и щелкнуть в любом
месте его окна мышкой, то текст заголовка окна изменится с "Form1" на "Hello, World!".
Методы визуальных компонент
Итак, события представляют собой свойства, для которых определяются методы. Таким
образом, от событий мы вновь возвращаемся к теме методов, в аспекте их работы с
визуальными компонентами.
ПРИМЕЧАНИЕ
Отметим, что в отличие от обычных свойств, или от событий, для методов в инспекторе
объектов места не нашлось. Поэтому чтобы получить справочную информацию о методах,
следует сперва обратиться к справке по самому компоненту, а уже из самого окна справки
щелкнуть по ссылке "Methods". Прежде всего, методы предоставляют иной путь управления компонентами. Поскольку
компоненты  это все те же объекты, они могут иметь процедуры и функции. Таким
образом, по аналогии с любыми другими классами, метод визуального компонента
представляет собой процедуру или функцию, объявленную в общедоступной части класса,
и которую можно вызвать при работе с данным компонентом. Например, когда мы
изменяли заголовок окна, то использовали свойство Caption. А вот если бы мы хотели,
скажем, скрыть форму (сделать ее невидимой), то следовало бы обратиться к методу Hide:
Form1.Hide;
Помимо метода Hide, а так же определенных еще для родительских классов методов вроде
Create и Free, класс TControl имеет ряд других часто применяемых методов, которые
наследуются визуальными компонентамипотомками этого класса. Некоторые из наиболее
часто употребляемых методов приведены в таблице 8.3.
Описание
Таблица 8.3. Некоторые методы класса TControl
Метод
BringToFront Делает форму видимой или переносит элемент, скрытый на форме под
Perform
Refresh
Repaint
SendToBack Переносит элемент на задний план
Show
Update
другими элементами, на передний план
Пересылает элементу указанное Windowsсообщение
Инициирует обновление (перерисовку) объекта на экране
Синоним для Refresh
Делает элемент видимым
Инициирует немедленное выполнение всех сообщений, связанных с ожиданием
обновления (перерисовки) элемента
Важно отметить, что большинство компонент, в отличие от обычных классов, нельзя
создать "просто так". Т.е. каждый компонент должен иметь своего родителя, к которому
он привязан. Поэтому если требуется создать, скажем, кнопку, причем именно
программным методом, то недостаточно просто создать экземпляр класса  необходимо
так же указать его родительский объект, для чего, вопервых, уже при обращении к
конструктору указывают имя объектаконтейнера, а вовторых, уже после создания явно
определяют свойство Parent. В качестве родительского компонента может выступать
любой другой компонент, который может содержать в себе иные компоненты, например,
форма:
var Form1: TForm1; But: TButton; ... But:=TButton.Create(Form1); But.Parent:=Form1;
К счастью, при создании экземпляров компонент визуальными методами (т.е. в
графической среде Delphi) вся необходимая работа выполняется автоматически.
Типы методов
Метод может вызываться различными способами, в зависимости от вида самого метода.
Все методы подразделяются на несколько видов  статические, динамические, виртуальные
и т.д. Тип метода задается при его описании в классе при помощи одного из ключевых
слов:

static  статический метод, такой тип методы имеют по умолчанию. Статические
методы нельзя переопределять, но можно делать перегружаемыми;
virtual  виртуальный метод. Виртуальные методы можно переопределять, а их
выполняемый код оптимизируется под скорость выполнения;
dynamic  динамический метод. Аналогичен виртуальному методу с той лишь
разницей, что его исполняемый код будет оптимизирован по размеру;
override  переопределяемый метод. Директива override указывает, что данный
метод переопределяет унаследованный одноименный виртуальный или
динамический метод;
overload  перегружаемый метод. Перегружаемые методы не скрывают наследуемые
методы, при этом они должны различаются по своим параметрам;




 message  метод обработки сообщения. Для примера переопределяемого определим некий класс TFigure с методом Draw, а так же
создадим его потомков  классы TCircle и TSquare с одноименными методами, которые и
переопределим:
type TFigure = class procedure Draw; virtual; end; TCircle = class(TFigure) procedure Draw;
override; end; TSquare = class(TFigure) procedure Draw; override; end;
Если теперь создать переменную типа TFigure, и использовать конструктор класса TSquare,
а затем вызвать метод Draw, то вызван будет метод класса TSquare. Если же для
переменной использовать конструктор класса TCircle, то метод уже этого класса будет
вызван:
var Fig: TFigure; begin Fig := TSquare.Create; Fig.Draw; // вызов TSquare.Draw Fig.Destroy;
Fig := TCircle.Create; Fig.Draw; // вызов TCircle.Draw Fig.Destroy; end;
В то же время, если бы, скажем, класс TCircle не имел собственного определения метода
Draw, то был бы вызван метод, унаследованный от класса TFigure. Что касается
перегружаемых методов, то суть их использования сводится к тому, что на разных уровнях
наследования в родственных классах можно использовать одноименные методы,
различающиеся лишь количеством и (или) типом параметров. Например, если взять те же
классы TFigure и TSquare, то можно было бы использовать не переопределяемые, а
перегружаемые методы:
type TFigure = class procedure Draw(left, top: integer); end; TCircle = class(TFigure) procedure
Draw(left, top, radius: integer); overload; end; TSquare = class(TFigure) procedure Draw(left,
top, width, height: integer); overload; end;
Таким образом, в зависимости от того, с какими параметры будет вызван метод Draw,
будет произведено обращение к той или иной процедуре:
var Fig: TFigure; begin Fig := TSquare.Create; Fig.Draw(10,10,30,40); // вызов TSquare.Draw
Fig.Draw(5,50); // вызов TFigure.Draw Fig.Destroy; end;
Следует так же отметить, что если перегружается виртуальный метод, то в дочерних
классах следует использовать директиву reintroduce. Наконец, полезно так же знать, что
перегружаемыми могут быть не только методы классов, но и любые другие процедуры и
функции.

file_name: тема 2 вопрос 29.docx

intro: Библиотека визуальных компонентов (Visual Component Library — VCL) Delphi содержит множество предопределенных типов компонентов, из которых пользователь может строить свою прикладную программу. Палитра компонентов расположенна справа в полосе инструментальных панелей интегрированной среды разработки Delphi.Поскольку число страниц в палитре велико и не все закладки видны на экране одновременно, в правой части палитры компонентов имеются две кнопки со стрелками, направленными влево и вправо. Эти кнопки позволяют перемещать отображаемую на экране часть палитры.

title: Лекция "Библиотека визуальных компонентов Delphi"