Тема : Объектно-ориентированное проектирование на Borland C++

1. Общие сведения о программах на Borland C++

2. Структура головного файла проекта

3. Структура файлов модулей форм

4. Области видимости и доступ к объектам модуля

5. Указатели на объекты

1. Общие сведения о программах на Borland C++

Рассмотрим вопросы общей организации приложения C++ и доступа к объектам, их свойствам и методам.

Приложение на C++ состоит из объявлений (переменных, констант, типов, классов, функций) и описаний функций. Среди функций всегда имеется главная - WinMain для приложений Windows. Именно эта функция выполняется при запуске приложения, и выполняет только некоторые подготовительные операции, необходимые для начала работы. А далее при ОО подходе работа приложения определяется происходящими событиями и реакцией на них объектов.

Как правило, программы строятся по модульному принципу и состоят из множества модулей. Четкое соблюдение принципов модульности в сочетании с принципом сокрытия информации позволяет внутри любого модуля проводить необходимые модификации, не затрагивая при этом остальных модулей и головную функцию.

Все объекты компонентов размещаются в объектах - формах. Для каждой формы C++Builder создает отдельный модуль. Именно в модулях и осуществляется программирование задачи. В обработчиках событий объектов размещаются все алгоритмы. В основном они сводятся к обработке информации, содержащейся в свойствах одних объектов, и задании по результатам обработки свойств других объектов. При этом постоянно происходит обращаение к методам различных объектов.

Согласно принципам сокрытия информации модуль состоит из заголовочного файла, который содержит объявления классов, функций, переменных и т.п., и файла реализации, в котором содержится описание функций. Стандартное расширение заголовочных файлов - .h. Стандартное расширение файлов реализации - .срр.

После того, как приложение написано, на ее основе создается выполняемый файл (модуль). Этот процесс осуществляется в несколько этапов.

Сначала работает препроцессор, который преобразует исходный текст. Препроцессор осуществляет преобразования в соответствии со специальными директивами препроцессора, которые размещаются в исходном тексте. Препроцессор может в соответствии с этими директивами включать тексты одних файлов в тексты других, развертывать макросы - сокращенные обозначения различных выражений и выполнять множество других преобразований.

После препроцессора работает компилятор. Его задача - перевести тексты модулей в объектный код. В результате для каждого исходного файла .срр создается объектный файл, имеющий расширение .obj.

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

2. Структура головного файла проекта

В процессе проектирования приложения C++Builder автоматически создает коды головного файла проекта, коды отдельных модулей и коды их заголовочных файлов. Головной файл проекта содержит функцию WinMain. В прочие модули вводите свой код, создавая обработчики различных событий. В заголовочные файлы этих модулей помещаются все объявления. Но головной модуль, как правило, не редактируемый. Только в исключительных случаях надо что-то изменять в тексте головного модуля, сгенерированном C++Builder. Тем не менее, надо все-таки представлять вид головного файла проекта и понимать, что означают его операторы.

Просмотреть код головного файла проекта можно через пункт меню Project | View Source. Типичный головной файл проекта имеет следующий вид:

(1)

Начинается файл головного модуля директивами препроцессора, наиболее важны директивы #include. Эти директивы подключают в данный файл тексты указанных в них файлов. В частности, подобными директивами включаются в текст заголовочные файлы. Директива #include <vcl.h> подключает заголовочный файл vcl.h, содержащий объявления, используемые в библиотеке визуальных компонентов C++Builder.

После директив препроцессора в файле размещены предложения USERES и USEPORM. Это макросы, используемые для подключения к проекту файлов форм, ресурсов и др. Препроцессор развернет эти макросы в соответствующий код. C++Builder автоматически формирует соответствующее предложение с макросом USEFORM для каждой формы, вносимой в проект. Первый параметр макроса содержит имя файла модуля, соответствующего форме (например, «Unit1.cpp»), а второй параметр - имя формы.

Далее расположена главная функция программы - WinMain.

