Тема 3. Объектно-ориентированное проектирование на 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. Типичный головной файл проекта имеет следующий вид:

Начинается файл головного модуля директивами препроцессора, наиболее важны директивы #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. Подробные комментарии в этом тексте поясняют, куда и что в этот код можете добавлять.

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

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

Рассмотрим подробнее эти файлы. Заголовочный файл начинается с автоматически включенных в него директив препроцессора. В частности, 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. Кроме того, в модуле введен обработчик события, связанного со щелчком пользователя на кнопке, и в разных местах модуля введены переменные и функции, чтобы можно было видеть, как получить к ним доступ.

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

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

Помимо функции 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 Области видимости переменных и функций

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

При решении вопросов видимости важнейшее значение имеет понятие блока. Блок - это фрагмент кода, ограниченный фигурными скобками "{}". Переменные, объявленные вне какого-то блока, являются глобальными и имеют областью видимости файл. Если какая-то переменная объявлена внутри блока, то ее область видимости - блок. Т.е. это локальная переменная, которую можно использовать только от момента ее объявления до первой встретившейся в коде закрывающейся фигурной скобки "}". Если имеются вложенные блоки, то переменная видна и в этих вложенных блоках. Если в каком-то блоке объявлена переменная с тем же именем, какое имеет глобальная переменная или переменная, объявленная во внешнем блоке, то это внутреннее объявление делает невидимой одноименную внешнюю переменную.

Например:

Например:

int i = 1, k = 4; // объявление глобальных переменных I

{

int i = 5, j = 2; // объявление переменных внешнего блока

....

{

// видны переменные j, к

// и переменная i этого блока

int i = 7; // объявление переменной i внутреннего блока

...

// видны переменные j, k

// и переменная i внутренняя

}

... // видны переменные j, к

// и переменная i внешнего блока

}

Локальная переменная не только видима в пределах блока, в котором она объявлена. Ее время жизни тоже определяется временем выполнения блока. Переменная создается в момент входа в блок и разрушается в тот момент, когда управление выходит за пределы блока. Таким образом, подобная переменная не может сохранять какие-то значения в промежутках между выполнением операторов блока. В приведенном примере переменная i во внутреннем блоке будет создаваться каждый раз, когда управление передается в этот блок, ей каждый раз будет присваиваться значение 7 и она каждый раз будет разрушаться при выходе из блока.

Сказанное выше о времени жизни относится к так называемым автоматическим (auto) переменным и не относится к статическим переменным, объявленным как static. Например:

static int i = 7;

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

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

i = : : i + 1 ;

Этот оператор присвоит внутренней переменной i значение на единицу большее значения глобальной переменной i.

Подчеркнем, что таким образом можно получить доступ только к одноименной глобальной переменной, а не к локальной переменной, описанной во внешнем блоке. (52 слайд)

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

int a1 = 10;

то в модуле Unit2 можете использовать эту переменную, если запишете объявление

extern int a1;

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

Отметим еще одну особенность использования переменных, описанных в другом модуле. Если в заголовочном модуле Unit1 объявлена описанная выше переменная a1, а в модуле Unit2 включили директивой #include заголовочный файл Unit1.h, но не записали объявление этой переменной со спецификацией extern (вообще не дали объявление a1), то в модуле Unit2 будет создана копия переменной a1, инициализированная согласно объявлению в Unit1. Но это будет копия, совершенно изолированная от переменной a1 в модуле Unit1. В модулях Unit1 и Unit2 будут существовать две различные переменные с одним именем a1. И изменение одной из них никак не скажется на значении другой.

Все сказанное относится только к глобальным переменным. Локальные переменные, объявляемые внутри функций, невозможно видеть в другом модуле.

Теперь рассмотрим видимость функций в приложениях, имеющих несколько модулей. Если в модуле 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.

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

4.5. Передача параметров в функции

Параметры в функции могут передаваться в основном двумя способами: по значению и по ссылке. То, что могли видеть в рассмотренном ранее примере - это передача параметра по значению. В этом случае в заголовке функции указывается имя параметра и его тип. Например:

void Fl(char Ch);

В этом случае Ch - это локальное имя формального параметра, используемое только внутри данной функции. При вызове этой функции, который может иметь вид: Fl(Ch2);

в памяти создается временная переменная с именем Ch, и в нее копируется значение аргумента Ch2. На этом связь между Ch и Ch2 разрывается. Можете изменять внутри функции значение Ch, но это никак не отразятся на значении внешней переменной Ch2, указанной в вызове функции в качестве аргумента.

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

Во-первых, функция не может изменить значение аргумента, а иногда это очень желательно.

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

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

Для реализации второго способа передачи информации - по ссылке, перед именем параметра в заголовке функции должен быть записан символ амперсанда '&'. Например: void Fl(char &Ch);

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

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".

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

Так любой автомобиль может рассматриваться не только как объект автомобилей данной марки, например, «Жигули», но и как один из объектов более общих классов - автомобили, средства передвижения и т.д. Так же и объект в C++ может рассматриваться как объект любого из классов предков.

Например, универсальным указателем на любой компонент может быть указатель на класс 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.