Лекция 11. Структура проекта
Здесь вы познакомитесь со структурой проекта и с файлами, которые составляют проект. Подробно разберем структуру модуля, его разделы.
До сих пор мы создавали программы, не задумываясь о том, какие файлы при этом создаются, для чего они нужны. Нам понятно, что файл проекта с расширением *.exe – это сама программа, которая получилась после компиляции проекта. Файлы с расширением *.pas – файлы модулей, содержащих исходный код программы. Настало время подробней изучить структуру проекта, из каких файлов он состоит, для чего они нужны, какова их внутренняя структура.
Модуль
Проект в Delphi представляет собой набор программных единиц – модулей. Модуль на английском языке называется Unit. Когда мы разрабатываем форму, мы одновременно обрабатываем модуль этой формы. Модуль – это файл с расширением *.pas. Это расширение – сокращение от языка программирования Pascal, на котором строилась Delphi. Иначе говоря, модуль – исходный код программы, или исходник. Как только мы создаем новую форму, сразу же создается и модуль для нее. Delphi заполняет этот модуль необходимым кодом, а нам остается создавать код для обработки кнопок и различных событий.
Давайте на примере уже рабочей программы посмотрим, из чего состоит проект. Откройте проект MyNotebook из лекции 8. Перейдите на редактор кода.
На самом верху вы видите строку
unit Main;
Unit – это зарезервированное слово, обозначающее Модуль формы. Зарезервированными называются служебные слова, которые уже имеют собственные названия в компиляторе, и такие названия нельзя давать переменным, константам, массивам, компонентам, функциям или процедурам. Зарезервированные слова в коде всегда выделяются жирным шрифтом, вы можете это видеть на примере таких слов, как unit, interface, uses, begin или end, и так далее:
Рис. 11.1. Фрагмент редактора кода
Когда мы создавали форму, то сразу дали ей имя (свойство Name) fMain. А когда сохраняли проект, Delphi прежде всего запросила имя для модуля формы. Мы назвали модуль также как форму, но без начальной буквы f - Main. Вот почему наверху кода unit (Модуль) этой формы имеет имя Main. Теперь вы понимаете, как важно соблюдать правила наименования форм и модулей? Когда в проекте будет много форм, то и модулей будет много, и если вы не будете соблюдать эти правила, то запросто запутаетесь в названиях. И также важно давать формам и модулям осмысленные имена. В сложных проектах таких форм и модулей может быть сотни!
Но вернемся к проекту MyNotebook. Взгляните на код. Далее идет служебное слово interface. Эта директива сообщает компилятору, что начинается раздел интерфейса. В этом разделе, прежде всего, указываются модули, подключенные к данному модулю. Они описываются после служебного слова uses. Когда мы вводим какую-либо функцию или процедуру, мы не задумываемся, откуда она берется. А эта функция описана в одном из подключенных модулей! Давайте в этом убедимся. Спустите курсор в нижнюю часть модуля. Последней у нас описана процедура вызова модального окна fAbout. Ниже этого вызова введите строку:
ShowMessage('Привет!');
Она тут совершенно не нужна, и потом мы ее удалим. А пока что установите курсор внутри самого слова ShowMessage, и нажмите <Ctrl>+<F1>. Тем самым, вы вызываете контекстную подсказку именно об этой команде. И в самом начале справки вы видите указание, в каком модуле описана данная процедура:
Unit
Dialogs or QDialogs
Теперь вернитесь к разделу uses, в котором описаны подключенные модули. Вы можете убедиться, что модуль Dialogs в списке присутствует. Если бы это было не так, то при попытке вызвать процедуру ShowMessage компилятор сразу сообщил бы нам об ошибке, он просто не нашел бы описания этой процедуры и не знал, откуда ее вызвать. Данный раздел подключенных модулей Delphi генерирует самостоятельно, и добавлять сюда другие модули вручную приходится лишь в том случае, когда вы хотите воспользоваться процедурой, описанной в модуле, которого в списке нет. Вы точно знаете, что такая процедура или функция существует, но компилятор выдает ошибку. Тогда вы устанавливаете курсор на имя процедуры и вызываете контекстную подсказку. И смотрите, в каком модуле описана данная процедура. Если этого модуля в списке нет, а процедура вам нужна позарез, добавьте модуль в список.
Кстати, количество подключенных к форме модулей объясняет, почему, казалось бы, небольшой проект имеет достаточно большой размер *.exe файла. Ведь подключенные модули содержат множество описаний функций и процедур, и даже если мы их не используем, они все равно доступны. Однако беспокоиться по этому поводу не стоит – нам едва ли придется писать программы, для которых критичен размер исполняемого файла. Это, как правило, драйверы или вирусы, и хотя на Delphi можно написать и то, и другое, для этих задач больше подходит чистый С. А если вы будете использовать Borland C++ Builder или Microsoft C++ Visual, то и они имеют множество подключенных модулей, и размер даже маленькой программки окажется большим.
Вернемся к нашему коду. Далее идет служебное слово type, которое описывает форму – какие в ней находятся компоненты, как они называются, и какие процедуры используются. В этом блоке вы видите разделы:
private
{ Private declarations }
public
{ Public declarations }
В раздел private можно добавлять описания собственных функций и процедур, которые не должны быть видны из других подключенных модулей. А если вы эти же самые процедуры и функции опишите в разделе public, то их можно будет использовать и в других модулях проекта. Позже мы не раз будем пользоваться этой возможностью.
Далее идет описание глобальных записей, констант и переменных. Здесь у нас есть только одна глобальная переменная:
var
fMain: TfMain;
Это – форма. Да, да, не удивляйтесь, форма – это переменная типа TForm. Точнее, не просто переменная, а объект со своими свойствами, событиями и методами.
Здесь же вы можете объявить собственные переменные или массивы, чтобы они стали глобальными. Глобальные переменные видны во всем модуле, в любой, описанной ниже процедуре или функции. Вот пример: допустим, нам много раз придется проверять адрес, откуда запущена программа. Скажем, по этому адресу у нас лежит файл, в который мы то и дело сохраняем различные настройки программы, или считываем их. А в процессе работы программы текущая папка может быть изменена на другую. В результате, обратившись к файлу просто по имени, мы рискуем вызвать ошибку в программе. Чтобы этого избежать, нужно полностью указывать и адрес файла, и его имя.
В этом разделе глобальных переменных мы можем создать собственную переменную:
var
fMain: TfMain;
adres: String; //для адреса, откуда запущена программа
Затем выделить главную форму, перейти на вкладку Events (События) и двойным щелчком мыши сгенерировать событие OnCreate, которое происходит однажды, при создании формы, или же OnActivate, которое происходит, когда форма становится активной. В этом событии прописать такую строку:
adres := ExtractFilePath(Application.ExeName);
Переменную adres в процедуре описывать не нужно – она глобальная, и мы ее уже описали. Функция Application.ExeName вернет полное имя файла нашей программы, а функция ExtractFilePath() вычленит из этого имени адрес, и вернет его. В дальнейшем, в любой процедуре или функции модуля, где будет необходимо обратиться к файлу, например, myparam.ini, который находится там же, откуда запущена программа, достаточно указать:
... adres + 'myparam.ini' ...
и мы получим имя файла вместе с полным адресом, откуда бы программа ни была запущена.
Далее идет раздел implementation. Это раздел реализации. Он содержит сами процедуры и функции, которые поддерживают работу этой формы. Кроме того, в этом разделе также может присутствовать директива uses, в которой объявлены модули, подключенные к данной форме. Данный раздел необязателен – если в вашем проекте только одна форма, то раздела не будет вовсе. Если есть еще одна форма, как в нашем примере – форма fAbout, модуль которой называется About, то этот раздел добавляется автоматически, как только вы воспользуетесь командой File -> Use Unit. Сразу под ключевым словом implementation у нас есть строка
uses About;
которая говорит о том, что к данной форме подключен модуль About. Можно модули добавлять и вручную, однако лучше все-таки делать это с помощью команды меню – так вы будете застрахованы от возможных ошибок. Однако если вы создали ошибочную связь с другой формой, то удалить эту связь можно вручную.
Далее вы видите такую строку, выделенную зеленым цветом:
{$R *.dfm}
Это не комментарий, как можно было бы подумать, а директива компилятору, что в процессе компиляции следует использовать файл описания формы. Файлы, которые составляют проект, мы рассмотрим чуть позже.
После этой директивы, собственно, и начинается работа программиста. Далее идут процедуры и функции, сгенерированные для обработки событий компонентов формы. Сюда же программист может добавить собственные процедуры и функции, однако не забывайте правила – чтобы воспользоваться процедурой или функцией, она должна быть описана выше того места, где мы хотим ее вызвать!
Самой последней строкой в модуле обязательно должна присутствовать завершающая модуль команда end с точкой. Точка указывает, что модуль завершен, после нее других строк быть не должно.
Закройте этот проект, сохранять его не нужно, команда ShowMessage, которую мы дали для примера, в программе не нужна. Создайте новый проект и перейдите в редактор кода. Сразу после директивы компилятора вы видите строку
end.
Обратите внимание, что слова begin перед ней нет, и быть не должно! Это – единственное исключение из правила скобок begin..end. Собственно, это даже не исключение, потому что эта end не является закрывающей скобкой, это завершение модуля.
Теперь, если мы будем устанавливать на форму компоненты, и обрабатывать для них события, будут формироваться процедуры между директивой компилятору и завершающей end.
Файлы проекта
Мы уже говорили, что проект состоит из множества файлов. Откройте папку с проектом MyNotebook, и посмотрите, какие файлы там есть. В таблице 11.1 приведены описания файлов, составляющих проект, и их расширений:
| Таблица 11.1. Описание файлов проекта | |
| Расширение | Описание файла |
| *.cfg | Этот файл содержит конфигурацию всего проекта, поэтому он один, и имеет имя, как у проекта. Редактировать этот файл вручную не стоит, если не хотите испортить проект. |
| *.dof | Этот файл содержит опции проекта – настройки, версию Delphi, версию проекта, используемые модули и многое другое. Редактировать этот файл вручную нельзя. |
| *.dpr | Это сам проект. Это текстовый файл с описанием используемых форм и модулей, а также процедура инициализации программы. Редактировать такой файл вручную можно, но только опытным программистам, которые точно знают, что они делают, и для чего это нужно. Даже им это бывает необходимо очень редко, поэтому лучше файл не трогать. Однако можно загрузить проект, просто щелкнув по нему дважды, либо поставить на него курсор и нажать Enter. Если Delphi не загружена, она загрузится и загрузит проект. |
| *.res | Файл ресурсов проекта, таких как иконки, курсоры и так далее. |
| *.pas | Модуль формы. Этот файл мы видим в редакторе кода, его мы редактируем. Таких файлов имеется по одному на каждую форму проекта. |
| *.dfm | Это файлы с информацией о форме. Тут содержатся описания используемых компонентов и их настройки. |
| *.ddp | Это вспомогательные файлы модуля, они генерируются автоматически. |
| *.dcu | Откомпилированный файл модуля. Фактически, та же программа, но только для одного модуля. Работать самостоятельно она не может. |
| *.exe | Готовая программа. Компилятор собирает все *.dcu в единый исполняемый файл. Если вы в проекте не использовали других файлов, таких как базы данных, например, то этот файл единственный, который нужен. При распространении программы отдавайте пользователю только его. Однако это не значит, что все остальные файлы можно удалить. Ведь в них ваш проект! В будущем, возможно, вам понадобится процедура или функция, аналогичная той, которую вы использовали в проекте. Чтобы заново не изобретать велосипед, просто откройте старый проект и посмотрите, как вы реализовали эту функцию. Скопируйте ее и вставьте в новый проект, если нужно. |
| *.~* | Файлы, расширение которых начинается с тильды – это резервные копии модулей и форм. Когда вы производите изменения и сохраняете проект, появляется такой файл. Это предыдущее сохранение. Если вы сохранили проект, и увидели, что ошиблись – его можно восстановить из этого файла. Однако лучше всего делать архивные копии проекта перед каждым серьезным изменением программы. |
Описание содержит основные файлы проекта. Иногда приходится использовать в проекте и другие файлы, и мы будем их изучать, когда придет время применять их на практике.
Лекция 12. Тип TStrings
В этой лекции вы познакомитесь с типом TStrings, изучите компоненты ListBox и ComboBox, создадите несколько программ, использующих пройденный материал. Кроме того, научитесь управлять циклами: прерывать их и принудительно переходить на новый виток цикла.
Строка и строки TStrings
В практике программирования чаще всего приходится работать со строками. Будь то обычный Edit или Memo, там используются строки. И даже если вы вставляете Edit, чтобы запросить у пользователя число, он все равно вводит его в качестве строки, и вам требуется преобразовать его в числовой тип, чтобы работать с ним, как с числом.
Итак, что такое строка? Фактически, это массив символов. Давайте посмотрим пример:
var
s : String;
a : array [1..7] of Char;
begin
s := 'Привет!';
ShowMessage(s); //Результат: вывод строки "Привет!"
a[1] := 'П';
a[2] := 'р';
a[3] := 'и';
a[4] := 'в';
a[5] := 'е';
a[6] := 'т';
a[7] := '!';
ShowMessage(a); //Результат: вывод строки "Привет!"
ShowMessage(s[1]); //Результат: вывод буквы "П"
ShowMessage(a[1]); //Результат: вывод буквы "П"
К сожалению, мы не можем просто так взять и присвоить массиву строку – это будет ошибкой, поэтому a := s не скомпилируется. Однако после того, как в массив мы посимвольно ввели текст, это получается уже полноценной строкой, поэтому компилятор разрешит директиву ShowMessage(a);, и программа отработает без ошибок. Разумеется, неразумно использовать массив символов там, где проще использовать переменную типа String. Этот пример показывает, что строка – это тот же массив символьного типа!
Однако мы с вами уже сталкивались и с типом TStrings – строки. Такой тип мы использовали в свойстве Lines компонента Memo и вы уже убедились, насколько мощный это тип и как легко с ним работать. Он позволяет добавлять или удалять строку из списка строк, с его помощью легко записать строки в файл или наоборот, загрузить их из файла. Тип TStrings присутствует во многих компонентах, и везде вы с ним можете производить такие вот действия! Раз уж мы заговорили о массивах, то проведем сравнение и для TStrings – это тот же массив, только не типа Char (символ), а типа String (строка):
a : array [1..10] of String;
Однако, хотя TStrings по своему образу похож на такой массив, он имеет массу дополнительных возможностей, поэтому используйте его везде, где встает речь о работе с набором строк!
ListBox – список выбора
Списки выбора хранят в себе какие-то списки, и дают пользователю возможность выбирать одну из указанных строк. Часто их применяют в окнах с заданными параметрами, чтобы пользователь мог выбрать один из параметров.
Чтобы получить доступ к строкам списка, нужно воспользоваться свойством Items компонента ListBox. Это свойство имеет тип TStrings (строки), с таким типом мы сталкивались, когда обрабатывали компонент Memo.
Посмотрим на практике, как работать с данным компонентом. Создайте новое приложение, установите на него один компонент ListBox, и под ним – один Edit для вывода той строки, которую выбрал пользователь:
Рис. 12.1. Внешний вид формы
Затем дважды щелкните по свойству Items компонента ListBox. Перед вами откроется уже знакомый редактор строк. Наберите названия операционных систем:
MS-DOS
Windows 3.10
Windows 95
Windows 98
Windows ME
Windows 2000
Windows XP
Windows Vista
Unix
Linux
OS/2
Каждое название операционной системы должно быть на отдельной строке. Нажмите "ОК", чтобы сохранить результат. Теперь создайте для компонента ListBox обработчик события onClick. Мы уже знаем, что это событие срабатывает всякий раз, когда пользователь выберет одну из строк в указанном списке.
В обработчике событий напишите только одну строку:
Edit1.Text := ListBox1.Items.Strings[ListBox1.ItemIndex];
Эта строка присваивает свойству Text компонента Edit тот текст, который хранится в выбранной строке списка ListBox. Свойство Items имеет свое свойство Strings, которое представляет собой массив из строк списка. Указав индекс массива, мы можем получить доступ к нужной строке. В примере в качестве индекса указано свойство ListBox1.ItemIndex, которое имеет тип Integer и возвращает элемент выбранной строки в массиве строк. Кстати, когда вы поставите точку и откроется список, там вы этого свойства не обнаружите, так что придется писать его вручную.
Сохраните пример в новую папку, откомпилируйте и посмотрите, как он работает.
Кроме того, мы имеем возможность программно добавлять в ListBox новую строку или удалять выбранную. Киньте на форму еще две кнопки и напишите на них – "Добавить строку", "Удалить строку". Добавлять будем строку, написанную в компоненте Edit, а удалять – выделенную.
Для кнопки "Добавить" впишите:
ListBox1.Items.Add(Edit1.Text);
а для кнопки "Удалить":
ListBox1.Items.Delete(ListBox1.ItemIndex);
Сохраните проект, откомпилируйте и посмотрите, как он работает.
Часто бывает необходимым предоставить пользователю возможность множественного выбора. Пользователь, удерживая клавишу <Ctrl>, щелкает по строкам и выбирает нужные. Для этого у ListBox имеется свойство MultiSelect (множественный выбор). По умолчанию оно равно False, то есть запрещает пользователю выбрать несколько строк. Создадим еще одно приложение, в котором продемонстрируем возможность множественного выбора.
Установите на форму один ListBox и один Memo, ниже – кнопку с надписью "Копировать". При нажатии на кнопку будем искать у ListBox выделенные строки и копировать их в Memo. На рисунке 12.2 в левой части установлен компонент ListBox, а в правой – Memo.
Рис. 12.2. Внешний вид приложения
Войдите в редактор строк ListBox и напишите там
Строка № 1
Строка № 2
и так далее, пока не заполните ListBox так, чтобы его не нужно было прокручивать. Установите свойство MultiSelect у ListBox в True. Не забудьте очистить Memo. Теперь для кнопки напишем следующий код:
procedure TForm1.Button1Click(Sender: TObject);
var
i : Integer;
begin
Memo1.Clear;
for i := 0 to ListBox1.Items.Count - 1 do
if ListBox1.Selected[i] then
Memo1.Lines.Add(ListBox1.Items.Strings[i]);
end;
Вначале мы очистили Memo, чтобы пользователь мог несколько раз опробовать выбор и копирование строк, и строки в Memo не скапливались.
Затем мы создаем цикл, чтобы обрабатывать ListBox построчно. Первая строка всегда имеет нулевой индекс, а свойство Count во всех объектах TStrings возвращает количество строк в объекте. Нам приходится вычесть единицу, так как индексы начинаются не с 1, а с 0. Далее в цикл мы поместили условный оператор if – если условие верно (то есть строка выделена), то производим добавление строки в Memo. За это отвечает свойство Selected (Выделено) с указанием индекса строки. Если оно равно True, то строка выделена.