В теле этой функции в фигурных скобках размещены следующие операторы:

Application->Initialize инициализирует объекты компонентов данного приложения.

Application->CreateForm создают объекты соответствующих форм. Формы создаются в той последовательности, в которой следуют эти операторы. Первая из создаваемых форм является главной.

Application->Run начинает собственно выполнение программы. После этого оператора программа ждет соответствующих событий, которые и управляют ее ходом.

Тело функции WinMain заключено в блоки try и catch. Это структура, связанная с обработкой так называемых исключений - аварийных ситуаций, возникающих при работе программы. Если такая аварийная ситуация возникнет, то будут выполнены операторы, расположенные в блоке catch. По умолчанию в этом блоке расположен стандартный обработчик исключений с помощью функции Application->ShowException.

Последний оператор тела функции WinMain - оператор return 0;, завершающий приложение с кодом завершения 0.

Все описанные выше операторы головного файла приложения заносятся в него автоматически в процессе проектирования приложения. Например, при добавлении в проект новой формы в файл автоматически вставляются соответствующее предложение USEFORM и оператор Application->CreateForm, создающий форму. Так что обычно ничего в головном файле изменять не надо и даже нет необходимости его смотреть.

Имя головного файла проекта по умолчанию дается стандартное: Project1, Project2 и т.п. Это же имя будет и у выполняемого модуля программы. Так что желательно изменить имя по умолчанию. Для этого достаточно сохранить головной файл проекта под соответствующим именем.

Всегда нужно сохранять проект под каким-то осмысленным именем. Иначе очень скоро можно запутаться в бесконечных программах Project1.

3. Структура файлов модулей форм

Рассмотрим теперь тексты модулей форм. Каждый такой модуль состоит из двух файлов: заголовочного, содержащего описание класса формы, и файла реализации. Ниже приведены тексты этих файлов модуля формы, на которой размещен один компонент типа TLabel и один компонент типа TButton. Подробные комментарии в этом тексте поясняют, куда и что в этот код можете добавлять.

(2)

Заголовочный файл:

(3)

Файл реализации:

Рассмотрим подробнее эти файлы. Заголовочный файл начинается с автоматически включенных в него директив препроцессора. В частности, C++Builder сам помещает тут директивы include, подключающие копии файлов, в которых описаны те компоненты, переменные, константы, функции, которые используются в данном модуле. Однако для некоторых функций такое автоматическое подключение не производится. В этих случаях разработчик должен добавить соответствующие директивы include вручную.

Далее следует описание класса формы. Имя класса формы - TForm1. Класс содержит три раздела: published - открытый раздел, содержащий объявления размещенных на форме компонентов и обработчиков событий в них, private - закрытый раздел класса, и public - открытый раздел класса. В данном случае в разделе published можете видеть объявления указателей на два компонента: компонент Button1 типа TButton и компонент Label1 типа TLabel и там же объявление функции Button1Click - введенного пользователем обработчика события щелчка на кнопке Button1. Все, что имеется в разделе published, C++Builder включает в него автоматически в процессе проектирования формы. А в разделы private и public можете добавлять свои объявления типов, переменных, функций. То, что объявлено в разделе public, будет доступно для других классов и модулей. То, что объявлено в разделе private, доступно только в пределах данного модуля. Как можете видеть, единственное, что C++Builder самостоятельно включил в раздел public, это объявление (прототип) конструктора формы TForm1.

После объявления класса следует предложение PACKAGE, которое включается в файл автоматически. После этого можете разместить объявления типов, переменных, функций, к которым при соблюдении некоторых дополнительных условий будет доступ из других модулей, но которые не включаются в класс формы.

Теперь рассмотрим текст файла реализации модуля. После автоматически включенных в этот файл директив препроцессора следует тоже автоматически включенное объявление указателя на объект формы Form1, а затем - вызов конструктора формы. Тело соответствующей функции пустое, но можете включить в него какие-то операторы. После этого размещаются описания всех функций, объявленных в заголовочном файле. Здесь также можно размещать объявления любых типов, констант, переменных, не объявленных в заголовочном файле, и размещать описания любых функций, не упомянутых в заголовочном файле. Имена файлам модулей C++Builder дает по умолчанию: для первого модуля имя равно Unit1, для второго Unit2 - и т.д.

4. Области видимости и доступ к объектам, переменным и функциям

4.1 Пример модуля, содержащего объекты и процедуры

Рассмотрим, как можно вводить в модуль переменные, функции и осу- осуществлять к ним доступ. Ниже приведен текст кода модуля, в котором на форме размещены два компонента: кнопка Button1 типа TButton и метка Label1 типа TLabel. Кроме того, в модуле введен обработчик события, связанного со щелчком пользователя на кнопке, и в разных местах модуля введены переменные и функции, чтобы можно было видеть, как получить к ним доступ.

(4)

Заголовочный файл:

(5)

Файл реализации:

Помимо функции Button1Click в код модуля внесены функции: Fl-F4, и символьные переменные: Ch1-Ch4. Рассмотрим подробно эти функции. Нам важно понять, как из функций обращаться к различным объектам и переменным. Но краткое описание того, что делают эти функции, надо дать.

Каждая из функций F1-F4 берет значение свойства Caption метки TLabel, прибавляет к ней символ, переданный в нее как параметр Ch, прибавляет далее символ, хранящийся в переменной Ch1, и возвращает надпись с этими добавлениями обратно в метку.

Обработчик TForm1::Button1Click задает переменным Ch1-Ch4 значения символов "-", "А", "В" и "С", затем очищает свойство Caption метки Label1, занося в него пустую строку, а затем поочередно обращается к функциям Fl-F4, передавая в них в качестве параметров различные символы. В заключение надпись метки окрашивается в красный цвет свойством Font->Color. Значение этого свойства изменяет последний оператор процедуры TForm1::Button1Click.

4.2 Доступ к свойствам и методам объектов

Рассмотрим теперь, как получить из программы доступ к свойствам и методам объектов. Доступ к объектам-компонентам можно получить через объявленные в заголовочном файле модуля указатели на эти объекты. Например, в объявлении класса формы TForm1 в заголовочном файле имеется строка

TLabel *Label1;

Эта строка объявляет Label1 как указатель на метку - объект типа TLabel. Доступ к элементам класса обеспечивается с помощью операции стрелка. В файле реализации модуля в текстах функций F1 и F2 выражения вида Label1->Caption означают: свойство Caption объекта Label1. Иногда свойство объекта является в свою очередь объектом. Тогда в обращении к этому свойству указывается вся цепочка предшествующих объектов. Например, метки имеют свойство Font - шрифт, которое в свою очередь является объектом. У этого объекта имеется множество свойств, в частности, свойство Color - цвет шрифта. Чтобы сослаться на цвет шрифта метки Label1, надо написать Label1->Font->Color. Это означает: свойство Color объекта Font, принадлежащего объекту Label1. Аналогичная нотация используется и для доступа к методам объекта.

Например, для метки определен метод Hide, который делает метку невидимой. Если в какой-то момент решили сделать метку Label1 невидимой, можете написать оператор

Label1->Hide();

4.3 Различие переменных и функций, включенных и не включенных в описание класса

Рассмотрим, чем различаются переменные и функции, включенные и не включенные в описание класса. Переменные и функции, включенные в описание класса, обычно называются соответственно данными-элементами и функциями-элементами. Применительно к ООП в C++Builder их называют свойствами и методами. В приведенном примере переменная Сh и функции F1 и F2 включены в описание класса, а переменные Ch2, Ch3 и функции F3 и F4 объявлены вне класса. В чем будет проявляться различие в их использовании?

Если в приложении создается только один объект данного класса (в примере - только один объект формы класса TForm1), то различие в основном чисто внешнее. Для функций, объявленных в классе, в их описании к имени функции должна добавляться ссылка на класс с помощью операции глобального разрешения области действия (::). В нашем примере имена функций F1, F2 и Button1Click в описании этих функций заменяются на TForm1::Fl, TForm1::F2 и TForm1::Button1Click. Тем самым указывается, что речь идет о функциях класса TForm1. Для функций F3 и F4, объявленных вне класса, такого дополнения к имени не требуется.

Необходимость добавления в имена функций, описанных в классе, ссылок на класс объясняется просто. Можете вне класса описать другую свою функцию с тем же именем (например, F1), что и у функции класса. И тогда из функций, не описанных в классе, сможете ссылаться на обе эти функции F1, только на одну из них непосредственно - по имени F1, а на другую через объект класса - Form1::Fl. Благодаря этому, при описании своих функций вне класса можете даже не знать имен всех функций, описанных в классе. Никакой путаницы при этом не возникнет.

Таким образом, применение операции глобального разрешения области действия позволяет объявить в разных классах и вне классов переменные и функции с одинаковыми именами. В этом случае операция разрешения области действия указывает, о какой именно переменной или функции идет речь. В некоторых случаях при работе с C++Builder разрешение области действия приходится делать вручную. Это происходит в тех случаях, когда компилятор выдает сообщение, что не может выбрать одну из нескольких альтернатив, например, не знает, к какому классу относится указанный метод.

Обращение к переменным и функциям, описанным внутри и вне класса, из функций, описанных вне класса, различается. К переменным и функциям, описанным вне класса, обращение происходит просто по их именам, а к переменным и функциям, описанным в классе, через имя объекта класса. Поэтому в примере в функциях F3 и F4 обращение к переменной Сh имеет вид Form1->Ch1. По той же причине и обращение к свойству Caption объекта Label1 в этих функциях имеет вид Form1->Label1->Caption. Только через ссылку на объект Form1 внешние по отношению к классу функции могут получить доступ ко всему, объявленному в классе.

Все эти ссылки на объект не требуются в функциях, объявленных в классе. Поэтому в функциях TForm1::Fl, TForm1::F2 и TForm1::Button1Click ссылки на переменную Сh и на объект Label1 не содержат дополнительных ссылок на объект формы.

Если в приложении создается несколько объектов одного класса, например, несколько форм класса TForm1, то проявляются более принципиальные различия между переменными, описанными внутри и вне класса. Переменные вне класса (в нашем примере Ch2 и Ch3) так и остаются в одном экземпляре. А переменные, описанные в классе (в нашем примере Сh), тиражируются столько раз, сколько объектов данного класса создано. Т.е. в каждом объекте класса TForm1 будет своя переменная Сh и все они друг с другом никак не будут связаны. Таким образом, в переменную, описанную внутри класса, можно заносить какую-то информацию, индивидуальную для каждого объекта данного класса. А переменная, описанная в модуле вне описания класса, может хранить только одно значение.

Отметим еще одну особенность. Перед именами функций-элементов класса ставится опция компилятора _fastcall. Не вдаваясь в детали скажем, что эта опция влияет на процесс компиляции и обеспечивает передачу параметров функции в быстрые регистры, что ускоряет вызов функции. Для функций-элементов классов эту опцию следует указывать всегда. Для других функций ее можно указывать, а можно и не указывать. Впрочем, эту опцию целесообразно указывать и для функций, не являющихся элементами класса.

В заключение просуммируем изложенные правила.

§ В реализацию функций-элементов должна добавляться ссылка на класс с помощью операции глобального разрешения области действия (::).

§ Функции-элементы объявляются и описываются с применением опции компилятора _fastcall.

§ В функциях-элементах обращение к другим функциям-элементам и данным-элементам того же класса может осуществляться без указания на объект.

§ В функциях, не являющихся элементами класса данного объекта, доступ к методам и свойствам осуществляется через указатель на объект с помощью операции стрелка (->) или с помощью разыменования указателя на объект и операции точка (.).

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

Рассмотрим видимость функций в приложениях, имеющих несколько модулей. Если в модуле Unit1 в его заголовочном файле вне описания класса объявили некоторую функцию F, то в другом модуле Unit2 можете использовать ее при выполнении одного из двух условий:

§ включаете директивой #include в модуль Unit2 заголовочный файл Unit1.h

§ повторяете в модуле Unit2 (в заголовочном файле или файле реализации) объявление функции F

В обоих случаях сможете вызвать функцию F из любого места модуля Unit2.

Если же функция F объявлена в модуле Unit1 не заголовочном файле, а в файле реализации, то единственный способ использовать ее в модуле Unit2 - повторить в нем объявление функции.

Если хотите предотвратить возможность обращения к функции из другого модуля, ее надо объявить со спецификацией static. Например:

static void F(void);

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

Переменные, объявленные в заголовочном файле модуля или в файле его реализации вне описания класса и функций, являются глобальными. Они доступны везде внутри данного модуля. Для доступа к ним из внешних модулей в этих модулях должно быть повторено их объявление с добавлением спецификации extern. В рассмотренном примере это относится к переменным Сh2 и СhЗ.

Функции, объявленные в заголовочном файле модуля вне описания класса, являются глобальными. Они доступны везде внутри данного модуля. Для доступа к ним из внешних модулей в этих модулях или надо повторить их объявление, или включить директивой #include заголовочный файл того модуля, в котором функции описаны. В рассмотренном примере это относится к функции F3.

Функции, объявленные в файле реализации модуля, являются глобальными. Они доступны везде внутри данного модуля. Для доступа к ним из внешних модулей в этих модулях надо повторить их объявление. В рассмотренном примере это относится к функции F4.

Элементы (переменные и функции), объявленные в классе в разделе private, видимы и доступны только внутри данного модуля. При этом из функций, объявленных внутри класса, к ним можно обращаться непосредственно по имени, а из других функций - только со ссылкой на объект данного класса. В рассмотренном примере это относится к процедуре F1. Если в модуле описано несколько классов, то объекты этих классов взаимно видят элементы, описанные в их разделах private.

Элементы, объявленные в классе в разделе public, видимы и доступны для объектов любых классов и для других модулей, в которых директивой include включен заголовочный файл данного модуля. При этом из объектов того же класса, к ним можно обращаться непосредственно по имени, а из других объектов и процедур - только со ссылкой на объект данного класса. В рассмотренном примере это относится к переменной Сh и процедуре F2.

В классах могут быть еще разделы protected -защищенные. Элементы, объявленные в классе в разделе protected, видимы и доступны для любых объектов внутри данного модуля, а также для объектов классов-наследников данного класса в других модулях. Объекты из других модулей, классы которых не являются наследниками данного класса, защищенных элементов не видят.

Элементы, объявленные внутри функции или блока (в рассмотренном примере это переменная Ch4 объявленная внутри функции TForm1::Button1Click), являются локальными, т.е. они видимы и доступны только внутри данной функции или данного блока. При этом время жизни переменных, объявленных внутри функции или блока, определяется временем активности данного блока. Так переменная Ch4 в нашем примере создается в момент вызова функции TForm1::Button1Click и уничтожается при завершении работы этой функции. Сделать локальную переменную существующей постоянно можно с помощью спецификации static.

Переменные и функции, объявленные в головном файле проекта, являются глобальными для этого файла. Если требуется доступ к ним из других модулей, то для функций в них должны быть повторены их объявления, а для переменных - повторено объявление (без инициализации) со спецификацией extern.

Если во внутреннем блоке объявлена переменная с тем же именем, что во внешнем блоке, или с тем же именем, что и глобальная переменная, то соответствующая внешняя или глобальная переменная в блоке не видна. В этом случае подучить доступ к одноименной глобальной переменной можно только с помощью унарной операции разрешения области действия "::".

5. Указатели на объекты

Основой объектно-ориентированного программирования являются объекты и классы. Рассмотрим более сложные и тонкие вопросы работы с объектами. Указатель на объект - это переменная, в которой хранится ссылка на объект некоторого класса, т.е. на место в памяти, где размещен объект. Объявление (создание) указателя на объект некоторого класса (типа) производится оператором:

<тип> *<указатель>;

Например, следующее объявление создает указатель на объект класса TLabel:

TLabel *Lab;

Создается не сам объект, а только указатель на любой объект данного типа. В момент его создания указатель инициируется нулем. Нуль не может ассоциироваться ни с каким объектом в памяти. Поэтому определить, занесена в указатель ссылка на конкретный объект, или нет, можно, например, оператором:

if (Lab ==0) ... ;

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

В C++ предопределена константа NULL, которая эквивалентна нулевому указателю. Поэтому приведенный выше оператор эквивалентен следующему:

if (Lab == NULL) ...;

В дальнейшем указателю можно присвоить ссылку на любой объект соответствующего класса простым присваиванием. Например:

Lab = Label1;

Тогда указатель Lab становится как бы псевдонимом объекта Label1. Оба указателя: и Lab, и Label1 ссылаются на один и тот же объект. Например,

Label1->Captiоn и Lab->Caption ссылаются на надпись одной и той же метки.

В качестве типа объекта, на который ссылается указатель, можно задать void. Например:

void *Lab;

Такой указатель на void можно рассматривать как указатель на объект любого типа. В дальнейшем этому указателю можно задать простым присваиванием ссылку на объект любого типа. Но разыменование такого указателя требует применения явного приведения типов, поскольку компилятор не знает, на объект какого типа в действительности ссылается указатель. Поэтому для него нельзя, например, после присваивания ему ссылки на метку Label1 написать просто Lab->Caption. Для ссылки на надпись Caption через этот указатель надо писать ((TLabel *)Lab)->Caption, то есть явным образом приводить тип указателя Lab к типу "указатель на объект класса TLabel".

Можно создавать ссылку на объект с помощью указателя не на истинный класс объекта, а на один из классов, которым наследует класс данного объекта. Дело в том, что любой объект может рассматриваться не только как объект своего класса, но и как объект любого класса-предка. Это в общем достаточно естественно для обычного понимания объектов в реальном мире.

Например, универсальным указателем на любой компонент может быть указатель на класс TControl - базовый класс всех компонентов:

TConrrol *Contr;

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

Contr = Label1;

При таком присваивании компилятор сам производит необходимое приведение типов. Но с этим указателем Contr уже нельзя работать непосредственно как с указателем на метку. Для него известны только свойства, объявленные в классе TControl. Эта такие общие свойства всех компонентов, как, например, Name - имя. Непосредственная ссылка на специфические свойства классов-наследников невозможна. Например, попытка написать код Contr->Caption вызовет сообщение компилятора об ошибке, смысл которого заключается в том, что свойство Caption в классе TControl недоступно. Поэтому для доступа к методам и свойствам, отсутствующим в классе TControl, надо осуществлять явное приведение типа указателя, например:

((TLabel *)Contr)->Caption

Этот код говорит компилятору: «Рассматривай Contr как ссылку на класс TLabel». И тогда никаких сообщений об ошибках не возникает.

Создание нового объекта также связано с созданием указателя на него. Для создания объекта применяется операция new. В ней после ключевого слова new указывается класс компонента. Если объект является компонентом, то после класса компонента в скобках указывается компонент - хозяин (Owner). Кроме того, после создания компонента обязательно надо указать его родителя (Parent) - компонент, на котором размещается новый компонент. Пока не задан родитель, компонент нельзя увидеть.

Рассмотрим следующий код:

TLabel *Lab1 = new TLabel (Form1);

Lab1->Parent = Form1;

Lab1->Caption = "Это новая метка";

Первый из этих операторов создает указатель Lab1 на объект-метку типа TLabel и создает с помощью new сам объект-метку с хозяином Form1. Последующие операторы используют указатель Lab1 для задания свойств метки: размещают ее на форме Form1 и задают на ней надпись «Это новая метка»:

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