Функции - eDrive

Министерство образования и науки РФ
_________________________________
Санкт-Петербургский государственный
электротехнический университет «ЛЭТИ»
В. М. Водовозов А. К. Пожидаев
Разработка
программ
под Windows
Учебное пособие
Санкт-Петербург
Издательство СПбГЭТУ «ЛЭТИ»
2005

ББК 32.973.26-018
В62
УДК 681.3.016 (018)
Водовозов В. М., Пожидаев А. К. Разработка программ под Windows:
Учеб. пособие. СПб.: Изд-во СПбГЭТУ «ЛЭТИ», 2005. 104 с.
Дано описание языка С++. Представлены основные этапы процедурного,
структурного, модульного и объектно-ориентированного программирования
под Windows. Показаны особенности работы с библиотеками, процедурами,
функциями, файлами, базами данных и справочными системами.
Предназначено для студентов направления 654500 – Электротехника,
электромеханика и электротехнологии, обучающихся по специальностям
180400 – Электропривод и автоматизация промышленных установок и технологических
комплексов, 180500 – Электротехнологические установки и
системы.
Рецензенты: кафедра информационных технологий СПбИДПО;
д-р техн. наук, проф. И. М. Семенов (СПбГПУ).
ISBN 5-7629-0567-5 © В. М. Водовозов, А. К. Пожидаев, 2005

Оглавление
Введение в процедурное программирование.................................................... 5
Редактор кода.........................................................................................................................5
Функции..................................................................................................................................5
Выражения .............................................................................................................................8
Классы форм ........................................................................................................................11
Обработка событий..............................................................................................................13
Программирование графики...............................................................................................16
Исключения..........................................................................................................................17
Простые типы данных и операторы...................................................................................19
Тип AnsiString ......................................................................................................................22
Составные операторы........................................................................................ 27
Операторы перехода............................................................................................................27
Условный оператор .............................................................................................................27
Оператор выбора..................................................................................................................29
Оператор цикла....................................................................................................................30
Операторы повторения........................................................................................................31
Программирование диалогов..............................................................................................32
Введение в структурное программирование................................................... 34
Массивы................................................................................................................................34
Перестановки и сортировки................................................................................................36
Списки TStringList...............................................................................................................40
Структуры и объединения ..................................................................................................43
Динамические структуры данных......................................................................................45
Введение в модульное программирование ..................................................... 53
Работа с текстовыми и графическими файлами ...............................................................53
Работа с двоичными файлами ............................................................................................59
Модули DLL и пакеты.........................................................................................................60
Ресурсы.................................................................................................................................63
Приложения баз данных.................................................................................... 63
Технологии создания приложений баз данных ................................................................63
Архитектуры приложений баз данных..............................................................................65
Подключение к базам данных ............................................................................................66
Доступ к записям .................................................................................................................68
Объектно-ориентированное программирование ............................................ 72
Инкапсуляция.......................................................................................................................72
Конструкторы и деструкторы.............................................................................................75
Дружественные функции и классы....................................................................................80
Полиморфизм.......................................................................................................................82
Шаблоны...............................................................................................................................85
Стандартная библиотека шаблонов STL...........................................................................89
Наследование .......................................................................................................................94
Виртуальные функции и абстрактные классы..................................................................98
Список литературы..........................................................................................103

5
Введение в процедурное программирование
Редактор кода
«Работа высшего, что есть в человеке – разума
– сводится к непрерывному ограничению
бесконечности, к разделению бесконечного на
удобные, легко перевариваемые части»
Е.Замятин
Файлы программ обрабатываются на вкладках окна редактора кода, запускаемого
через меню View .Units (), View .Toggle Form/Unit
(). Вкладки с текстами открываются в редакторе кода через меню File
.Open. Переход между ними удобно выполнять с помощью навигационных
стрелок в правом верхнем углу окна. В левом поле выделения окна щелчком
можно расставлять и снимать точки прерывания выполнения программы. Переключение
между кодами и файлами заголовков выполняется через контекстные
меню Open Source/Header File () и Open File at Cursor (). Щелчки по именам в текстах программ при нажатой клавише
превращают их в гиперссылки (hotspot), с помощью которых обычно перемещаются
между связанными файлами. Другие возможности системы редактирования
Code Insight приведены в табл. 1:
Таблица 1.
Подсказки в системе редактирования Code Insight
Технология Клавиши Назначение
Code Completion Список членов класса после стрелки -> и точки
Code Parameters Список параметров функции после скобки (
Code Templates Список шаблонов программирования
Tooltip Expression
Evaluation
Подсказка значения переменной под курсором
в окне отладчика
Tooltip Symbol Insight
Подсказка объявления объекта в редакторе
кода
Функции
Исходный текст программы на языке C++ составляют выражения,
сгруппированные в функции.
Функции – это единственный вид процедур, используемый в C++. Будучи
разновидностью процедуры, функция (function) представляет относительно
автономную именованную часть программы, описывающую поведе-

6
ние программных объектов через действия над данными. Программирование
с использованием функций сокращает размеры исходного текста и упрощает
его организацию, хотя «экономия пространства не экономит времени»
[Кнут].
В отличие от простой процедуры, функция обычно имеет возвращаемое
значение (return value), то есть результат своей деятельности в вызывающем
ее выражении.
Каждая функция может многократно вызываться из других функций. В
момент вызова функция получает исходные данные и начинает выполнять
предписанные действия над ними.
Различают встроенные библиотечные и авторские функции. Первые
хранятся в библиотеках C++. Для доступа к библиотечным функциям в начале
текста программы указываются имена соответствующих файлов заголовков:
#include < имяФайлаЗаголовка >
или
#include «имяФайлаЗаголовка»
Файлы заголовков – «это хранилища информации, содержащие описания
констант и объявления функций» [Сван]. Каждый такой файл сообщает компилятору
имена и характеристики функций из других файлов и библиотек,
которые используются в программе. Файлы заголовков главных библиотек
фирмы Borland приведены в табл. 2.
Таблица 2.
Файлы заголовков библиотек фирмы Borland
Файл заголовка
ALLOC.H
BIOS.H
CONIO.H
CTYPE.H
DIR.H
FSTREAM.H
IOMANIP.H
IOSTREAM.H
MATH.H
PROCESS.H
STDIO.H
STRING.H, STDLIB.H
TIME.H
VCL.H
WINDOW.H
Назначение
Функции распределения памяти
Функции интерфейса с BIOS
Функции консольного ввода и вывода
Функции классификации символов
Функции доступа к файлам
Функции ввода и вывода файловых потоков
Функции-манипуляторы потоков
Функции потокового ввода и вывода
Математические функции
Функции управления процессами
Функции стандартного ввода и вывода
Функции преобразования строк
Функции времени и даты
Функции библиотек VCL
Функции для работы в среде Windows

7
Выражение, начинающееся символом #, называют директивой препроцессора
(preprocessor directive). Если имя файла заголовка в директиве
препроцессора заключено в угловые скобки, компилятор отыскивает его в
специальной папке \INCLUDE. Если же это имя заключено в кавычки, поиск
будет начат из текущей папки.
В текстах программ C++Builder много директив препроцессора, служащих
инструкциями для компилятора. Все они располагаются в начале исходного
текста (табл. 3).
Таблица 3.
Директивы препроцессора
Директива препроцессора
#include
#include «файлЗаголовка»
#define имяМакроса (список
параметров) текстМакроса
#pragma argsused
#pragma hdrstop
#pragma package (smart_init)
#pragma resource "*.dfm"
#ifdef (#if defined)… #endif
#ifndef … #define… #endif
Назначение
Заменить строку содержимым файла заголовка
Создать макрос
Запрет вывода сообщений о неиспользуемых параметрах
Ограничение списка ранее компилированных заголовков
Инициализировать пакеты в порядке их объявления
В качестве файла ресурсов использовать файлы .DFM
Если имя ранее определено, выполнить все до #endif
Если имя еще не определено, выполнить все до #endif
С применением авторских функций связаны три понятия: объявление
функции, определение функции и вызов функции. Каждая функция только
один раз определяется (declare) (описывается) в тексте. При этом ей присваивается
уникальное имя и сообщается набор параметров (parameter), то
есть данных, которые должны поступить к ней прежде, чем подпрограмма
приступит к их обработке. В ряде случаев определению функции предшествует
ее объявление (announcement). Объявления и определения функций могут
выноситься в авторские библиотеки. Каждый программист помещает
нужные ему функции в файлы заголовков и при необходимости обращается к
этим файлам из файлов кодов, получая доступ к созданным ранее функциям.
Такое обращение называется вызовом (call). При вызове функции передаются
аргументы (argument), то есть значения параметров. В процессе компиляции
автоматически создается список всех функций, необходимых обрабатываемому
файлу, а в ходе последующей компоновки устанавливаются необходимые
связи.
Имена функциям, равно как и переменным, константам, определяемым
в программах, даются программистами. Имена чувствительны к регистру,
начинаются с буквы или символа подчеркивания, не содержат пробелов и
иных символов, кроме подчеркивания, цифр и латинских букв, и отличаются
от лексем, служащих именами встроенных функций, операторов, констант и
других элементов языка. Имена функций расширяют набор лексем языка

8
программирования, используемый в данной программе; они включаются в
выражения наряду с лексемами языка.
Обязательной частью программы является единственная главная функция
(main function), обычно WinMain, расположенная в файле кода проекта.
Раздел объявлений и другие функции необязательны. Когда компьютер приступает
к выполнению программы, он начинает ее с первой строки главной
функции, независимо от взаимного расположения функций в программе.
Выражения
Любое объявление является выражением, содержащим сведения об области
определения и области значений данных. Объявления функций называют
прототипами (prototype), т.к. они представляют собой своеобразный
шаблон, образец использования функции:
[Модификатор] [типФункции] имяФункции
( типПараметра [ имяПараметра [ = Значение ]]...);
Здесь и далее используется метаязык описания языка программирования, в
котором в прямоугольные скобки принято заключать необязательные части
выражений, а многоточием отмечается возможность повторения элементов
синтаксической формулы.
Все выражения в C++, кроме директив препроцессора и комментариев,
завершаются точкой с запятой. Длинные выражения можно разбивать символом
\ – признаком продолжения на следующей строке. В круглых скобках
помещаются сведения о параметрах функции. При этом части из них, расположенной
в конце списка параметров, можно сразу присваивать значения –
это называется инициализацией по умолчанию (default initialization). Тип
функции (function type) характеризует возвращаемое значение, а тип параметра
(parameter type) – множество входных данных, обрабатываемых этой
функцией. Кроме объявления встроенных функций из стандартных библиотек,
находящихся в файлах заголовков, авторские функции, создаваемые программистом,
также могут включаться в файлы заголовков. Но часто их объявляют
и затем определяют прямо в тексте программы. В тех случаях, когда
функция определяется до ее вызова, объявлять функции необязательно. C++
не допускает объявления и определения функций внутри других функций:
Формат определения авторской функции:
Заголовок {
[ объявлениеДанных...]
Выражение…
[ return возвращаемоеЗначение;] }

9
Заголовок (caption) определяемой функции является своего рода копией
ее объявления, но обязательно содержит имена параметров и не завершается
точкой с запятой. Внутри фигурных скобок в определении функции заключается
ее тело (body). Текст программы содержит выражения, состоящие из
переменных, констант, операторов, вызовов функций и заканчивающиеся
точкой с запятой. Фигурными скобками текст может разбиваться на отдельные
блоки.
Обычно каждый блок обрабатывает свои переменные и константы, «не
заботясь» о других данных программы. В этом «правиле ограниченной видимости»
заключается автономность, независимость блоков и функций. Данные,
обрабатываемые внутри блока, называют локальными (local variable),
личными или автоматическими. Память под них выделяется на время работы,
а по завершении работы функции их значения так же автоматически стираются,
освобождая место в памяти переменным других частей программы.
В C++ разрешено совмещать определение коротких функций с их объявлением
с помощью лексемы inline. Благодаря этому механизму, код функции
автоматически встраивается в то место, откуда происходит ее вызов, и
вызов происходит значительно быстрее.
Если требуется сохранять значения локальных переменных между вызовами
функций, их объявления снабжают модификатором static. В момент
объявления статическую переменную можно явно инициализировать. Если
этого не сделать, то при первом вызове ей автоматически присваивается нулевое
значение. При повторных вызовах выражение инициализации игнорируется.
Модификатор register направляет локальную переменную на сохранение
в регистры процессора. А модификатор volatile явно указывает, что локальная
переменная «изменчива», то есть может в любой момент поменять
свое значение.
Кроме локальных данных, в программах существуют глобальные переменные
(global variable) и глобальные константы (global constant), доступные
из разных частей программы. Они размещаются в разделе объявлений файла
и помогают функциям обмениваться информацией, минуя параметры, но порой
снижают надежность программной системы и увеличивают размер памяти,
занимаемой программой в ходе выполнения.
Внешний модификатор extern информирует компилятор о существовании
внешних данных, находящихся в другом файле кода программы. За
внешними и глобальными данными память закрепляется постоянно на все
время работы программы, а при первом вызове они инициализируются нулем.
Каждый вызов функции представляет собой запрос на совершение определенных
действий. Он осуществляется в соответствии с объявленным
прототипом и семантической организацией программы:

10
имяФункции ([ списокАргументов ]);
В ответ на вызов копия кода функции передается в вызывающую функцию
для обработки, после чего она удаляется из памяти. Исключением являются
функции, объявленные с модификатором inline, коды которых обрабатываются
непосредственно. При вызове функций параметры, инициализированные
по умолчанию, могут быть опущены в списке передаваемых аргументов.
В любой части программы можно разместить комментарии – тексты,
обрамленные символами /* */, или фрагменты строк, начинающиеся символами
//, не влияющие на ход выполнения программы.
Ниже приведен пример текста файла проекта на языке C++Builder:
#include
#pragma hdrstop
// Заголовочный файл описания классов VCL
// Ограничитель списка прекомпилированных
// заголовочных файлов
// Файлы и имена форм проекта
USEFORM ("bMainForm.cpp", MainForm);
USEFORM ("bDataBase.cpp", DataBase);
USEFORM ("bDiagram.cpp", Diagram);
USEFORM ("bAbout.cpp", About);
WINAPI WinMain (HINSTANCE, HINSTANCE, LPSTR, int)
{ try {
Application->Initialize ();
// Главная
// функция
// Инициализация OLE
// Создание формы
Application->CreateForm (__classid (TMainForm), &MainForm);
Application->Run ();
// Запуск приложения
}
catch (Exception &exception)
{ Application->ShowException (&exception); }
catch (...) {
try { throw Exception (""); }
catch (Exception &exception)
{ Application->ShowException(&exception); }
}
return 0;
}
// Обработка исключений
Здесь директива препроцессора #include подключает к тексту
файл заголовка, ссылающийся на описание классов VCL, а директива
#pragma hdrstop ограничивает список файлов заголовка, доступных для
предварительной компиляции. Директивы USEFORM сообщают о модулях,
используемых в проекте. Выражение Application->Initialize() инициализирует

11
OLE-серверы автоматизации. Каждое выражение Application->CreateForm()
создает отдельную форму, а выражение Application->Run() запускает приложение,
переводя его в состояние ожидания наступления событий. Конструкция
try…catch используется для корректного завершения приложения в случае
возникновения ошибки.
Классы форм
Меню View .Class Explorer открывает окно обозревателя классов. В нем
представлена иерархия классов с указанием типов, член-данных, членфункций
и глобальных переменных, входящих во все файловые модули.
Каждой форме соответствует файл заголовка с определением ее класса
в формате
например:
class имяКласса: public TForm
{ [[ Метка ] обявлениеЧленов...]...};
class TForm1 : public TForm {
__published:
TEdit *Edit1;
TEdit *Edit2;
TButton *Button1;
TLabel *Label1;
void __fastcall Button1Click (TObject *Sender);
private:
public:
__fastcall TForm1 (TComponent* Owner);
};
Закрытые член-данные и член-функции класса должны размещаться под меткой
private: или в начале описания класса без метки, защищенные члены
снабжаются меткой protected:, а открытые члены перечисляются под меткой
public:. Данные, свойства которых представлены в окне Object Inspector, находятся
под меткой __published:. Объекты, порождаемые от закрытых членов
класса, доступны лишь объектам своего класса. Объекты, порождаемые защищенными
членами, открыты объектам своего класса и производных от него
классов. Объекты открытых членов могут использоваться во всех операциях
и взаимодействовать с переменными программы.
Данные в определении класса объявляются со своими типами и именами,
а у член-функций указываются, кроме того, типы данных параметров. В
рассматриваемом примере присутствуют указатели на данные Edit1, Edit2,
Button1, Label1 классов TEdit, TButton, TLabel. Модификатор быстрого вызо-

12
ва __fastcall организует передачу аргументов методам VCL не через стек, а
через процессорные регистры, если это не вещественные числа, не структуры
данных и не функции. Лексема void является указателем на то, что функция
Button1Click не возвращает никаких значений по окончании работы.
Бестиповая функция TForm1, имя которой совпадает с именем класса,
называется конструктором (constructor). Конструкторы (а их может быть несколько)
предназначены для автоматической инициализации данных в ходе
порождения объектов.
Класс формы является производным классом, и в его заголовке через
двоеточие указано имя базового класса TForm с открытым типом доступа
public. Производный класс наследует все члены базового класса, за исключением
конструкторов и деструктора. В производном классе унаследованные
члены могут иногда изменяться, а также добавляются новые члены.
Одновременно с объявлением класса в файле заголовка задается одноименная
с формой глобальная переменная, позволяющая обращаться к ней из
любого файла проекта, например:
extern PACKAGE TForm1 *Form1;
Лексема PACKAGE является именем макроса, в котором содержится код экспорта
из библиотеки пакетов BPL – Borland Package Library.
Члены классов, объявленные в файле заголовка, определяются в файле
кода формы в форматах:
[Модификатор] [Тип] имяКласса :: имяЧлен-данного [= Значение];
[Модификатор][Тип] имяКласса :: имяЧлен-функции (списокПараметров)
телоЧлен-функции
В частности, каждой форме в ее файле кода автоматически прописывается
пустой конструктор, получающий при вызове единственный параметр Owner,
указывающий объекта-владельца, создающего форму. Например:
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner): TForm(Owner) {}
При удалении из формы элементов управления их объявления автоматически
удаляются из описания класса формы, хотя объявления членфункций
сохраняются, и при необходимости программисту следует удалить
их вручную. При переименовании объектов переименовываются и все ссылки
на них в файле заголовка и в определениях.

Обработка событий
13
Доступ к функциям форм, обрабатывающим события элементов управления,
может осуществляться через вкладку Events инспектора объектов. Эти
же обработчики можно и непосредственно открывать в окне редактора кода.
По умолчанию C++Builder присваивает обработчику имя, образованное соединением
имени компонента с именем события. Например,
void __fastcall TForm1::Button1Click (TObject *Sender) {}
– это обработчик щелчка – события OnClick кнопки Button1 в форме Form1,
являющийся функцией класса TForm1.
Текст обработчика программист наполняет выражениями, описывающими
поведение формы или элементов управления, изменяющими их характеристики
или посылающими сообщения. Элементы управления, обрабатываемые
этими выражениями, характеризуются свойствами и методами. В обработчике
свойства и методы связываются стрелками (->) с указателями на
элементы управления. Ниже приведены примеры обработчиков трех пунктов
меню и кнопки:
void __fastcall TForm1::menuNewClick (TObject *Sender) {
Edit1->Text = "2003";
Label1->Caption = "Санкт-Петербург";
}
void __fastcall TForm1::menuDatabaseClick (TObject *Sender) {
Form2->Show();
}
void __fastcall TForm1::menuAboutClick (TObject *Sender) {
FormAbout->ShowModal();
}
void __fastcall TForm1::Button1Click (TObject *Sender) {
Application->Terminate();
}
Здесь при выборе пункта меню menuNew свойству Текст поля Edit1 присваивается
значение «2003», а надписи Label1 передается «Санкт-Петербург».
При выборе пункта menuDatabase открывается форма Form2, а при выборе
пункта menuAbout открывается модально форма FormAbout. При нажатии
кнопки Button1 приложение завершает свою работу.

14
В следующем примере показаны обработчики меню открытия и сохранения
файла, обслуживающие элемент RichEdit1 и строку состояния Status-
Bar1:
void __fastcall TForm1::menuOpenClick (TObject *Sender) {
OpenDialog1->Execute()
RichEdit1->Lines->LoadFromFile (OpenDialog1->FileName);
StatusBar1->Panels->Items[0]->Text = OpenDialog1->FileName;
}
void __fastcall TForm1::menuSaveAsClick (TObject *Sender) {
SaveDialog1->Execute()
RichEdit1->Lines->SaveToFile (SaveDialog1->FileName);
AnsiString fn = SaveDialog1->FileName;
StatusBar1->Panels->Items[0]->Text = SaveDialog1->FileName;
}
Передача данных между не модальными формами осуществляется либо
через открытые члены их классов, либо через свойства форм. Например, чтобы
внести в надпись Label1 активной формы-владельца, на которую ссылается
указатель this, значение заголовка формы ModelessForm, можно воспользоваться
следующим выражением:
this->Label1->Caption = ModelessForm->Caption;
Важным достоинством обработчиков является их способность создавать
новые элементы управления в ходе выполнения программы (runtime
mode), а не на стадии проектирования (design time mode). Новые объекты порождаются
оператором new, который выделяет необходимое количество свободной
памяти и вызывает конструктор объекта. Объекты, созданные оператором
new, следует удалять из памяти оператором delete, освобождающим
память.
В частности, формам не обязательно выделять память при запуске приложения.
Это можно делать динамически, по мере необходимости. На стадии
проектирования имена динамических форм надо удалить из списка Autocreate
forms вкладки Forms (меню Project .Options) или просто вычеркнуть
соответствующие строки из WinMain, а в нужном месте программы создавать
их и открывать не модально методом Show или модально методом ShowModal.
В следующем примере в форме MainForm по щелчку кнопки Button1
создаются три формы: не модальная форма ModelessForm, модальная форма
ModalForm, объявленная глобальной переменной в файле заголовка, и модальная
форма LocalForm, не связанная с глобальной переменной:

15
#include
#include "Unit1.h"
#include "Unit2.h"
#include "Unit3.h"
TForm1 *Form1;
__fastcall TForm1::TForm1 (TComponent* Owner): TForm (Owner)
{
ModelessForm->Show();
ModalForm = new TModalForm (this);
ModalForm->ShowModal();
delete ModalForm;
// при наличии
// глобального
// определения
TLocalForm *LocalForm = new TLocalForm (0); // вместо
LocalForm->ShowModal();
// глобального
delete LocalForm;
// определения
ModelessForm->Close();
}
В программе использован аргумент this, указывающий на владельца
TMainForm, и аргумент 0, не связывающий новую форму с конкретным владельцем.
Еще один фрагмент программы посвящен созданию кнопки:
TButton *b = new TButton (this);
b->Parent = this;
b->Name = “NewButton”;
b->Width = 100;
b->Height = 30;
b->Left = 10;
b->Top =10;
b->Caption = “Новая кнопка”;
b->Visible = true;
b->OnClick = MyClick;
void __fastcall TForm1::MyClick (TObject *Sender) {
ShowMessage (“Привет”);
}

Программирование графики
16
Табл. 4 посвящена характерным методам формирования графических
образов по канве.
Таблица 4.
Методы обработки канвы
Метод
Назначение
Arc
Строит дугу внутри заданной области
Chord Строит сектор эллипса по хорде
CopyRect Копирует фрагмент изображения с другой канвы
Draw Создает графический объект с заданными свойствами и координатами
Ellipse Строит эллипс в заданных границах
FillRect Строит прямоугольную область с заданным свойством Brush
FloodFill Заполняет пространство канвы заданным свойством Brush
FrameRect Строит прямоугольник с границами, заданными свойством Brush
LineTo Ведет линию из позиции PenPos в точку с координатами X-1 и Y-1
MoveTo Переносит позицию рисования в точку с координатами X-1 и Y-1
Pie
Строит сектор эллипса внутри заданного прямоугольника
Polygon Строит замкнутый контур из отрезков, проходящих через заданные точки
PolyLine Строит ломаную из отрезков, проходящих через заданные точки
Rectangle Строит прямоугольник через левый верхний и правый нижний углы
RoundRect Строит прямоугольник с закругленными углами
StretchDraw Вписывает изображение в прямоугольник, автоматически масштабируя
TextHeight Возвращает высоту текстовой строки на рисунке
TextOut Формирует строку текста из точки с X и Y, перенося в конец ее курсор
TextWidth Возвращает ширину текстовой строки на рисунке
TextRect Размещает фрагмент строки в заданной области, обрезая излишки
В следующем примере показан обработчик события формы FormPaint,
рисующий Андреевский флаг:
void __fastcall TAboutBox::FormPaint (TObject *Sender) {
Canvas->Brush->Color = clBlue;
Canvas->FillRect (Rect (0,0,ClientWidth, ClientHeight));
Canvas->Pen->Color = clWhite; Canvas->Pen->Width = 20;
Canvas->MoveTo (0,0); Canvas->LineTo (ClientWidth, ClientHeight);
Canvas->MoveTo (0,ClientHeight); Canvas->LineTo (ClientWidth, 0);
}
Аналогичную задачу можно решить в элементе управления PaintBox по событию
PainBoxPaint.
Во втором примере обработчик события, связанного с нажатием кнопки,
формирует диалог для вставки объекта OLE:

void __fastcall TModalForm::Button1Click (TObject *Sender) {
OleContainer1->InsertObjectDialog();
}
17
Третий пример демонстрирует использование компонента Clipboard
для копирования содержимого одного объекта Image в другой:
#include
void __fastcall TForm1::BitBtn1Click (TObject *Sender) {
Image1->Picture->LoadFromFile ("d:/val/scan.bmp");
Clipboard()->Assign (Image1->Picture);
Image2->Picture->Bitmap->Assign (Clipboard ());
}
Компонент Image способен самостоятельно обновляться. Он является
удобным средством ускоренного отображения графики в форме: достаточно
создать скрытый вариант Image и копировать его в канву формы по событию
OnPaint:
void __fastcall TForm1::FormPaint (TObject *Sender) {
this->Canvas->CopyRect (ClientRect, Image1->Canvas, Image1->ClientRect);
}
Исключения
C++Builder поддерживает стандартный механизм обработки исключений
(exception), то есть ошибок, которые могут возникнуть при выполнении
программы (например, при делении на нуль или нарушении обслуживания
потоков). При встрече с ненормальной ситуацией он может передать управление
другой части программы, продолжить ее выполнение либо завершить
работу. Обычно определяют обработчик исключения (exception handler), выполняющий
необходимые действия перед завершением программы. Блоки
кода, генерирующие исключения, начинаются словом try и заключаются в
фигурные скобки. В случае обнаружения ошибки происходит программное
прерывание. При этом управление передается блоку обработчика исключения
catch. В скобках указывают спецификацию класса конкретного исключения,
а для перехвата всех ошибок – многоточие (…). Не менее одного такого
блока следует за блоком try. Для каждой исключительной ситуации определен
свой класс. Некоторые классы исключений приведены в табл. 5.

18
Некоторые классы исключений
Таблица 5.
Класс
EAccessViolation
EConvertError
EDatabaseError
EDivByZero
EInOutError
EPrinterError
EStackOverflow
EZeroDivide
EOverflow
Описание
Ошибка доступа в память
Ошибка преобразования данных
Ошибка доступа к базе данных
Ошибка деления на нуль целого числа
Ошибка файлового обмена
Ошибка печати
Переполнение стека
Ошибка деления на нуль вещественного числа
Переполнение регистров вещественных чисел
В приведенном ранее тексте файла проекта в блок try функции WinMain
помещены выражения инициализации объектов OLE Automation, создания
главной формы и запуска приложения. В блоке catch в случае исключительной
ситуации выводится сообщение с указанием ее причины.
Простой пример обработки исключений может иметь вид:
void __fastcall TForm1::Button2Click (TObject *Sender) {
try { Label1->Caption = Edit1->Text ; }
catch (...) { ShowMessage ("Ошибка"); }
}
Другой пример обработки исключительной ситуации:
try { Roubles->Text =
FloatToStrF (floor (StrToFloat (EditDollars->Text) *
StrToFloat (EditRate->Text) + 0.5), ffFixed, 10, 2);
}
catch (const EConvertError &) {
LabelError->Caption = “Неверный формат числа”;
}
catch (const EOverflow &) {
LabelError->Caption = “Неверная величина числа”;
}
В блоке try можно использовать лексему throw для вызова исключительной
ситуации или для указания типа исключения, которое вызывает
функция. Вслед за блоком try вместо catch часто располагают блок __finally,
выполняющийся вне зависимости от наличия исключительной ситуации.

19
Простые типы данных и операторы
Типы данных C++Builder ориентированы на 32-разрядную платформу
(табл. 6).
Таблица 6.
Типы данных C++Builder
Тип данных Байт Значения Название
char 1 ±128 Байт
BYTE 1 0…255 Байт без знака
short 2 ±32767 Короткий целый
unsigned short, WCHAR 2 0…65534 Короткий целый без знака
int, long 4 ±2147483648 Целый
unsigned long 4 0…4294967295 Целый без знака
__int64 8 9,2E±18 Длинный целый
bool 1 true, false Логический
float 4 1,2E±38 Вещественный
double 8 2,2E±308 Двойной вещественный
long double 10 3,3E±4932 Длинный двойной вещественный
void * 8 2,2E±308 Указатель
char *
Строковый с нулем в конце
void
Пустой
TDateTime 8 Дата и время
Currency 8 Валюта, 4 цифры после запятой
Variant 16 Универсальный (int, float, char, bool)
AnsiString
Динамический строковый
WideString
Строковый, 2 байта на символ
Первая октава образует категорию порядковых типов данных (ordered
data type). Пять последних типов являются типизированными классами (typed
class) C++Builder. Из большого многообразия типов данных рекомендуется в
первую очередь использовать int и __int64, double, bool, AnsiString и void. Некоторые
(фундаментальные) типы введены для совместимости с языком C:
char, short, long, float.
Типы указываются во всех объявлениях переменных и констант. Объявления
переменных могут совмещаться с их инициализацией:
[Модификатор] [Тип] имяПеременной [=Значение];
а во множестве различных объявлений констант инициализация обязательна:
const Тип имяКонстанты = Значение;
enum [Тип] { списокЗначений };
enum { списокЗначений } имяТипа;
#define имяКонстанты Значение

20
Последний вариант объявления констант введен для совместимости с C.
Типы переменных, входящих в параметры функций, указываются в
круглых скобках вслед за именем функции. Если параметр отсутствует, скобки
остаются пустыми. Тип возвращаемого функцией значения указывается
при ее объявлении и определении перед именем. Функция, не возвращающая
значений, объявляется как функция типа void. Если у функции или данных не
объявлен тип, они получают тип int.
В соответствии с типами, различают символьные, строковые, целые и
вещественные константы. Первые заключаются в апострофы (например, ‘e’
или ‘1’), вторые – в кавычки («привет»). Целые бывают десятичными (например
56), восьмеричными (056) и шестнадцатеричными (0хАС), а вещественные
– десятичными (6.23) и экспоненциальными (5Е-12). Специальную
группу символьных констант образуют управляющие последовательности
(табл. 7).
Таблица 7.
Управляющие последовательности
'\0' Ноль '\t' Горизонтальная табуляция
'\a' Сигнал '\v' Вертикальная табуляция
'\b' Возврат на символ '\"' Кавычки
'\f' Новая страница '\'' Апостроф
'\n' Новая строка '\\' Обратная косая черта
'\r' Начало строки
Данные, которыми манипулирует программа, хранятся в ячейках памяти
компьютера, и именованные ячейки памяти мы назвали переменными и константами.
Hо память предназначена не только для хранения значений, обрабатываемых
в ходе выполнения программы. Часть ячеек памяти выделяется
для указания на другие области, и эту часть называют указателями и ссылками.
«Введение связей с другими элементами данных через указатели – чрезвычайно
важная идея в программировании; это ключ к представлению сложных
структур» [Кнут]. Указатель (pointer) – это специальный тип данных,
описывающий не значение, а размещение переменной, константы или возвращаемого
значения функции, «одно из хитроумных понятий C» [Сван]. Его
объявляют как Тип *имяУказателя. Оператор разыменования * (dereference
operator) служит средством доступа к данным, а имяУказателя может быть
другим указателем или адресом конкретной области памяти. В последнем
случае указатель называют ссылкой (reference) и объявляют как Тип
&имяСсылки. & – это оператор взятия адреса, а имяСсылки – значение хранящихся
по этому адресу данных. Между операторами * и & установлено следующее
соотношение: если имяУказателя – адpес данных, то *имяУказателя
– их значение (т.е. указатель); если имяСсылки – значение данных, то
&имяСсылки – их адpес (т.е. ссылка).

21
Однажды инициализировав ссылку, ей нельзя присвоить другое значение.
И, в отличие от указателей, которые могут быть объявлены без инициализации
или установлены в нуль, ссылки всегда указывают на конкретные
данные.
Использование указателей и ссылок играет важную роль в работе с
функциями. Обычно аргументы, передаваемые в функцию при ее вызове, обрабатываются
функцией как копии данных, и потому сами данные не меняются
в ходе выполнения функции. В вызывающем модуле функция может
изменить только одну переменную – ту, которую она возвращает как результат
своей работы. Если же требуется, чтобы функция изменяла более одной
переменной, ей в качестве аргументов следует передавать не значения, а
ссылки на данные, и в первую очередь – адpеса переменных. Аналогичное
правило действует и при передаче функции в другую функцию в качестве аргумента.
Для выполнения операций над типизированными данными в C++ используется
более 50 простых операторов. В табл. 8 они расположены по убыванию
приоритета.
Таблица 8.
Простые операторы C++
Приоритет
Категория Доступ к данным
1 Первичные () [] {} /* */ // ‘’
“” :: ; # -> .
2 Унарные & * - + (тип) new
delete sizeof
Арифметические
Логические
++ -- ! ~
Двоичные
3 Мультипликативные * / % >> =
== !=
6 И && &
7 Исключающее ИЛИ ^
8 ИЛИ || |
9 Условие ? :
10 Присваивание = *= /= %=
+= -=
=
&= |= ^=
Круглые скобки отделяют список аргументов, квадратные – индексы
массивов, фигурные – блоки данных, косые – комментарии. В кавычки заключаются
константы. Двойное двоеточие (::) образует оператор области видимости
данных. Точка с запятой (;) завершает выражения. Знак номера (#)
начинает директивы препроцессора. Стрелка ( -> ) и точка (.) отделяют свойства
и методы классов.
Амперсанд (&) и звездочка (*) помечают адреса, ссылки и указатели.
Операторы сложения и вычитания (+, -) меняют знаки операндов. В скобки

22
заключают временно заменяемый тип данных. Оператором new создаются, а
оператором delete удаляются объекты. Оператор sizeof определяет размер
данных. Оригинальные операторы автоинкремента (++) и автодекремента (-
-) могут действовать до операции или после ее. Так, действие j = i++ аналогично
выражениям j = i; i = i+1. А j = --i можно представить как i = i-1; j = i. То
же можно сказать и о таких операторах, как *=, /= и им подобным. Восклицательный
знак (!) служит для отрицания, а тильда (~) – для инверсии.
Звездочка (*) является знаком умножения, косая черта (/) – деления, а
процент (%) – остатка от деления нацело. Двойными стрелками (>>,

23
Продолжение таблицы 10.
Метод
FormatFloat (AnsiString& format,
long double& val)
Insert (AnsiString& str, int index)
IsDelimiter (AnsiString& delimiters,
int index)
IsEmpty()
LastDelimiter (AnsiString& delimiters)
Length()
LoadStr (int ident)
operator != (AnsiString& rhs)
operator < (AnsiString& rhs)
operator (AnsiString& rhs)
operator >= (AnsiString& rhs)
operator == (AnsiString& rhs)
operator [] (int idx)
operator = (AnsiString& rhs)
operator + (AnsiString& rhs)
operator += (AnsiString& rhs)
Pos (AnsiString& subStr)
printf (char* format, ...)
sprintf (char* format, ...)
SetLength (int newLength)
StringOfChar (char ch, int count)
SubString (int index, int count)
ToDouble (), ToInt ()
ToIntDef (int defaultVal)
Trim (),TrimLeft (),TrimRight ()
UpperCase ()
Назначение
Задает формат представления (0, #, ., ;, E+, ‘ ‘, “ “)
положительных и отрицательных вещественных чисел
и нулей, например # ##0,00 “руб.”
Вставляет подстроку str в позицию index
Подтверждает наличие определенного символа
(delimiter) в заданной позиции (index)
Подтверждает, что строка пуста
Последняя позиция в строке определенного символа
(delimiter)
Длина строки в байтах
Загружает строку из файла
Сравнение с другой строкой rhs
Символ под указанным индексом idx
Инициализация строки другой строкой rhs
Соединение с другой строкой rhs
Позиция начала подстроки subStr в строке
Задают формат строки в стандарте языка С, возвращая
длину или ссылку на строку
Задает длину (newLength) строки
Строка заданного числа (count) символов (ch)
Подстрока длиной count в позиции index
Преобразуют строку в число, в т.ч. – в число по
умолчанию в случае ошибки преобразования
Удаляют пробелы
Преобразует в прописные буквы
Отдельные символы строк класса AnsiString индексируются, начиная с 1.
В следующем примере приведен текст конструктора формы Form1, в
котором вычисляется округленное значение гипотенузы и результат направляется
в надпись Label1. Затем вычисляется средняя длина двух окружностей,
и округленный результат направляется в надпись Label2. Тексты надписей
имеют тип данных AnsiString, поэтому используются функции преобразования
типов FloatToStr и FloatToStrF.
#include
#include
#pragma hdrstop
#pragma resource "*.dfm"

TForm1 *Form1;
24
__fastcall TForm1::TForm1 (TComponent* Owner) : TForm(Owner) {
double a = 5, b = 7;
Form1->Label1->Caption = FloatToStr (floor (hypot (a, b) + 0.5));
double R1 = 5, R2 = 7;
Form1->Label2->Caption = FloatToStrF (M_PI * (R1 + R2), ffFixed, 10, 2);
}
В примере задействована математическая библиотека Borland C , подключаемая
файлом заголовка . Функции этой библиотеки описаны в
табл. 10:
Таблица 11.
Математические функции Borland C
Функции
abs, fabs
acos, asin, atan
cos, sin, tan
exp
floor
hypot
pow, pow10
seal
sqrt
Назначение
Абсолютное значение
Обратные тригонометрические функции
Тригонометрические функции
Экспонента
Ближайшее меньшее целое
Гипотенуза
Степень
Ближайшее большее целое
Квадратный корень
Второй пример посвящен использованию типа AnsiString, а также типов
TDateTime, Currency и Variant.
void __fastcall TForm1::vAnsiStringClick (TObject *Sender) {
AnsiString as = Edit0->Text, as1 = as;
Label0->Caption = as.StringOfChar ('>', as.Length ())
+ as.ToIntDef (0) + as.StringOfChar ('

void __fastcall TForm1::vCurrencyClick (TObject *Sender) {
Currency c = Edit2->Text;
Label2->Caption = (c < 100) ? AnsiString (--c) + " меньше 100 рублей":
AnsiString (c++) + " больше 100 рублей";
}
25
void __fastcall TForm1::vVariantClick (TObject *Sender) {
Variant v = Edit3->Text;
Label3->Caption = (v.Type () == varString) ? v : BoolToStr (v.operator bool ());
}
В третьем примере дана форма с полями ввода Edit1 и Edit2, кнопкой
Button1 и надписью Label1:
class TForm1 : public TForm {
__published:
TEdit *Edit1;
TEdit *Edit2;
TLabel *Label1;
TButton *Button1;
void __fastcall Button1Click (TObject *Sender);
public:
AnsiString CalcF (double, double);
AnsiString CalcSF (AnsiString, double);
AnsiString CalcS (AnsiString, AnsiString);
};
При нажатии кнопки данные из полей формы преобразуются к нужному
формату, обрабатываются в соответствии с условием конкретной задачи, и
результат возвращается в надпись:
void __fastcall TForm1::Button1Click (TObject *Sender) {
AnsiString c = "";
try {
c = CalcF (StrToFloat (Form1->Edit1->Text),
StrToFloat (Form1->Edit2->Text));
} catch (Exception &EConvertError) {
try {
c = CalcSF (Form1->Edit1->Text, StrToFloat(Form1->Edit2->Text));
} catch (Exception &EConvertError) {
try {
c = CalcS (Form1->Edit1->Text, Form1->Edit2->Text);
} catch (...) { c = "Ошибка данных"; }
}
}

}
Form1->Label1->Caption = c;
26
Далее следуют обработчики кнопки Button1, которые выводят в надпись Label1
решение трех задач:
AnsiString TForm1::CalcF (double a, double b) { return a / b; }
AnsiString TForm1::CalcSF (AnsiString a, double b) {
return a + FloatToStr (++b);
}
AnsiString TForm1::CalcS (AnsiString a, AnsiString b) {
return “Имя: “ + a + “\nФамилия: “ + b;
}
Еще один пример посвящен передачи данных из модальной формы в
обычную. Необходимые данные должны быть получены до того, как модальная
форма будет уничтожена. Это удобно делать, в частности, через дополнительный
параметр конструктора. В рассматриваемом примере таким параметром
является указатель *arg, который инициализируется в конструкторе.
При нажатии кнопки Button1 запомненный по указанному адресу заголовок
формы переносится в надпись Label1 не модальной формы:
class TLocalForm : public TForm {
__published: TLabel *Label1;
public:
__fastcall TLocalForm (TComponent* Owner);
__fastcall TLocalForm (String *arg, TComponent* Owner);
};
__fastcall TLocalForm::TLocalForm (String *arg, TComponent*Owner):
TForm (Owner) { *arg = this->Caption; }
void __fastcall TForm1::Button1Click (TObject *Sender) {
String s;
TLocalForm *LocalForm = new TLocalForm (&s, 0);
LocalForm->ShowModal(); delete LocalForm;
this->Label1->Caption = s;
}

27
Составные операторы
«Длинна та дорога, где нет поворота»
Английская пословица
Операторы перехода
Ветвящиеся и циклические алгоритмы управления информационными
процессами реализуются с помощью составных операторов. Такие операторы
часто входят друг в друга, образуя управляющих структуры.
Традиционным средством организации нелинейных процессов являются
операторы перехода, служащие для изменения хода вычислительных процессов.
К таким операторам относятся: break, continue, return, goto Метка.
Первый из операторов перехода прекращает выполнение самого внутреннего
из составных операторов, передавая управление следующему за прерываемым
оператором. Второй прерывает выполнение составного оператора,
передавая управление в его конец. Третий завершает выполнение функции. А
четвертый передает управление на метку внутри текущей функции, состоящую
из имени и двоеточия. Применение его не поощряется в современном
программировании, так как нарушает принцип процедурного подхода. «Goto
- неизбежное зло, ибо программы с безусловными переходами трудно понять»
[Бабэ]; «любая программа может обойтись без оператора goto» [Трой].
Условный оператор
С помощью условного оператора ход вычислительного процесса организуется
в зависимости от значения логического выражения:
if (истинноеЛогическоеВыражение) Выражение… [else Выражение… ]
Логическое выражение строится на базе логических операторов и переменных.
Пример:
void Ifs1 () {
double x, y, r;
x=StrToFloat (MyForm->Edit1->Text);
y=StrToFloat (MyForm->Edit2->Text);
r=StrToFloat (MyForm->Edit3->Text);
if (x * x + y * y < r * r) MyForm->Label1->Caption = "Точка внутри круга";
else MyForm->Label1->Caption = "Точка вне круга";
}
Другой пример посвящен сравнению двух слов:

28
void Ifs2 () {
AnsiString a, b;
a= Edit1->Text; b= Edit2->Text;
if (a > b) Label1->Caption = "a”; else Label1->Caption = "b”
}
Следующий пример демонстрирует, как можно с помощью условного
оператора организовать построение произвольных линий, подобно тому, как
это делается в редакторе Paint. Рисование начинается в момент нажатия
кнопки мыши и заканчивается в момент ее отпускания. Флаг нажатия drawing
должен быть предварительно внесен в список открытых членов класса формы.
void __fastcall TForm1::FormMouseDown (TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y) {
drawing=true;
Canvas->TextOut (X, Y, "Старт!"); Canvas->MoveTo (X, Y);
}
void __fastcall TForm1::FormMouseUp (TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y) {
drawing = false; Canvas->TextOut (X, Y, "Стоп!");
}
void __fastcall TForm1::FormMouseMove (TObject *Sender,
TShiftState Shift, int X, int Y) {
if (drawing) Canvas->LineTo (X, Y);
}
Еще одна функция показывает работу методов Delete (удаление букв) и
Length (длина строки) класса AnsiString в операции сцепления первой буквы
слова a, точки и слова b:
void Ifs3 () {
AnsiString a = MyForm->Edit1->Text;
AnsiString b = MyForm->Edit2->Text;
AnsiString c = a.Delete (2, a.Length () - 1);
if (a > b) MyForm->Label1->Caption = c + '.' + b + '\n' + a;
else MyForm->Label1->Caption = a + '\n' + c + '.' + b;
}

29
Составные операторы могут иметь любую глубину вложенности. Но
«вложенный набор операторов if...else иногда напоминает водопровод старого
дома: система работает, но трудно понять, какая труба куда ведет» [Сван].
Оператор выбора
Оператор выбора служит для организации хода вычислительного процесса
в зависимости от значения выражения или переменной:
switch (порядковаяПеременная)
{ case Константа : Выражение…
...
[default : Выражение…] }
После выполнения каждого выражения действие передается следующему
выражению. Для прерывания этой последовательности обработку каждой
константы в операторе выбора завершают оператором break. Выражения, открываемые
лексемой default, рассчитаны на обработку незапланированных
значений логического выражения. Пример:
void Cases () {
AnsiString day;
}
int n = StrToInt (MyForm->Edit1->Text);
switch (n) {
case 1: day = "Понедельник"; break;
case 2: day = "Вторник"; break;
case 3: day = "Среда"; break;
case 4: day = "Четверг"; break;
case 5: day = "Пятница"; break;
case 6: day = "Суббота"; break;
case 7: day = "Воскресенье"; break;
default: day = "Ошибка ввода";
} MyForm->Label1->Caption = day;
Следующий пример посвящен созданию новой формы в ходе выполнения
программы. Для передачи форме значения параметра newArg класс формы
дополнен вторым конструктором:
class TLocalForm : public TForm {
__published: TLabel *Label1;
public:
__fastcall TLocalForm (TComponent* Owner);
__fastcall TLocalForm (int newArg, TComponent* Owner);
};

30
__fastcall TLocalForm::TLocalForm (int newArg, TComponent* Owner):
TForm (Owner) {
switch (newArg) {
case 1: Label1->Caption = "Обычная форма"; break;
case 2: Label1->Caption = "Форма с параметром"; break;
}
}
Оператор цикла
Оператор цикла организует повторяющийся вычислительный процесс в
заданном диапазоне изменения переменной-счетчика цикла:
for ([ выражениеИнициализации ];
[ выражениеУсловия ];
[ выражениеИтерации ]) Выражение…
Выражения цикла, условия и итерации строятся с использованием переменной-счетчика
цикла, который относится к одному из порядковых типов.
Выражение итерации может быть как увеличивающимся, так и уменьшающимся,
например, a++, b-=2, c--. По завершении цикла значение переменной-счетчика
остается неопределенным.
void Fors1 () {
char ch;
AnsiString alphabet;
// ch – переменная-счетчик цикла
}
for (ch='A'; chLabel1->Caption = alphabet;
Во втором примере для извлечения символов в операциях сравнения
строк и формирования строки символов алфавита служит метод operator []
класса AnsiString. Этот метод возвращает символ строки, соответствующий
указанному в качестве аргумента порядковому номеру.
void Fors2 () {
AnsiString chars="", aa, bb;
aa = MyForm->Edit2->Text; bb = MyForm->Edit3->Text;
char a=aa.operator [](1); char b=bb.operator [](1);
for (char k=a; kLabel1->Caption = chars;
}

31
Для досрочного завершения цикла в его тело включают операторы перехода.
При отсутствии выражения условия или итерации образуются «вечные
циклы», например for (;;).
Операторы повторения
Операторы повторения предназначены для организации вычислительных
процессов, повторяющихся заранее неизвестное число раз. Различают
операторы повторения с предусловием и с постусловием:
while (истинноеЛогическоеВыражение ) Выражение…
do Выражение… while (истинноеЛогическоеВыражение );
Значение логического выражения обычно меняется в теле оператора в ходе
выполнения выражений. В противном случае образуются «вечные циклы»
(endless repetition) типа while (1) или do while (!0). До начала работы оператора
с предусловием должно быть сформировано истинное логическое выражение.
Для досрочного завершения выполнения операторов повторения в
выражениях размещаются операторы перехода. Примеры:
void Whiles1 () {
int temp = 10, count = 1;
AnsiString result = MyForm->Label1->Caption;
while (2 * temp > 3 * count++) result = result + IntToStr (temp--) + ' '; // 10 9 8 7
MyForm->Label1->Caption = result;
}
Оператор повторения с постусловием относится к числу наименее надежных
управляющих структур, так как условие его завершения проверяется только
после начала работы.
void Whiles2 () {
int x = 9;
}
do
MyForm->Label1->Caption = MyForm->Label1->Caption +
IntToStr (x--) + " в квадрате равно " + IntToStr (x * x) + '\n';
while (x);
А вот пример «вечного цикла», выход из которого возможен только с
помощью оператора перехода:

void Whiles3 () {
int leapYear, year;
TLabel *lb = MyForm->Label1;
try { year = StrToInt (MyForm->Edit1->Text); } catch (...) {
lb->Caption = "Вводите годы целыми числами"; return;
}
while (1) {
if (year > 0) {
if ((year % 100) == 0) leapYear = ((year % 400) == 0);
else leapYear = ((year % 4) == 0);
if (leapYear) lb ->Caption = " - високосный";
else lb ->Caption = " - не високосный";
break;
}
else { lb ->Caption = " - неверный"; break; }
} lb ->Caption = IntToStr (year) + lb ->Caption + " год";
}
32
Программирование диалогов
Составные операторы помогают организовать диалог с пользователем с
помощью специально предназначенных для этого функций (табл. 11), что
особенно удобно на этапе подготовки и отладки приложений.
Таблица 12.
Функции сообщений
Функция
int MessageDlg (AnsiString text, TMsgDlgType type,
TMsgDlgButtons buttons, int helpContext)
int MessageDlgPos (AnsiString text, TMsgDlgType type,
TMsgDlgButtons buttons, int helpContext, int X, int Y)
void ShowMessage (AnsiString text)
bool SelectDirectory (AnsiString &dir, TSelectDirOpts options,
int helpContext)
Назначение
Сообщение в центре экрана с
возвратом результата
Сообщение в позиции X,Y с
возвратом результата
Сообщение с кнопкой ОК
Окно диалога для выбора
папки
Большинство функций диалога возвращает определенное значение, которое
можно обрабатывать в составных операторах.
Ниже дан пример обработчика, в котором нажатие кнопки открывает
возможность выбора или создания новой папки, после чего ее адрес отображается
в надписи.
#include
#include
#include
#pragma hdrstop

#pragma resource "*.dfm"
TForm1 *Form1;
33
void __fastcall TForm1::Button1Click (TObject *Sender) {
if (MessageDlg ("Создать/выбрать папку?", mtConfirmation,
TmsgDlgButtons () Controls[i]->Name ;
ShowMessage ("Дочерние объекты формы " + info);
info.Delete (1, info.Length ());
for (i=0; iToolBar1->ControlCount; ++i)
info = info + '\n' + MyForm->ToolBar1->Controls[i]->Name;
ShowMessage ("Дочерние объекты панели инструментов " + info);

34
Введение в структурное программирование
«Подобное к подобному влечется»
Из Платона
Массивы
Для группового представления и обработки однотипных данных применяются
составные типы – массивы (array). В объявлениях массива используются
прямоугольные скобки:
Тип имяМассива [ [Размер] ]…[={списокЗначений} ];
Массивы инициализируются одним из двух способов:
имяМассива [ Индекс ]…=Значение;
имяМассива [ [Размер] ]…= { списокЗначений };
Размер и индекс относятся к целому типу. Они указываются в квадратных
скобках вслед за именем массива. При наличии списка значений один из
размеров можно опускать: он рассчитывается автоматически. Массивы индексируются
с нуля. Число размеров определяет размерность массива, а число
членов массива равно произведению всех размеров. Пример:
void Arrays1 () {
AnsiString students[] = {"Иванов", "Петров", "Сидоров"};
MyForm->Edit1->Text = students[0];
MyForm->Edit2->Text = students[1];
MyForm->Edit3->Text = students[2];
}
Число байтов, выделяемое массиву при инициализации, определяется
как произведение размера типа и числа членов. Для резервирования и освобождения
этой памяти целесообразно использовать выражения
Пример:
имяМассива = new Тип [ Размер ]…;
delete [ ] имяМассива;
void Arrays2 () {
AnsiString *whos;

35
whos = new AnsiString[4];
whos[0] = MyForm->Edit1->Text; whos[1] = "Mr. " + whos[0];
whos[2] = "Dr. " + whos[0]; whos[3] = *(whos + 1);
MyForm->RichEdit1->Text =
whos[0] + '\n' + whos[1] +'\n' + whos[2] + '\n' + whos[3];
delete [] whos;
}
Имя каждого члена массива состоит из имени массива и индексов в
квадратных скобках. Программа обрабатывает многомерные массивы, начиная
с членов, отмеченных крайними справа индексами. Имя массива указывает
на адрес его нулевого члена. Так как начальный адрес массива устанавливается
автоматически в момент инициализации, он не может быть переопределен
пользователем и, следовательно, имена массивов нельзя присваивать
друг другу. Копирование массивов выполняется почленно, в том числе с помощью
специальных функций.
Массив передается в функцию только по ссылке на свой адрес. При передаче
массива в функцию в качестве аргумента указывается имя массива, а
при определении функции с многомерным массивом параметром задается
имя массива и все размеры, кроме первого:
void F1 () { AnsiString x[3]; F2 (x); ShowMessage (x[0] + ‘ ‘ + x[1]); }
void F2 (AnsiString y[3]) { y[0] = “Привет”; *(y+1) = “Салют”; }
void F3 () {
int x[2][2]; F4 (x); ShowMessage (IntToStr (x[0][0]) + ‘ ‘ + IntToStr (x[0][1]));
}
void F4 (int y[][2]) { y[0][0] = 1; y[0][1] = 2; }
Примером массива является свойство Cells компонента StringGrid, которым
задается содержание ячейки, адресуемой индексами. Массивами описывают
также отдельные панели строки состояния и строки списков.
void Arrays4 () {
MyForm->StringGrid1->Cols[1]->Add (“0-ая ячейка 1-го столбца”);
MyForm->StringGrid1->Cols[1]->Add (“1-ая ячейка 1-го столбца”);
MyForm->StringGrid1->Cols[1]->Append (“2-ая ячейка 1-го столбца”);
MyForm->StringGrid1->Cells[2][3] = “Ячейка 2-го столбца 3-ей строки”;
MyForm->StatusBar1->Panels->Items[0]->Text = "Левая панель";

}
MyForm->ListBox1->Items->Strings[0] = "Нулевая строка списка";
36
Массивы эффективно используются в графике, например, для рисования
геометрических фигур по канве формы:
void __fastcall TForm1::FormPaint (TObject *Sender) {
TPoint v[5];
int cw = ClientWidth, ch = ClientHeight;
v[0] = Point (0, cw/10); v[1] = Point (cw/4, cw/10); v[2] = Point (cw/2, cw/4);
v[3] = Point (cw/4, cw/4); v[4] = Point (0, cw/10); Canvas->Polyline (v, 4);
v[0] = Point (cw/2, ch/2); v[1] = Point (cw/2, ch);
v[2] = Point (cw,ch); Canvas->Polygon (v,2);
Canvas->Rectangle (0, ch/2, cw/2, ch);
Canvas->RoundRect (0, ch/2, cw/2, ch, cw/10, ch/10);
Canvas->Ellipse (0, ch/2, cw/2, ch);
}
Свойство Pixels типа TColor у компонентов Canvas можно использовать
как двухмерный массив цвета точки, координаты которой отсчитываются
от левого верхнего угла изображения.
void __fastcall TForm1::FormMouseDown (TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y) {
Label1->Caption = X; Label2->Caption = Y;
Label3->Caption = Canvas->Pixels[X][Y];
Canvas->Pixels[X][Y] = clWhite;
}
Перестановки и сортировки
Простым алгоритмом описывается широко распространенная в программировании
операция перестановки (swap) данных местами. Пример перестановки
пары переменных выглядит так:
void Swap (int &a, int &b) { int x = a; a = b; b = x; }
void SwapVar () {
int x = 2, y = 1;
Swap (x, y);
ShowMessage (x >y ? “x > y” : “x < y”);
}

37
Следующий пример иллюстрирует перестановку членов массива:
void Swap (AnsiString a[], int n) {
int i, j;
for (i=0, j=n-1; i

38
ing), в отличие от «пузырька», переставляются не соседние, а далеко отстоящие
члены, что иногда повышает скорость в 1,5 раза.
Примерно втрое большую скорость, чем сортировка методом «пузырька»,
обеспечивает «быстрая сортировка» (quick sorting). При сортировке
этим методом выбирается произвольный член, а остальной список сортируемых
членов делится пополам, и каждый член одной половины сравнивается с
членами другой. Затем список вновь делится пополам и выполняется перестановка
и т.д. Этот алгоритм положен в основу ряда библиотечных функций.
void Swap (int &x, int &y) { int temp = x; x = y; y = temp; }
void BubbleSort (int array[], int N) {
for (int i=0; ii; --j)
if (array[j] < array[j-1]) Swap (array[j], array[j-1]);
}
void ExchangeSort (int array[], int N) {
for (int i=0; i array[j]) Swap (array[j], array[j-1]);
}
void ShellSort (int array[], int N) {
int delta = 1, sw, offset = (N-1+delta) / 2;
while (offset > 0) {
int limit = N-1+delta-offset;
do {
sw = 0;
for (int i=1; iarray[i+offset-delta]) {
Swap (array[i-delta], array[i+offset-delta]); sw = i;
}
limit = sw - offset;
} while (sw);
offset /= 2;
}
}

39
void QuickSort (int array[], int left, int right) {
int i = left, j = right, temp, test = array [(left+right) / 2];
do {
while (array[i] < test) ++i;
while (test < array[j]) --j;
if (i RadioGroup1->ItemIndex) {
case 0: BubbleSort (array, N); break;
case 1: ExchangeSort (array, N); break;
case 2: InsertionSort (array, N); break;
case 3: ShellSort (array, N); break;
case 4: QuickSort (array, 0, N-1); break;
}
for (i=0; i

= 0, если elem1 == elem2,
> 0, если elem1 > elem2:
40
int Sort_function (const void *a, const void *b);
void Qsorting () {
char list[5] = {'c', 'r', 'a', 'p', 'n'};
int i;
AnsiString result;
qsort ((void*) &list, 5, sizeof (list[0]), Sort_function);
for (i = 0; i < 5; i++) result += AnsiString (list[i]) + ' ';
ShowMessage (result);
}
int Sort_function (const void *a, const void *b) {
return strcmp ((char*) a, (char*) b);
}
Списки TStringList
Разновидностью массивов являются последовательности символьных
строк – списки. VCL поддерживает общий интерфейс со списками через
класс TString и производный от него класс TStringList. Это один из самых популярных
классов, представляющий удобный контейнер для хранения строк
и связанных с ними объектов. Методы класса позволяют загружать и сохранять,
создавать списки, манипулировать строками, сортировать, вставлять,
добавлять и удалять их.
Временные списки и списки длительного пользования проектируют поразному.
Первые обычно создаются и разрушаются в пределах одной функции:
void __fastcall TForm1::Button1Click (TObject *Sender) {
TStringList *TempList = new TStringList;
try { Label1->Caption = “Временный список используется”; }
__finally { delete TempList;}
}
Вторые сначала объявляются в файле заголовка формы как указатели
на объекты класса TString. Объявленные объекты создаются в конструкторе
формы и освобождают память при ее уничтожении. В приведенном ниже
примере в файле заголовка формы был объявлен открытый указатель
TStringList *ConstList:

__fastcall TForm1::TForm1 (TComponent* Owner): TForm (Owner) {
ConstList = new TStringList;
}
void __fastcall TForm1::FormClose (TObject *Sender, TCloseAction &Action) {
ConstList->SaveToFile (ChangeFileExt (Application->ExeName, ".LOG"));
delete ConstList;
}
void __fastcall TForm1::FormMouseDown (TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y) {
TVarRec v[] = {X,Y};
ConstList->Add (Format ("Курсор в (%d,%d)", v, ARRAYSIZE (v) - 1));
}
41
Новая строка в конец списка добавляется методом Add. Количество
строк в списке вычисляется методом Count, а свойство Strings содержит весь
массив строк, доступных по их индексам, начиная с 0. Метод IndexOf определяет
индекс строки, содержащей указанный текст, например:
void StringLists2 () {
MyForm->ConstList->Add ("Конец");
MyForm->ConstList->Strings [ConstList->Count-1] =
MyForm->ConstList->IndexOf ("Конец");
}
Чтобы добавить i-ю строку в список, используется метод Insert. Для
добавления строк из другого списка служит методы Assign и AddStrings.
Перемещение строк внутри списка выполняется методом Move. Удалением
строки занимается метод Delete, а Clear очищает список:
void StringLists3 () {
TStringList *tsl = new TStringList;
tsl->Add (“Раз”);
tsl->Add (“Два”);
ShowMessage (tsl->Count);
ShowStr (tsl);
// Раз Два
tsl->Insert (1, “Полтора”); ShowStr (tsl); // Раз Полтора Два
tsl->Move (0, 2); ShowStr (tsl);
// Полтора Два Раз
tsl->Exchange (0, 1); ShowStr (tsl); // Два Полтора Раз
tsl->Delete (1); ShowStr (tsl);
// Два Раз
tsl->Sort (); ShowStr (tsl);
// Два Раз
int index; if (tsl->Find (“Раз”, index)) ShowMessage (index); // 0
tsl->Clear (); ShowStr (tsl);

42
TStringList *temp = new TStringList;
Temp->Assign (tsl); ShowStr (temp);
delete temp;
// Два Раз
Memo1->Lines->Assign (tsl);
RichEdit1->Lines->Assign (tsl);
tsl->Assign (Memo1->Lines);
TStrings *ml = Memo1->Lines;
ml->Add (“Три”);
ShowMessage (ml->Count);
ml->Move (0, 1);
ml->Insert (1, “Четыре”);
ml->Delete (1);
ml->Clear ();
ComboBox1->Items->AddStrings (tsl);
TStrings *lb = ListBox1->Items;
lb->AddStrings (tsl);
lb->Add (“Три”);
lb->Append (“Четыре”);
ShowMessage (lb->Count);
lb->Insert (2, “Пять”);
lb->Move (0, 1);
lb->Exchange (0, 1);
lb->Delete (1);
lb->SaveToFile (“1.txt”);
lb->Clear ();
lb->LoadFromFile (“1.txt”);
ShowMessage (lb->Text);
ShowMessage (lb->Strings[0]);
ShowMessage (ListBox1->ItemIndex); // номер выделенной строки
if (ListBox1->Selected[1] == true)
ShowMessage (lb->Strings[ListBox1->ItemIndex]);
ListBox1->Sorted = true;
ListBox1->ItemIndex = 1;
}
void ShowStr (TStringList *z) {
AnsiString s;
for (int i=0; iCount; ++i) s+= z->Strings[i] + ‘\n’;
ShowMessage (s);
}

43
Структуры и объединения
Упростить представление и групповую обработку разнотипных данных
помогают структуры (structure). Их объявления:
struct имяТипаСтруктуры { объявлениеПолей };
struct имяСтруктуры { объявлениеПолей } [=списокЗначений ];
struct имяТипаСтруктуры имяСтруктуры [={ списокЗначений }];
где объявление полей имеет формат
Тип имяПоля;…
Как и любой тип, структура представляет абстрактную категорию, характеризующую
размер памяти и способ обработки данных. Для работы с
данными создаются переменные:
имяТипаСтруктуры списокИменСтруктур;
Структуры инициализируют, подобно классам:
имяСтруктуры.имяПоля = Значение;
указательНаСтруктуру->имяПоля = Значение;
Имена полей уникальны в пределах структуры. Поля поддерживают
все операции, характерные для их типов. Структуры и объединения могут
вкладываться друг в друга. Примеры:
void Structures1 () {
struct Student {
AnsiString firstName;
int birthYear;
double scholarship;
};
Student example;
example.firstName = MyForm->Edit1->Text ;
example.birthYear = StrToInt (MyForm->Edit2->Text);
example.scholarship = StrToFloat (MyForm->Edit3->Text) ;
MyForm->StringGrid1->Cells[1][1] = example.firstName;
MyForm->StringGrid1->Cells[2][1] = example.birthYear;
MyForm->StringGrid1->Cells[3][1] = example.scholarship;
}

void Structures2 () {
TStringGrid *sg = StringGrid1;
int rows = sg->RowCount;
struct s {int n; AnsiString nm;};
s group;
try {
for (int i=0; iCells[0][i]);
group.nm = sg->Cells[1][i];
ShowMessage (IntToStr (group.n) + ' ' + group.nm);
}
} catch (...) { ShowMessage ("Заполнить ячейки"); }
}
44
Следующий пример посвящен пузырьковой сортировке строк String-
Grid с использованием структуры:
void Structures3 () {
TStringGrid *sg = StringGrid1;
int rows = sg->RowCount;
struct s { AnsiString name; int year; };
s temp;
for (int i=1; ii; --j)
if (sg->Cells[0][j] < sg->Cells[0][j-1]) {
temp.name = sg->Cells[0][j];
sg->Cells[0][j] = sg->Cells[0][j-1];
sg->Cells[0][j-1] = temp.name;
temp.year = StrToInt (sg->Cells[1][j]);
sg->Cells[1][j] = sg->Cells[1][j-1];
sg->Cells[1][j-1] = temp.year;
}
}
При передаче в функцию в качестве аргументов могут использоваться
как имена полей, так и указатели на адреса. Применение указателя в качестве
значения аргумента избавляет от необходимости копирования в функцию
всех данных, но в этом случае они остаются беззащитными перед изменениями
в теле функции. Для устранения этой проблемы перед указателем
можно помещать лексему const. Пример передачи данных структуры:
struct x {int size, price;};
void Change1 (x y) { y.size = y.price; }
void Change2 (x *y) { y->size = y->price;}

45
void Structures4 () {
x y = {1, 2};
Change1 (y);
MyForm->Edit1->Text = y.size - y.price;
Change2 (&y);
MyForm->Edit2->Text = y.size - y.price;
}
Близкие к структурам по смыслу объединения (union) позволяют хранить
в одной и той же области памяти значения переменных разных типов,
поочередно заменяя одно другим. Размер памяти, занимаемой данными объединения,
назначается в соответствии с тем из типов, который требует больше
памяти. Их объявление и пример:
union имяТипаОбъединения {объявлениеПолей} имяОбъединения
[={списокЗначений}];
void Unions () {
union intDbl {int i; double x;} id = {70};
MyForm->Edit1->Text = "Масса в граммах" + IntToStr (id.i);
id.x = 0.07;
MyForm->Edit2->Text = "Масса в килограммах" + FloatToStr (id.x);
}
Динамические структуры данных
В отличие от составных типов, динамические структуры данных (dynamic
data structure), или связные списки (linked list), изменяются в размере по
мере заполнения и освобождения их от данных и обычно не требуют последовательного
размещения элементов в памяти компьютера. Динамические
структуры не входят в состав типов данных традиционных языков программирования
и присутствуют в них как классы. Они, как правило, разрабатываются
программистами или берутся из библиотек – контейнеров. Каждая
структура характеризуется порядком заполнения (allocation) и порядком обхода
(traversal).
Некоторые характеристики классов динамических структур C++Builder
приведены в табл. 12:

46
Свойства и методы контейнерных классов C++Builder
Таблица 13.
Имя Член Классы Назначение
Push Метод TStack, TQueue Добавляет член в вершину
Pop Метод TStack, TQueue Удаляет члены из вершины
Peek Метод TStack, TQueue Указатель на вершину
Count Метод TStack, TQueue Возвращает число членов (размер)
AtLeast Метод TStack, TQueue Проверяет размер
Capacity Свойство TList Максимальный размер
Count Свойство TList Фактический размер
Items Свойство TList Указатель на член
List Свойство TList Указатель на список членов
First Метод TList Указатель на первый член
Last Метод TList Указатель на последний член
Add Метод TList Добавляет член в вершину
Insert Метод TList Добавляет член в заданное место
Delete Метод TList Удаляет член с указанным индексом
Remove Метод TList Удаляет указанный член
Clear Метод TList Удаляет все члены
Pack Метод TList Удаляет пустоты
Exchange Метод TList Меняет местами два члена
Move Метод TList Перемещает указанный член
Expand Метод TList Увеличивает максимальный размер
Sort Метод TList Сортирует члены
Наиболее распространенной динамической структурой является стек
(stack). Это последовательность данных, в которой помещение и выборка
информации выполняется с одного конца, именуемого вершиной стека (top).
Иными словами, стек обрабатывает данные по принципу «последним вошел
– первым вышел» (LIFO – Last Input, First Output). Примеры:
void __fastcall TForm1::STACKClick (TObject *Sender) {
AnsiString a[] = { "Иванов", "Петров", "Сидоров" }, b = "0\n";
TStack *s = new TStack;
for (int i=0; iPush (a[i].c_str ());
b += AnsiString (s->Count ()) + ' ' + (char*) s->Peek () + '\n';
}
while (s->AtLeast (1))
b += AnsiString (s->Count ()) + ' ' + (char*) s->Pop () + '\n';
ShowMessage (b + '0');
// 0 1 Иванов 2 Петров 3 Сидоров
} // 3 Сидоров 2 Петров 1 Иванов 0

47
void SimpleStack() {
TStack *vStack = new TStack;
vStack->Push ("Пеpвое ");
vStack->Push ("Втоpое "); vStack->Push ("Тpетье ");
ShowMessage ("Добавили " + AnsiString (vStack->Count ()));
vStack->Pop (); ShowMessage ("Осталось " + AnsiString (vStack->Count ()));
}
Далее приведен пример разработки символьного стека:
const int ARRAYSIZE = 1000;
struct vStack { char s[ARRAYSIZE]; int top; };
void Reset (vStack *stk) { stk->top = -1; }
int Empty (const vStack *stk) { return stk->top == -1; }
int Full (const vStack *stk) { return stk->top == ARRAYSIZE - 1; }
void Push (char *str, vStack *stk) {
int i = 0; while (str[i]) if (!Full (stk)) stk->s[++stk->top] = str[i++];
}
void Pop (vStack *stk) {
AnsiString result;
while (!Empty (stk)) result += AnsiString (stk->s[stk->top--]) + '\n';
ShowMessage (result);
}
void MyStack () {
vStack s;
Reset (&s);
Push ("Пеpвое ", &s); Push ("Втоpое ", &s); Push ("Тpетье ", &s); Pop (&s);
}
Очередью (queue) называют динамическую структуру, в которой помещение
данных выполняется с одного конца – входа очереди (input), а выборка
– с другого конца – выхода очереди (output) по принципу «первым вошел
– первым вышел» (FIFO – First Input, First Output):
void __fastcall TForm1::QUEUEClick (TObject *Sender) {
AnsiString a[] = { "Иванов", "Петров", "Сидоров" }, b = "0\n";
TQueue *q = new TQueue;
for (int i=0; iPush (a[i].c_str());

48
b += AnsiString (q->Count ()) + ' ' + (char*) q->Peek () + '\n';
}
while (q->AtLeast (1))
b += AnsiString (q->Count ()) + ' ' + (char*) q->Pop () + '\n';
ShowMessage (b + '0');
// 0 1 Иванов 2 Иванов 3 Иванов
} // 3 Иванов 2 Петров 1 Сидоров 0
void SimpleQueue () {
TQueue *vQueue = new TQueue;
vQueue->Push ("Пеpвое ");
vQueue->Push ("Втоpое "); vQueue->Push ("Тpетье ");
ShowMessage ("Добавили " + AnsiString (vQueue->Count ()));
vQueue->Pop ();
ShowMessage ("Осталось " + AnsiString (vQueue->Count ()));
}
Списком называется динамическая структура, в которой поддерживаются
помещение и выборка данных в произвольных позициях. Каждый член
списка, именуемый узлом (node), содержит поле данных и поле–указатель
следующего узла.
Список называют линейным (linear list), если обход его выполняется
только в одном направлении – от предшествующего узла к последующему,
начиная с первого узла и кончая последним. Список называют циклическим
(cyclic list), если последний узел его содержит указатель на первый узел; в
нем обход выполняется также в одном направлении, но из любого узла можно
достичь любой другой узла. Пример:
void MyList () {
TList *vList = new TList ();
AnsiString item = "что-то есть";
try {
vList->Add (item.c_str ());
ShowMessage ("В списке " + IntToStr (vList->Count));
vList->Remove (item.c_str ());
ShowMessage ("В списке " + IntToStr (vList->Count));
}
catch (...) { delete vList; throw; }
delete vList;
}
void Info (TList *vl) {
AnsiString b;
for (int i=0; iCount; ++i) { b += AnsiString (i) + ' ' + (char*) vl->Items[i] + '\n';
}

ShowMessage ("В списке: " + IntToStr (vl->Count) + '\n' + b);
}
void __fastcall TForm1::LISTClick (TObject *Sender){
AnsiString a[] = {"Иванов", "Петров", "Сидоров", "Смирнов"};
TList *vList = new TList;
try {
vList->Capacity = 10;
for (int i=0; iAdd (a[i].c_str ());
Info (vList); // В списке 4: 0 Иванов 1 Петров 2 Сидоров 3 Смирнов
49
vList->Remove (vList->Items[1]); vList->Delete (1);
Info (vList); // В списке 2: 0 Иванов 1 Смирнов
vList->Insert (1, a[0].c_str ());
Info (vList); // В списке 3: 0 Иванов 1 Иванов 2 Смирнов
ShowMessage ("Свободно " + IntToStr (vList->Capacity-vList->Count)); // 7
vList->Pack ();
ShowMessage ("Свободно " + IntToStr (vList->Capacity-vList->Count)); // 7
} catch (...) { delete vList; throw; }
delete vList;
}
Пример разработки списка:
struct vList { int value; vList *p; };
vList *current, *last, *first;
int Get () {
static value;
int val = MessageDlg ("Продолжать?", mtConfirmation,
TmsgDlgButtons () p = 0;
if (last) last->p = current; else first = current;
last = current;
}
}

50
void Info () {
AnsiString result;
if (first) {
result = "Список: ";
current = first;
do { result += AnsiString (current->value) + ' '; current = current->p; }
while (current);
result += " Конец";
}
ShowMessage (result);
}
void MyList () { Add (); Info (); Add (); Info (); }
Другой пример посвящен двухмерному списку. Он демонстрирует технику
выделения и освобождения памяти динамической структуре данных:
struct vMatr { double **base; int row, column; };
void Allocate (int r, int s, vMatr &m) {
m.base = new double *[s];
for (int i=0; i

int i, j, k[] = {2, 3, 4, 2}; // заданы случайные размеры массовов
Allocate (k[0], k[1], book1); Allocate (k[2], k[3], book2);
for (i=0; i

52
прямом порядке обхода (depth-first traversal) («просмотре в глубину») движение
начинается от корня и выполняется от родителей сначала к левым потомкам,
а затем к правым. При обратном порядке (breadth-first traversal) обход
начинается с листьев и выполняется от потомков к родителям слева направо,
завершаясь в корне. Наиболее распространенный обход в симметричном порядке
(simmetrical traversal) направлен от левого потомка через родителя к
правому потомку от листьев к корню.
Пример двоичного дерева:
struct vTree { char *data; vTree *left; vTree *right; };
vTree *root;
void Search (vTree **tree, const char *s);
AnsiString Process (vTree *node);
AnsiString InOrder (vTree *node);
void MyTree () {
char s[128];
// можно сортировать любые массивы
randomize();
for (int i=1; idata = strdup (s); p->left = 0; p->right = 0; *tree = p;
}
else {
p = *tree;
cmpResult = strcmp (s, p->data); // сравнение строк
if (cmpResultleft, s);
else if (cmpResult>0) Search (&p->right, s);
else ShowMessage ("Такой член уже есть");
}
}
AnsiString Process (vTree *node) {
static AnsiString result;
result += AnsiString (node->data) + ' ';

53
return result;
}
AnsiString InOrder (vTree *node) {
AnsiString result;
If (node != 0) {
InOrder(node->left);
result = Process (node);
InOrder (node->right);
}
return result;
}
Введение в модульное программирование
«Требуется гораздо больше ума, чтобы передать
свои мысли, чем чтобы их иметь»
Из Гельвеция
Работа с текстовыми и графическими файлами
Файл (file) представляет именованную область накопителя, предназначенную
для хранения, передачи и приема структурированной информации.
Число одновременно открытых файлов и их размер определяются возможностями
операционной системы и ресурсами компьютера.
Ряд визуальных компонентов поддерживает файловый обмен своими
методами SaveToFile и LoadFromFile. К ним относятся классы TStrings, TPicture,
TOLEGraphic, TGraphic и производные от них классы. Рассмотрим несколько
примеров:
Для загрузки и сохранения строк в текстовом файле используются методы
SaveToFile и LoadFromFile класса TStringList, организующие обмен таким
образом, что каждая строка файла соответствует строке списка. Это
применяется в заполнении из файлов элементов управления класса Memo или
в сохранении содержимого элементов управления классов List и ComboBox,
например:
void StringLists1 () {
AnsiString file = "test.INI";
Form1->Memo1->Lines->LoadFromFile (file);
Form1->Memo1->Lines->SaveToFile (ChangeFileExt (file,".BAK"));
}

Списки в файл и из файла
void __fastcall TForm1::StringListFilesClick (TObject *Sender) {
AnsiString fName = "D:\\examples\\tempFile.txt";
TStringList *sl = new TStringList;
sl->Add ("раз"); sl->Add ("два"); sl->Add ("три"); sl->SaveToFile (fName);
sl->Clear (); sl->LoadFromFile (fName);
ListBox1->Items->LoadFromFile (fName); ComboBox1->Items->Assign (sl);
delete sl;
}
// Строки в файл и из файла
void __fastcall TForm1::ListFilesClick (TObject *Sender) {
AnsiString fName ="tempFile.txt";
StringListFilesClick (Sender);
struct s { AnsiString as; int i; };
s myS[3];
for (int j=0; jItems->Count; ++j) {
myS[j].as = ListBox1->Items->Strings[j]; myS[j].i = j;
}
for (int j=0; jCells[0][j] = myS[j].as; StringGrid1->Cells[1][j] = myS[j].i;
}
StringGrid1->Cols[0]->SaveToFile (fName);
Memo1->Lines->LoadFromFile (fName);
RichEdit1->Lines->LoadFromFile (fName);
}
// Картинки из файлов
void __fastcall TForm1::GraphFilesClick (TObject *Sender){
AnsiString fName = "D:\\examples\\scan.bmp";
Image1->Picture->LoadFromFile (fName);
Form1->Icon->LoadFromFile ("scan.ico");
Graphics::TBitmap *gb = new Graphics::TBitmap;
gb->LoadFromFile (fName); PaintBox1->Canvas->Draw (0, 0, gb);
this->Canvas->CopyMode = cmSrcPaint;
this->Canvas->CopyRect
(ClientRect, PaintBox1->Canvas, PaintBox1->ClientRect);
delete gb;
}
// Кнопки с картинками из файла
void __fastcall TForm1::BtnFilesClick (TObject *Sender) {
AnsiString fName = "D:\\examples\\scan.bmp";
BitBtn1->Glyph->LoadFromFile (fName);
54

55
SpeedButton1->Glyph->LoadFromFile (fName);
}
Для проведения файлового обмена без рассмотренных компонентов в
C++Builder используются функции, приведенные в табл. 13. Работа с файлом
ведется с помощью файловых переменных (file variable), связываемых с конкретными
файлами. Файл открывается для чтения, записи или других операций.
После работы файл следует закрыть.
Таблица 14.
Функции файлового обмена
Функция
Int FileCreate (AnsiString name)
Int FileOpen (AnsiString name, int
mode)
Int FileWrite (int handle, void
*buffer, int count)
Int FileRead (int handle, void
*buffer, int count)
void FileClose(int handle)
int FileSeek (int handle, int offset,
int origin)
bool DeleteFile (AnsiString name)
bool FileExists (AnsiString name)
bool DirectoryExists (AnsiString
name)
bool ForceDirectories (AnsiString
dir)
AnsiString FileSearch (AnsiString
name, AnsiString dir)
Назначение
Создает новый или переписывает существующий
файл с заданным именем, возвращая файловую переменную.
Открывает файл в режимах (mode) fmOpenRead
(чтение), fmOpenWrite (запись), fmOpenReadWrite
(чтение-запись), возвращая файловую переменную.
Пишет count байт в файл handle из *buffer, возвращая
число записанных байтов
Читает count байт из файла handle в *buffer, возвращая
число прочитанных байтов.
Закрывает файл.
Позиционирует указатель в файле со смещением
(offset) относительно базы (origin), равной 0 (начало),
1 (текущая позиция указателя) или 2 (конец
файла), возвращая позицию указателя в файле.
Удаляет файл.
Проверяет наличие файла.
Проверяет наличие папки.
Создает папки.
Выполняет поиск файла name в папках dir.
Ниже даны примеры организации файлового обмена.
Первый простой пример представляем вывод в файл содержания полей
Edit1 и Edit2:
void __fastcall TForm1::FieldsToFileClick (TObject *Sender) {
AnsiString a = Edit1->Text,
b = Edit2->Text;
int f = FileCreate ("tempFile.txt");
if (f != -1) {
FileWrite (f, a.c_str (), a.Length ());
FileWrite (f, b.c_str (), b.Length ());

FileClose (f);
}
}
56
Во втором примере создается файл, в него заносятся два числа, и он закрывается.
Затем файл открывается для чтения и возвращается его содержимое.
void Files1 () {
AnsiString name = "test.dat";
if (FileExists (name))
if (Application->MessageBoxA ("Переписать файл?",
"Есть такой файл", MB_YESNO | MB_ICONQUESTION)!=IDYES) return;
int iFile = FileCreate (name);
if (iFile == -1) { ShowMessage ("Не создать файл"); return; }
AnsiString first = MyForm->Edit1->Text;
AnsiString second = MyForm->Edit2->Text;
char *firstStr = first.c_str (), *secondStr = second.c_str ();
int err = FileWrite (iFile, firstStr, first.Length ());
if (err == -1) { ShowMessage ("Не записать файл"); return;}
err = FileWrite (iFile, secondStr, second.Length ());
if (err == -1) { ShowMessage ("Не дописать файл"); return; }
FileClose (iFile);
iFile = FileOpen (name, fmOpenRead);
if (iFile == -1) { ShowMessage ("Не открыть файл"); return; }
int readLen = first.Length () + second.Length ();
char *getStr;
getStr = new char[readLen + 1];
err = FileRead (iFile, getStr, readLen);
if (err == -1) { ShowMessage ("Не прочитать файл"); return; }
FileClose (iFile);
}
ShowMessage (AnsiString (getStr, readLen));
В третьем примере после открытия первого файла определяется его
размер, указатель возвращается в начало, и в массив читается его содержимое.
Затем открывается второй файл для записи в него содержимого массива.

void Files2 () {
AnsiString from = MyForm->Edit1->Text, to = MyForm->Edit2->Text;
try {
57
int iFile = FileOpen (from, fmOpenRead);
int len = FileSeek (iFile, 0, 2);
FileSeek (iFile, 0, 0);
char *c;
c = new char [len + 1];
len = FileRead (iFile, c, len);
FileClose (iFile);
iFile = FileOpen (to, fmOpenWrite);
FileWrite (iFile, c, len);
}
ShowMessage (from + " -> " + to + '\n' + AnsiString (c, len));
delete [] c;
FileClose (iFile);
} catch (...) { ShowMessage ("Ошибка одной из файловых операций"); }
Аналогичный пример посвящен отображению содержания файла в
надписи Label1:
void __fastcall TForm1::LabelFromFileClick (TObject *Sender) {
int f = FileOpen ("tempFile.txt", fmOpenRead);
if (f != -1) {
int size = FileSeek (f, 0, 2);
char *s = new char[size+1];
FileSeek (f, 0, 0);
FileRead (f, s, size);
Label1->Caption = AnsiString (s, size);
FileClose (f);
delete [] s;
}
}
Далее показано, как файл с текстом, указанным в Label1, дополняется
содержимым поля Edit1:
void __fastcall TForm1::InsertToFileClick (TObject *Sender) {
int f = FileOpen ("tempFile.txt", fmOpenWrite);
if (f != -1) {
AnsiString is = Label1->Caption, what = Edit1->Text;
is += what;

Label2->Caption = is;
FileWrite (f, is.c_str (), is.Length ());
FileClose (f);
}
}
58
Следующий пример посвящен изменению содержимого файла. Вначале
текст файла считывается в массив, который преобразуется в строку. В этой
строке отыскивается заданное слово и заменяется фразой «[Удалено]», а
файл заполняется пробелами. После этого измененная строка возвращается в
файл.
void Files3 () {
AnsiString word = MyForm->Edit1->Text,
file = MyForm->Edit2->Text,
bText ="";
try {
int bFile = FileOpen (file, fmOpenReadWrite);
int bLen = FileSeek (bFile, 0, 2);
char *b = new char [bLen];
FileSeek (bFile, 0, 0);
FileRead (bFile, b, bLen);
bText =AnsiString (b, bLen);
delete [] b;
int index = bText.AnsiPos (word.c_str());
if (!index) {
ShowMessage ("В файле нет такого слова");
FileClose (bFile); return;
}
bText.Delete (index, word.Length ());
bText.Insert ("[Удалено]", index);
FileSeek (bFile, 0, 0);
AnsiString c = AnsiString::StringOfChar (' ', bLen);
FileWrite (bFile, c.c_str (), bLen);
FileSeek (bFile, 0, 0);
FileWrite (bFile, bText.c_str (), bText.Length ());
FileClose (bFile);

} catch (...) { ShowMessage ("Ошибка файловой операции"); }
ShowMessage (bText);
}
59
Пример удаления фрагмента, заданного в Edit1, из файла, в котором содержится
указанная в Label1 фраза:
void __fastcall TForm1::DelFromFileClick (TObject *Sender) {
AnsiString is = Label1->Caption, what = Edit1->Text, was = is;
int f = is.AnsiPos (what.c_str ());
ShowMessage (is+ ' ' +IntToStr (is.Length ()));
If (f) is.Delete (f, what.Length ());
ShowMessage (is + ' ' + IntToStr (is.Length ()));
Label3->Caption = is;
f = FileOpen ("tempFile.txt", fmOpenWrite);
if (f != -1) {
is += AnsiString::StringOfChar (' ', was.Length ());
FileWrite (f, is.c_str (), is.Length ());
FileClose (f);
}
}
Еще один пример демонстрирует процесс поиска файла, в том числе – с
символом подстановки *, в текущей папке и в папке Windows:
void Files4 () {
char buffer[256];
}
GetWindowsDirectory (buffer, sizeof (buffer));
AnsiString file = FileSearch (MyForm->Edit1->Text, GetCurrentDir() +
";" + AnsiString (buffer));
if (file.IsEmpty ()) ShowMessage ("Нет файла " + MyForm->Edit1->Text);
else ShowMessage ("Есть файл " + file + " !");
Работа с двоичными файлами
Разработано множество способов запуска исполнительных файлов из
приложений C++.
В файле заголовка PROCESS.H объявлена группа функций семейства
exec… Эти функции загружают в память и открывают исполнительные файлы
(дочерние процессы), одновременно лишая ресурсов и прекращая родительский
процесс. Первым параметром этих функций всегда является путь к

60
вызываемому дочернему процессу, а при запуске каждая такая функция передает
несколько дополнительных параметров этому процессу:
Например:
exec…(путь, параметры).
execl (“MyFile.exe”, “MyFile.exe”, NULL);
Суффиксы l, v, p, e, добавляемые к имени exec, раскрывают требования
к параметрам. Так, l свидетельствует о постоянном фиксированном числе параметров,
v говорит о непостоянном массиве указателей в списке параметров,
p указывает, что путь следует искать в переменной окружения path, а e – в
списке параметров окружения дочернего процесса. В случае неудачного запуска
exec… возвращает –1, а глобальная переменная errno устанавливается
в одно из следующих значений: EACCESS – отказ в доступе, EMFILE – много
открытых файлов, ENOENT – не найден путь, ENOEXEC – мало памяти.
В файле заголовка SHELLAPI.H объявлена серия полезных функций
запуска приложений без закрытия родительского процесса. Среди них – Win-
Exec, ShellExecute, CreateProcess и другие. В числе их параметров всегда
присутствует режим окна, который задается константами SW_MINIMIZE,
SW_MAXIMIZE, SW_NORMAL, SW_RESTORE, SW_HIDE. Примеры:
WinExec (“MyFile”, SW_RESTORE);
ShellExecute (Handle, NULL, “MyFile.exe”, NULL, NULL, SW_RESTORE);
ShellExecute (Handle, “open”, “File.doc”, NULL, NULL, SW_RESTORE);
К двоичным файлам относятся, также, растровые файлы, значки, курсоры
и файлы ресурсов (.RES). Все они просматриваются, создаются и редактируются
графическим редактором Image Editor, доступным через меню
Tools. Редактор достаточно прост в использовании и во многом напоминает
известный редактор Microsoft Paint.
Модули DLL и пакеты
Одним из самых распространенных способов создания модульных приложений
являеся использование библиотек динамической компоновки DLL и
BPL. Такие библиотеки представляют особый вид выполняемого кода (компилированных
функций, констант, форм, ресурсов), хранящийся в файлах с
расширениями .DLL и .BPL, которые рассчитаны на одновременное использование
несколькими программами. Пакеты (package) BPL оснащены средствами
работы с компонентами VCL. Они располагают большей, чем DLL,
информацией о вызывающем приложении, а приложение, в свою очередь,

61
лучше контролирует поведение связанного модуля. К сожалению BPL обслуживают
только приложения C++Builder, тогда как DLL более универсальны
и работают с любыми приложениями в разных операционных системах.
Модули DLL и BPL можно подключать к приложению статически (design
time mode) и динамически (runtime mode). Статически загружаемые модули
связываются с главной программой при ее компоновке и остаются загруженными
в память все время, пока выполняется приложение. Такие модули
содержат экспортируемые функции, описание которых помещается в файлы
библиотек импорта LIB – Import Library File, которые также подключаются
на этапе компоновки. Динамически загружаемые модули в процессе работы
при необходимости можно выгружать из памяти, освобождая при этом
ресурсы. В ряде режимов возможна работа таких приложений и без них. Дополнительные
библиотеки импорта здесь не используются.
Библиотека DLL создается командой File .New из шаблона DLLWizard.
В состав проекта автоматически включаются файл проекта (например,
myDLL.BPR) и файл модуля DLL (myDLL.CPP) без формы, которые следует
дополнить файлом заголовка (myDLL.H) и при необходимости – файлами
требуемых форм. Пример файла модуля, формирующего произвольное сообщение
авторской функцией Message и открывающего форму О программе
другой функцией About:
//myDLL.CPP
#include "myDLL.h"
int WINAPI DllEntryPoint (HINSTANCE hinst,
unsigned long reason, void* lpReserved) { return 1; }
void Message (char *s) { ShowMessage ((AnsiString) s + " из DLL"); }
void About (char *s) {
Form1 = new TForm1 (0); Form1->Label1->Caption = (AnsiString) s + " из
DLL";
Form1->ShowModal (); delete Form1;
}
Функция DllEntryPoint является главной функцией DLL. Функции Message и
About здесь служат примерами библиотечных функций, которые будут подключаться
к приложению с выводом передаваемой оттуда строки. Объявление
этих функций как функций экспорта следует поместить в файл заголовка:
extern "C" void __declspec (dllexport) Message (char *s);
extern "C" void __declspec (dllexport) About (char *s);

62
Лексема __declspec со спецификатором класса памяти dllexport гарантирует
совместимость библиотеки с Microsoft C/C++. После компоновки проекта будет
создан файл библиотеки (.LIB) и исполняемый файл (.DLL).
Для статического подключения DLL к имеющемуся проекту надо добавить
в него файл .LIB (Project .Add to Project) из проекта DLL и включить
файл заголовка из DLL. После компоновки можно обращаться к хранящимся
там данным. Например:
//myApplication.cpp
#include "myDLL.h"
void __fastcall TForm1::Button1Click (TObject *Sender) { Message ("Привет "); }
void __fastcall TForm1::Button2Click (TObject *Sender) { About ("Привет "); }
Динамическое подключение выполняется иначе:
void __fastcall TForm1::Button1Click (TObject *Sender) {
HINSTANCE dllp = LoadLibrary ("myDLL.dll");
if (dllp) {
void (__stdcall *p) (char *s);
p = (void (__stdcall *) (char*)) GetProcAddress (dllp,"_Message");
if (p) p ("Привет ");
else ShowMessage ("Нет функции DLL");
FreeLibrary (dllp);
}
else ShowMessage ("Нет файла DLL");
}
Функция LoadLibrary возвращает тип HINSTANCE из библиотеки Windows
API и загружает модуль DLL, либо NULL при его отсутствии. GetProcAddress
присваивает значение указателя функции DLL. Затем вызывается рабочая
функция, а библиотека DLL выгружается из памяти функцией FreeLibrary.
Аналогичным образом экспортируются целые классы DLL.
Пакеты BPL создаются на базе шаблона Package. При проектировании
пакета используются файлы со следующими расширениями:
.BPK – исходный файл параметров проекта в формате XML;
.BPL – runtime-пакет, представляющий разновидность .DLL со специальными
функциями C++Builder;
.BPI – библиотека импорта пакета;
.CPP – файл исходного текста с главной функцией проекта DllEntry-
Point;
.H – файл заголовка;

63
.LIB – статическая библиотека (коллекция файлов OBJ) для подключения
в режиме design time, если установлен параметр компиляции GI (Generate
LIB file);
.OBJ – двоичный образ модуля пакета.
Для динамического подключения пакетов вызывающее приложение
следует оснащать функциями LoadPackage и FreePackage вместо LoadLibrary
и FreeLibrary.
Ресурсы
Ресурсы создаются графическим редактором Image Editor и там же
включаются в файл ресурсов .RES приложения как Bitmaps, Cursors и Icons.
Для работы с обновленным файлом ресурсов следует закрыть приложение,
затем вновь открыть и перестроить его. Пример:
const Tcursor myCursor = 5;
void __fastcall TForm1::FormCreate (TObject *Sender) {
Screen->Cursor[myCursor] = LoadCursor (HInstance “имяРесурсаКурсора”);
Cursor = myCursor;
Icon->Handle = LoadIcon (HInstance, “имяРесурсаЗначка”);
}
Приложения баз данных
«У памяти хороший вкус»
Французское изречение
Технологии создания приложений баз данных
C++Builder создавать эффективные СУБД – системы управления базами
данных (DBMS). Для поддержки таких приложений разработаны различные
технологии, приведенные в табл. 14.
Таблица 15.
Варианты архитектур приложений баз данных
Технология
ADO
BDE
dbExpress
Область применения
Все базы данных, поддерживающие стандарт OLE DB
Реляционные базы данных xBase, Paradox, InterBase
Различные базы данных
Универсальная технология ADO – ActiveX Database Objects – разработана
в Microsoft в соответствии со стандартом OLE DB (Object Linking and
Embedding of DataBases). Она является развитием ODBC (Open DataBase

64
Connectivity) – открытой двухуровневой системы подключения баз данных,
ставшей стандартом для большинства приложений. Верхний уровень (клиент
ODBC) играет роль интерфейса с приложением и поддерживает стандартные
функции API. Нижний уровень выполняет функции специализированного
драйвера преобразования информации в соответствии с форматом конкретной
СУБД (сервера ODBC). Средства поддержки ADO строятся как модели
составных объектов COM (Component Object Model). Технология ориентирована
на Интернет (HTTP, InternetExpress, FastNet) и сети, работающие под
Windows, при взаимодействии с любыми СУБД, оснащенными драйверами
ODBC. Кроме того, ADO предлагает разработчикам поддержку данных, хранящихся
в не реляционном формате, например XML или сообщений электронной
почты. Специальные версии ADO относятся к категории распределенных
(многоуровневых) архитектур. В них программы разделяются на секции,
взаимодействующие на основе разнообразных протоколов. Это CORBA
для построения масштабируемых приложений, не зависящих от платформ;
DCOM для реализации удаленного доступа; MIDAS для обслуживания приложений
клиент/сервер.
Базовая одноуровневая технология BDE – Borland Database Engine поддерживает
форматы баз данных группы xBase, такие как dBase, FoxPro, Clipper,
а также Paradox, текстовый формат с разделителями (ASCII-Delimited
Text) и стандарт ODBC. Реализованная в виде набора системных файлов
DLL, технология BDE удовлетворяет небольшим дешевым производительным
приложениям. Для работы с корпоративными базами данных Oracle,
SQL Server, DB2, InterBase между BDE и базой данных может быть помещен
дополнительный уровень SQL Links – Structured Query Language Links. Архитектура
BDE/SQL Links реализует более производительный сетевой обмен по
технологии клиент/сервер. Выражения на языке SQL, непосредственно внедренные
в программный код, позволяют манипулировать данными через
BDE, обеспечивая наивысшую производительность, хотя при этом игнорируются
визуальные компоненты и связанные с ними преимущества быстрой
разработки приложений.
Специализированные технологии dbExpress предусматривают высокоскоростное
подключение к каждому конкретному типу базы данных с учетом
особенностей операционной среды. Компромиссным решением служит подключение
к ODBC через специализированные компоненты, поставляемые
сторонними производителями под API конкретных СУБД. Популярен и вариант
API СУБД без использования технологии визуальной разработки. Он
применяется в простых базах данных и поддерживается их разработчиками
самостоятельно за счет средств доступа к данным самой СУБД.
Обычно для построения приложений баз данных используется организация,
состоящая из нескольких своеобразных программных «слоев» (рис.
2,а):

65
• интерфейс пользователя (user interface);
• компоненты связи интерфейса пользователя с наборами данных,
именуемые источниками данных (data sources);
• наборы данных (datasets), представляющие записи таблиц и запросов
баз данных;
• средства подключения к базам данных (data connections).
Интерфейс пользователя строится на базе традиционных форм. Источники
данных связывают интерфейс пользователя с наборами данных. При
этом несколько элементов управления интерфейса можно подключать к одному
источнику данных для синхронной обработки одной и той же информации.
Основу приложений составляют наборы данных, представляющие даталогические
модели одной или нескольких таблиц или запросов и отражающие
состояние и изменение физических данных носителя информации. Каждой
таблице или запросу ставится в соответствие свой набор данных.
Архитектуры приложений баз данных
Наборы данных различных типов используют разнообразные механизмы
подключения к данным, которые, в свою очередь, определяют архитектуру
приложений баз данных. К основным способам подключения относятся:
Программа
Программа
Application server
Интерфейс
(User interface)
Источник данных
(Data source)
Набор данных
(Dataset)
Подключение
(Data connection)
Данные
Интерфейс
пользователя
Источник данных
клиента
Набор данных
клиента
Подключение
к серверу
Client
Источник сервера
(Provider)
Целевой
набор данных
(Unidirectional
data source)
SQL-соединение
(SQL connection)
Сервер базы данных
(Database server)
а. б.
Рис. 2. Варианты организации приложений баз данных

66
• прямое подключение;
• подключение через вспомогательный набор данных;
• архитектура «клиент-сервер».
В C++Builder все подключения по технологии ADO производятся через
компонент TADOConnection вкладки ADO панели визуальных компонентов,
источниками данных служат компоненты TADOTable, TADOQuery, TADOStoredProc,
TADODataSet, TADOCommand вкладки ADO, а наборы данных
обычно представляются компонентом TDataSource вкладки Data Access.
Подключения по технологии BDE выполняются через компонент
TDataBase без наборов данных или с TDataSource, а роль источников данных
здесь играют компоненты TTable, TQuery, TStoredProc вкладки BDE панели
визуальных компонентов. Для работы с корпоративными базами данных
InterBase служат компоненты TIBDataBase, TIBTable, TIBQuery, TIB-
StoredProc вкладки InterBase.
Технологии dbExpress для подключения используют компонент
TSQLConnection, источниками данных являются TSQLTable, TSQLQuery,
TSQLStoredProc вкладки dbExpress, а наборы данных представляет
TSQLDataSet.
Прямое подключение обычно используется для организации постоянных
соединений, которые устанавливаются в начале сеанса связи с базой
данных и разрываются в конце сеанса. Такое подключение просто реализуется,
но работает только в однопользовательских системах без разграничения
прав доступа. Технологиями BDE и dbExpress поддерживается подключение
через вспомогательные наборы данных TBDEClientDataSet, TIBClientDataSet,
TSQLClientDataSet.
Архитектура «клиент-сервер» применяется в приложениях, где данные
распределены по нескольким таблицам или нескольким корпоративным и
локальным базам данных, в системах с несколькими клиентами, требующих
организации совместного доступа и коллективной защиты. Схема организации
таких приложений показана на рис. 2,б. В отличие от предыдущих архитектур,
для подключения здесь привлекается источник данных сервера – провайдер,
к которому обращается клиент для получения или передачи данных.
Приложение-сервер может предоставлять запрошенные данные или отказывать
в сервисе в зависимости от принятой стратегии управления и ситуации в
сети.
Подключение к базам данных
Хорошим стилем программирования считается отделение интерфейса
пользователя от компонентов связи с базой данных. Этим достигается повышенная
гибкость проекта, позволяющая менять средства связи независимо от
интерфейса или усовершенствовать интерфейс без изменения подключений.
Инструментом такого разделения в C++Builder служат модули данных Data

67
Module из Object Repository. Это специальный тип формы, применяемый в
качестве хранилища невидимых компонентов, в первую очередь – компонентов
баз данных. Как и формы, каждый модуль данных строится с использованием
файла заголовков (.H), файла кода (.CPP) и файла структуры модуля
(.DFM).
Окно модуля данных удобно применять вместе с вкладкой Diagram и с
окном Object TreeView, так как модуль данных отражает компоненты, а
вкладка Diagram – их иерархическую структуру. При проектировании компоненты
можно помещать прямо в модуль данных или на ветви Object Tree-
View, в результате чего они становятся дочерними компонентами того объекта,
на который помещаются. До завершения привязки объекты Object Tree-
View помечаются вопросительными знаками.
В частности, для подключения базы данных через вспомогательный
набор данных по технологии ADO в модуль данных помещается объект
ADOConnection с вкладки ADO. Его редактор свойства ConnectionString
предлагает сформировать строку подключения (или использовать файл
.UDL). Для формирования такой строки (под кнопкой Build) при подключении
к персональным базам данных Microsoft можно выбрать провайдер Microsoft
Jet… На вкладке Connection этого же окна в поле Select or enter a database
name указывается подключаемая база данных. Кнопкой Test Connection
проверяется подключение. В сформированной таким образом строке
подключения указано имя провайдера, имя и пароль пользователя и папка с
базой данных. В большинстве случаев свойство LoginPrompt объекта
ADOConnection устанавливается в false для открытия базы данных без пароля.
Связь приложения с базой данных в архитектуре «клиент-сервер» выполняется
с помощью источников данных, работающих через драйверы
ODBC. С описанием таких источников в формате DSN (Data Source Notification)
можно ознакомиться, если открыть Администратор источников данных
ODBC в папке Панель управления Windows. Вкладки этой программы посвящены
трем категориям источников: Пользовательский DSN единственного
пользователя одного компьютера; Системный DSN всех пользователей
компьютера; Файловый DSN, доступный всем пользователям сети, имеющих
одинаковые драйверы, независимо от компьютера. На отдельной вкладке
представлены установленные на компьютере драйверы ODBC. Для работы с
конкретной базой данных обычно подключают имеющийся или создают новый
источник данных, используя соответствующий драйвер. Этот источник
впоследствии распространяют в комплекте с приложением и базой данных.
Поэтому для формирования строки подключения под кнопкой Build
обычно выбирается Microsoft OLE DB Provider for ODBC Drivers, служащий
универсальным механизмом доступа к продуктам Microsoft. На вкладке Connection
этого же окна в поле переключателя Use connection string под кнопкой
Build выбирается источник данных. Если требуемый источник данных

68
отсутствует и его следует создать, в поле DSN Name под кнопкой New указывается
одна из строк:
• Microsoft Access Driver, обслуживающая Access;
• Microsoft dBase Driver для работы с базами xBase;
• Microsoft Excel Driver для работы с таблицами Excel;
• Microsoft Text Driver для подключения текстовых таблиц;
• SQL Server для обращения к корпоративной базе данных
и вводится произвольное имя нового источника. В следующем окне ODBC
Microsoft Access Setup базу данных можно выбрать под кнопкой Select, либо
создать новую под кнопкой Create, задав ее имя. В последнем случае должно
поступить сообщение об успешном создании базы данных. Выделив найденный
или созданный источник и вернувшись на вкладку Connection, остается
убедиться в его работоспособности кнопкой Test Connection.
А вот пример программного подключения, выполняемого в конструкторе
модуля данных:
__fastcall TDataModule1::TDataModule1 (TComponent* Owner)
: TDataModule (Owner) {
AnsiString s = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=\
bRobots.mdb;Persist Security Info=False";
try {
ADOConnection1->Connected = false;
ADOConnection1->ConnectionString = s;
ADOConnection1->Connected = true;
} catch (...) { ShowMessage ("Нет подключения к bRobots.mdb"); }
}
Фиксированную строку подключения можно заменить окном диалога:
AnsiString s = PromptDataSource(0, "");
Доступ к записям
Доступ к записям баз данных реализуется через таблицы, запросы и
хранимые процедуры.
Для работы с таблицами с помощью компонента ADOTable вкладки
ADO в модуль данных добавляются элементы управления доступом к каждой
таблице. Их свойство Connection инициализируется именем объекта
ADOConnection, а в свойство TableName вписываются имена соответствующих
таблиц. Каждый элемент управления ADOTable аккумулирует все записи
и поля своей таблицы.

69
Для подключения к форме с помощью компонента DataSource вкладки
Data Access панели компонентов в модуль данных добавляется источник
данных для каждой таблицы. В их свойстве DataSet указываются имена соответствующих
компонентов ADOTable. Свойство AutoEdit разрешает режим
редактирования записей, вводимых в поля наборов данных.
После подключения в модуле данных устанавливается в true свойство
Active элементов доступа к таблицам для их открытия. Аналогично выполняется
открытие таблиц из программы, например:
ADOTable1->TableName = "Countries";
ADOTable1->Active = true;
Следующий пример демонстрирует подключение к файлу MYDBF.DSN
с открытием таблицы T.
void __fastcall TDBForm1::ConnectClick (TObject *Sender) {
AnsiString s = "Extended Properties=\"FILEDSN=myDBF.dsn;\";";
TADOConnection *cnn = DataModule1->ADOConnectionDBF;
TADOTable *rst = DataModule1->ADOTableDBF;
try {
cnn->Connected = false;
cnn->ConnectionString = s;
cnn->Connected = true;
rst->TableName = "T";
rst->Active = true;
} catch (...) {
s = PromptDataSource(0, "");
try {
cnn->Connected = false;
cnn->ConnectionString = s;
cnn->Connected = true;
rst->TableName = "T";
rst->Active = true;
} catch (...) { ShowMessage (s); }
}
}
Возможно подключение и при отсутствии файла .DSN, в том числе – и
без использования объектов ADOConnection, если известны все необходимые
параметры командной строки. Еще один пример посвящен открытию доступа
к таблице dBase и к листу Excel:
void __fastcall TDBForm1::DBFConnectClick (TObject *Sender) {
AnsiString s = "Provider=MSDASQL.1;\

Extended Properties=\"DBQ=D:\\DATABASES;\
Driver={Microsoft dBase Driver (*.dbf)};DriverId=533;FIL=dBase 5.0;\";";
TADOConnection *cnn = DataModule1->ADOConnectionDBF;
TADOTable *rst = DataModule1->ADOTableDBF;
try {
cnn->Connected = false;
cnn->ConnectionString = s;
cnn->Connected = true;
rst->TableName = "Т";
rst->Active = true;
} catch (...) { ShowMessage (“Увы…”); }
}
void __fastcall TDBForm1::XLSConnectClick (TObject *Sender) {
AnsiString s = "Provider=MSDASQL.1;\
Extended Properties=\"DBQ=D:\\DATABASES\\Сотрудники.xls;\
Driver={Microsoft Excel Driver (*.xls)};DriverId=790;FIL=excel 8.0;\";";
TADOTable *rst = DataModule1->ADOTableXLS;
try {
rst->Active = false;
rst->ConnectionString = s;
rst->TableName = "Лист1";
rst->Active = true;
DBGrid1->DataSource = DataModule1->DataSourceXLS;
} catch (...) { ShowMessage (“Не подключились”); }
}
70
К подключенной базе данных можно обращаться с запросами на выборку,
создание, обновление и удаление таблиц. Для этого на вкладке ADO
присутствует компонент ADOQuery, создающий объекты-запросы. В свойстве
Connection этого компонента указывается имя объекта ADOConnection, а в
редакторе свойства SQL формируется требуемое SQL-выражение. Примеры
запросов на выборку и запросов действия:
select * from Robots where radius > 10;
select model, country, mass*radius*radius as inertia from Robots;
create table Robots (model string (10), country string (10),
coord string (15), radius float, mass float, primary key (model)) ;
create table Countries (country string (10), primary key (country));
insert into Robots values ('Тест', 'Россия', 'Сферическая', 3, 5 );
update Robots set country='Франция' where country='Россия';
delete from Robots where country='Франция';

71
В свойстве SQL одного компонента сохраняется только один запрос.
Поэтому ввод каждой строки запроса надо завершать установкой свойства
Active в true для его проверки и выполнения. При этом C++Builder передает
запрос серверу, который выполняет его и возвращает приложению результирующий
набор (result set). Запросы действия, не возвращающие наборов данных,
можно формировать, также, компонентом TADOCommand. После выполнения
запроса в режиме проектирования или программным путем вводится
следующее выражение SQL и вновь повторяется его активизация. Для
подключения запросов на выборку к форме, в модуль данных добавляются
источники данных DataSource.
Формирование базы данных при необходимости продолжают на вкладке
Diagram модуля данных, где из элементов управления ADOTable собирается
структурная схема базы данных. На вкладке Diagram между ними можно
просматривать и устанавливать связи четырех типов:
• Property от дочернего элемента управления к родителю (сплошная
линия со стрелкой), например, от полей к таблице;
• Master/Detail от главной таблицы (master) к подчиненной (detail) (линия,
на которой главная таблица помечена большим прямоугольником,
а подчиненная – маленьким прямоугольником и указано поле
связи);
• типа Lookup (линия с изображением глаза);
• ссылка Comment Allude (стрелка).
Пользуясь контекстными меню, эти связи удобно удалять и редактировать.
При этом тип Lookup отображает поля подстановки данных из других таблиц,
а Comment Allude подключает комментарии Comment Block к компонентам
структуры.
Чтобы связать между собой две таблицы, следует при нажатой кнопке
Master/Detail провести линию от главной таблицы к подчиненной, и в открывшемся
окне указать имена зависимых полей и нажать кнопку Add. В результате
автоматически заполнится свойство MasterFields подчиненной таблицы
именем соответствующего поля главной таблицы MasterSource. Эти же
данные можно занести вручную через редакторы названных свойств.
Чтобы создать в неактивной таблице новое поле подстановки, следует в
контекстном редакторе ее ветви Fields окна Object TreeView выбрать New
Field и, установив переключатель Lookup, задать имя, тип и размер поля,
ключи (Key), источник (Dataset) и поле подстановки (Result Field).
Инструменты Comment Allude и Comment Block помогают оформить
схему базы данных, а контекстное меню Print готовит ее к печати.
Подготовленный модуль данных сохраняется, и в редакторе форм подключается
к модулю формы (File .Include Unit Hdr). В форму помещаются
элементы управления данными с вкладки Data Controls панели компонентов.
Это таблицы DBGrid и навигаторы DBNavigator, а также поля таблиц DBText,

72
DBEdit, DBMemo, DBImage и другие. Компоненты вкладки Data Controls отличаются
от рассмотренных ранее компонентов вкладки Standard наличием
свойств DataSource и DataField, обеспечивающих их совместную работу с
источниками данных. В свойстве DataSource указываются соответствующие
объекты модуля данных, а в DataField –поля таблиц и запросов. Здесь также
возможна подстановка (свойство столбца PickList), но не из таблицы, а из
фиксированного списка значений.
Объектно-ориентированное программирование
«Что посеешь, то и пожнешь»
Русская пословица
Инкапсуляция
Создание авторских классов начинается с их объявления в файле заголовка
модуля. После объявления или одновременно с ним класс определяется
(описывается). Встроенное объявление и определение членов выполняется в
формате обычных переменных и функций:
class имяКласса {
[Метка]
[объявлениеЧленов…]
[встроенноеОпределениеЧленов…] };
Если не дается встроенное определение, в файле кода модуля приводится
внешнее определение членов:
Тип имяКласса :: имяЧлен-данного [ =Значение];
Тип имяКласса :: имяЧлен-функции телоЧлен-функции
Использование внешних определений повышает наглядность текста программы
и облегчает его последующую модификацию. Члены класса могут
принадлежать к другим классам, и их именуют в этом случае вложенными
классами. Глубина вложенности не ограничивается, хотя «большое число
уровней абстракции так же плохо, как и их отсутствие [Голуб]».
После объявления и определения создаются объекты класса. Каждый
класс может использоваться для порождения множества объектов:
имяКласса имяОбъекта;
имяКласса *имяОбъекта = new имяКласса;

73
Инициализация и обращение к членам класса выполняются по разнообразным
схемам. Обращение к членам своего класса производится по именам,
без указания имени объекта:
имяЧлена [= Значение];
При этом адресация выполняется с помощью неявного аргумента this. Так
как this – адрес, то конструкция this->имяЧлена является указателем на объект,
а *this представляет сам объект:
this->имяЧлена [= Значение];
(*this).имяЧлена [= Значение];
При обращении к членам других классов следует указывать имя объекта:
имяОбъекта.имяЧлена [= Значение];
ссылкаНаОбъект->имяЧлена [= Значение];
Пусть, например, требуется периодически выводить информацию о
компьютерах из различных функций некоторой программы. Чтобы не делать
это в каждой функции, в проекте удобно создать новый модуль (File .New
.Unit), и в его файле заголовка поместить объявление класса VPC, получающего
сведения через функцию Set и представляющего их функцией Out, как
это показано в следующем примере:
class VPC {
private:
int type;
AnsiString firm;
public:
double price;
void Set (int a, AnsiString b) { type = a; firm = b; }
void Out () {
ShowMessage ("Пpоцессор фирмы " + firm + " стоит $" + price);
}
};
Для создания объектов класса в других формах, в их файлах кода размещаются
ссылки на файл заголовка класса VPC. Ниже приведен пример функции
MainVPC, «воспользовавшейся услугами» класса VPC для обработки объекта
myCPU, и таких функций может быть множество:
void MainVPC () {
AnsiString company = "Acer";
VPC myCPU;

74
myCPU.Set (6, company); myCPU.price = 100; myCPU.Out ();
}
Другой пример посвящен классу VIntegral, реализующему численное
интегрирование тремя методами: методом прямоугольников, методом трапеций
и методом парабол. Класс объявлен в файле заголовка модуля, его членфункции
Rect, Trap, Para определены в файле кода модуля, а объекты созданы
функцией MainVIntegral в файле кода формы:
class VIntegral {
double j, x, sum, sum1, f;
public:
void Rect (double, double, double, double (*fnc) (double, double));
void Trap (double, double, double, double (*fnc) (double, double));
void Para (double, double, double, double (*fnc) (double, double));
};
void VIntegral :: Rect (double xk, double h, double f,
double (*fnc) (double x, double y))
{ for (x=0, sum=0; x

}
i.Rect (xk, h, f, pow);
i.Trap (xk, h, f, pow);
i.Para (xk, h, f, pow);
75
Пример реализации и использования класса дека:
class VDeque {
VDeque *next, *pre;
char info[40];
public:
void Add (char *ptr);
void AddNode ();
void Out ();
};
VDeque *head;
void VDeque :: Add (char *ptr) {
int max = strlen (ptr); for (int i=0; ipre = this; pre = 0; }
}
void VDeque :: Out () {
AnsiString result;
VDeque *cursor = head;
while (cursor != this) { result += AnsiString (cursor->info) +'\t'; cursor = cursor-
>next; }
ShowMessage (AnsiString (cursor->info));
}
void MainVDeque () {
VDeque a, b, c, d;
a.Add ("IBM"); a.AddNode (); b.Add ("Siemens"); b.AddNode ();
c.Add ("Motorola"); c.AddNode (); d.Add ("Apple"); d.AddNode (); b.Out ();
}
Конструкторы и деструкторы
Для автоматической инициализации объектов класса используются
конструкторы – бестиповые, одноименные с классом член-функции:

76
class VMicroPC {
AnsiString type; int price;
public:
VMicroPC (AnsiString a, int b) { type = a; price = b; } // конструктор
void Out () { ShowMessage ("Компьютер " + type + " стоит $" + price); }
};
void MainVMicroPC() {
AnsiString comp1 = "IBM", comp2 = "Macintosh";
VMicroPC myCPU (comp1, 990), yourCPU (comp2, 1500);
myCPU.Out(); yourCPU.Out();
}
Конструктор вызывается не только при определении нового объекта
класса для объявления данных, но и при копировании объекта или при динамическом
выделении памяти новому объекту. В качестве аргументов копирующего
конструктора (copying constructor) используются ссылки на копируемые
объекты. Примером может служить конструктор типизированного
класса AnsiString:
struct computer { AnsiString name; int price; };
class VList {
computer *p;
int i, max, current;
public:
VList (int);
void Add (computer *);
void Delete (computer *);
AnsiString Out ();
};
VList::VList (int max) { VList::max = max; current = 0; p = new computer[max]; }
void VList::Add (computer *v) {
if (current < max) {
p[current].name = v->name;
p[current++].price = v->price;
}
}
void VList::Delete (computer *v) {
for (i=0; iname) {

}
}
while (i < current-1) {
p[i].name = p[i+1].name;
p[i].price = p[i+1].price;
i++;
}
--current;
}
77
AnsiString VList::Out () {
AnsiString result;
for (i=0; i

AnsiString temp;
float m[3][3], k;
public:
VMatrix (float a[][3], float c = 1);
void Out ();
};
78
VMatrix::VMatrix (float a[][3], float c): k(c) {
for (i=0; i

};
79
void Out () { ShowMessage (AnsiString (first) + '\n' + AnsiString (second)); }
void MainVPair () {
{ VPair num (2,3); // объект создан
num.Out (); // 2-3
} // объект удален
{ VPair num (4,5); // объект создан
num.Out (); // 4-5
} // объект удален
}
За освобождением памяти можно наблюдать и без деструктора. В приведенной
ниже реализации объектов str, поочередно помещаемых в стек и
очередь, деструктора нет:
class VStackAndQueue {
char *s;
int i, size, top;
AnsiString result;
public:
VStackAndQueue (AnsiString str);
void Push (AnsiString str);
void PopStack ();
void PopQueue ();
int Empty () { return top == -1; }
int Full () { return top == size; }
};
VStackAndQueue::VStackAndQueue (AnsiString str) {
size = str.Length (); s = new char[size]; top = -1; result = str + ":\n";
}
void VStackAndQueue::Push (AnsiString str) {
for (i = 1; i

void MainVStackAndQueue () {
{ AnsiString str = "Проверка стека";
VStackAndQueue test (str); test.Push (str); test.PopStack ();
}
{ AnsiString str = "Проверка очереди";
VStackAndQueue test (str); test.Push (str); test.PopQueue ();
}
}
80
Дружественные функции и классы
Иногда требуется разрешить доступ к закрытым членам класса со стороны
функций, не относящихся к членам класса. Такие функции объявляются
дружественными (friend) рассматриваемому классу. Объявление дружественной
функции помещается в public-, либо в private-раздел объявления
класса, которому она дружественна. Метки public, private не влияют на описание
friend.
class VFriendPC {
int num;
public:
VFriendPC (int b): num (b) {}
friend void Show (VFriendPC x);
};
void Show (VFriendPC x) { ShowMessage (AnsiString ( x.num )); }
void MainVFriendPC () { VFriendPC price (900); Show (price); }
В приведенном примере Show объявлена функцией, дружественной классу
VFriendPC, поэтому она свободно обрабатывает закрытую переменную num
этого класса.
Особенно полезными аспектами механизма дружественных функций
является то, что функция может быть дружественной по отношению к нескольким
классам, член-функция одного класса может быть дружественной
другому классу и, напротив, сразу группа функций или целый класс могут
быть дружественными рассматриваемому классу:
class VTwo;
class VOne {
friend void Out (VOne &c1, VTwo &c2);
private:
char *s1;
public:
VOne () { s1 = "Проверка: ";}

};
81
class VTwo {
friend void Out (VOne &c1, VTwo &c2);
private:
char *s2;
public:
VTwo () { s2 = "Sony, Siemens, Fuji"; }
};
void Out (VOne &c1, VTwo &c2) {
ShowMessage (AnsiString ( c1.s1) + AnsiString (c2.s2));
}
void MainVOneVTwo () {
VOne c1; VTwo c2; Out (c1, c2);
}
// Проверка: Sony, Siemens, Fuji
Если все функции одного класса дружественны второму классу, то говорят
о дружественном классе (friend class):
class VFirst;
class VSecond {
AnsiString model, firm;
public:
VSecond (AnsiString a, AnsiString b): model (a), firm (b) {}
friend class VFirst;
};
class VFirst {
VSecond set;
public:
VFirst (AnsiString a, AnsiString b): set (a,b) {}
void Model () { ShowMessage (AnsiString (set.VSecond::model)); }
void Firm () { ShowMessage (AnsiString (set.VSecond::firm)); }
};
void MainVFirstVSecond () {
AnsiString mod = "ATT", frm = "IBM";
VFirst device (mod, frm);
device.Model ();
// AT
device.Firm ();
// IBM
}

82
Используя дружественные функции, следует помнить, что «подобно
оператору goto, друзья снижают надежность программного кода... Потребность
в объявлении одних классов друзьями других свидетельствует о плохо
продуманной иерархии классов» [Сван]. Поэтому обращаться к помощи друзей
следует лишь при крайней необходимости.
Полиморфизм
Полиморфизм как способность одинаковых операторов и одноименных
функций к избирательному (зависящему от типа) поведению реализуется в
C++ в первую очередь через механизмы перегрузки (overloading) операторов
и функций.
Суть перегрузки операторов заключается в создании функцииоператора,
использующей в качестве имени лексему operator и следующим за
ней перегружаемый оператор. Объявление перегрузки аналогично объявлению
обычной дружественной функции или член-функции класса:
Тип operator знакОперации ( [объявлениеПараметров] );
Перегрузке могут подлежать все простые операторы, за исключением «.»,
«.*», «?:», «sizeof», «::». Язык не позволяет задать для перегружаемого оператора
иной символ, кроме тех, что определены в списке операторов. Нельзя
изменять синтаксис использования оператора: унарный оператор не перегружается
в бинарный, префиксный – в постфиксный и т.п. Операторы «+»,
«-», «*», «&» могут быть как бинарными, так и унарными.
Перегружаются только опеpатоpы в операциях, для которых по крайней
мере один из параметров является членом структуры или класса. С учетом
неявного указателя this, при выполнении одноместных операций аргумент
может опускаться, а в двухместных операциях допустимо оставлять
один аргумент.
Для знакомства с перегрузкой одноместных операторов рассмотрим
одну из распространенных задач программирования – вывод текущего времени
на экран. На основании показаний системных часов компьютера такая
программа формирует на экране время в днях, часах и минутах. Чтобы в каждом
такте часов не пересчитывать время заново, здесь переопределен оператор
инкремента, что позволяет использовать не абсолютный, а относительный
отсчет времени:
class VClock {
private:
__int64 total, secs, mins, hours, days;
public:
VClock (__int64 i);
void Out ();

};
VClock operator++ ();
83
VClock::VClock (__int64 i) {
total = i; secs = total % 60; mins = (total / 60) % 60;
hours = (total / 3600) % 24; days = total / 86400L;
}
void VClock::Out () {
ShowMessage (AnsiString (total) + " сек.= "
+ AnsiString (days) + " дн. " + AnsiString (hours) + " час. "
+ AnsiString (mins) + " мин. " + AnsiString (secs) + " сек. ");
}
VClock VClock::operator++ () {
VClock temp (++total);
secs = temp.secs; mins = temp.mins; hours = temp.hours;
days = temp.days; return *this;
}
void MainVClock () {
VClock t1 (59), t2 (172799L);
}
ShowMessage ("Старое время:");
t1.Out ();
// 0 дн. 0 час. 0 мин. 59 сек.
t2.Out ();
// 1 дн. 23 час. 59 мин. 59 сек.
++t1; ++t2;
ShowMessage ("Новое время:");
t1.Out ();
// 0 дн. 0 час. 1 мин. 0 сек.
t2.Out ();
// 2 дн. 0 час. 0 мин. 0 сек.
Следующий пример посвящен операции транспонирования матрицы
M[3][3], представленной элементом управления StringGrid1, для выполнения
которой перегружается оператор «!»:
class VMatr {
int i, j;
double temp;
double M[3][3];
public:
VMatr ();
void Out ();
VMatr operator ! ();
};

VMatr::VMatr () {
for (i=0; iCells [i][j] );
}
void VMatr::Out () {
for (i=0; iCells[i][j] = M[i][j];
}
VMatr VMatr::operator! () {
for (i=0; i

85
class VMatrixPlus {
int i, j; double k, m[3][3];
public:
double n[3][3];
VMatrixPlus (double a[][3]);
VMatrixPlus (double c): k (c) {}
VMatrixPlus operator ! ();
VMatrixPlus operator + (VMatrixPlus c);
void Out ();
};
VMatrixPlus::VMatrixPlus (double a[][3]) {
for (i=0; i

86
В теле определяемой функции один или несколько параметров используют
типы, специфицированные в списке параметров шаблона. В качестве примера
обратимся к сортировке членов структуры методом «пузырька». Чтобы
дважды не использовать в этой программе процедуру обмена значений двух
переменных, разработана функция-шаблон, в которой тип параметра самостоятельно подбирается компилятором:
template void Swap (T &a, T &b) { T buf; buf=b; b=a; a=buf; }
void MainSwap () {
const N = 3;
struct metallHeat { AnsiString name; int heat; };
metallHeat m[N];
m[0].name = "cuprum"; m[0].heat = 139; m[1].name = "aluminium";
m[1].heat = 386; m[2].name = "ferrum"; m[2].heat = 234; int i, j, criteria;
criteria = MessageDlg ("Сортировка по name?", mtConfirmation,
TMsgDlgButtons ()

87
void MainSort () {
int i, weight[] = {10, 20, 5, 60, 15};
AnsiString result;
int len = sizeof (weight) / sizeof (weight[0]);
}
Sort (weight, len);
for (i=0; i», используемый
при сравнении элементов массива.
class VPrice {
__int64 dollars;
int cents;
public:
VPrice (__int64 myDollars=0, int myCents=0):
dollars (myDollars), cents (myCents) {}
int operator > (const VPrice);
friend AnsiString &operator (const VPrice amount) {
return (dollars > amount.dollars) ||
(dollars == amount.dollars && cents > amount.cents);
}
AnsiString &operator

88
Для создания обобщенного определения семейства классов используются
шаблоны классов. «Подобно тому, как класс представляет собой схему
строения объекта, так и шаблон представляет схему функции или класса»
[Сван]. Шаблон определяет член-данные и член-функции класса, на основании
которых компилятор впоследствии cможет сгенерировать новый класс
для конкретного типа. Иногда шаблон называют параметризованным типом,
указывающим лишь спецификации для функций и классов, но не детали реализации.
Шаблонная функция начинается строкой template , где вместо
T пользователь будет впоследствии подставлять конкретное имя функции
или класса. Можно задавать указатель T *param или ссылку T &param.
Функция может обновлять несколько параметров и возвращать значение типа
T. Hапpимеp, template T F(int a, Tb) – шаблонная функция F возвращает
значение типа T и имеет в качестве параметров целое с именем a и
неопределенный объект T с именем b. В дальнейшем это может оказаться,
например, выражением double F(int a, double b). Возможно и такое объявление:
template T1 F(T1 a, T2 b). Здесь функция F будет
возвращать значение типа T1, и ей нужны два параметра типов T1, T2.
Рассмотрим работу шаблона класса для простых стековых операций:
const MAX = 10;
template class VStack {
int num;
T *items;
public:
VStack (int size = MAX) { num = 0, items = new T[size]; }
~VStack () { delete [] items; }
void Push (T t) { items[num++] = t; }
T Pop () { return items[--num]; }
};
void MainVStack () {
VStack StackInt (10);
StackInt.Push (33); StackInt.Push (44); StackInt.Push (55);
ShowMessage ("В стеке целые числа: " + AnsiString (StackInt.Pop()) + ',' +
AnsiString (StackInt.Pop()) + ',' + AnsiString (StackInt.Pop()));
VStack StackDouble (10);
StackDouble.Push (33.3); StackDouble.Push (44.2);
StackDouble.Push (-55.1);
ShowMessage ("В стеке вещественные числа: " +

}
И еще один шаблон класса. Он работает с массивами произвольных типов:
89
AnsiString (StackDouble.Pop ()) + ',' +
AnsiString (StackDouble.Pop ()) + ',' + AnsiString (StackDouble.Pop ()));
template class VVector {
T *elem;
// тип и число элементов
public:
VVector ();
T &operator[] (int i) { return elem[i]; }
void Out ();
};
template VVector :: VVector () {
elem = new T[size]; for (int i=0; i

90
держивающие итерацию. Итераторы бывают прямыми и обратными, константными
и неконстантными, изменяющими содержимое контейнера. Низкоуровневые
функции распределения памяти контейнеров называют аллокаторами.
С их помощью все члены STL автоматически выделяют и освобождают
память, не нуждаясь в операторах new и delete. Для манипулирования
данными в контейнерах служат алгоритмы. Обычно на них возлагаются
стандартные операции сортировки, поиска, сравнения, перестановки и т.п.
Контейнер vector, описанный в файле заголовка является динамическим
массивом переменного размера. Подобно стеку, он обеспечивает
добавление объектов в конец функцией push_back и удаление их оттуда
функцией pop_back. Кроме того, в нем реализована вставка объектов в произвольное
место функцией insert и удаление их оттуда функцией erase.
Функция clear удаляет из контейнера все объекты, а функция size возвращает
число объектов в контейнере. Функция empty сообщает, пуст ли контейнер,
reserve резервирует память для будущих объектов, а capacity возвращает текущий
объем выделенной памяти.
#include
using namespace std;
void __fastcall TForm1::VectorClick (TObject *Sender) {
vector n;
vector::iterator j;
vector::reverse_iterator rj;
ListBox1->Items->Add (n.size ());
ListBox1->Items->Add (n.capacity ()); // 0 0
for (int i=0; iItems->Add (n.size ());
ListBox1->Items->Add (n.capacity ()); // 10 16
for (j = n.begin (); j!=n.end (); ++j) ListBox2->Items->Add (*j); // 0,1,...,9
for (rj = n.rbegin (); rj!=n.rend (); ++rj) ListBox3->Items->Add (*rj); // 9,8,...,0
n.erase (n.begin ()+5, n.begin ()+7);
// удаление 5-6-го
n.insert (n.end ()-2, -1);
// вставка –1 3-м с конца
n.push_back (10);
// вставка 10 в конец
ListBox1->Items->Add (n.size ());
ListBox1->Items->Add (n.capacity()); // 10 16
for (j=n.begin (); j!=n.end (); ++j) ListBox4->Items->Add (*j);
// 0,1,2,3,4,7,-1,8,9,10
n.clear ();
}
Контейнер deque из одноименного файла заголовка, в отличие от vector,
может заполняться и освобождаться от объектов с двух сторон.

91
#include
using namespace std;
void __fastcall TForm1::DequeClick (TObject *Sender) {
deque n;
deque::iterator j;
deque::reverse_iterator rj;
for (int i=0; iAdd (*j); // 4,3,2,1,0,5,6,7,8,9
for (rj=n.rbegin (); rj!=n.rend (); ++rj) ListBox2->Items->Add (*rj);
// 9,8,7,6,5,0,1,2,3,4
n.pop_front ();
n.pop_back ();
for (j = n.begin (); j!=n.end (); ++j) ListBox3->Items->Add (*j); // 3,2,1,0,5,6,7,8
n.erase (n.begin ()+5, n.begin ()+7);
// удаление 5-6-го
n.insert (n.end()-2, -1);
// вставка –1 3-м с конца
for (j = n.begin (); j!=n.end (); ++j) ListBox4->Items->Add (*j); // 3,2,1,0,-1,5,8
n.clear ();
}
Контейнер map организован в виде множества упорядоченных пар
(иногда троек). Каждая пара состоит из первого члена (first), являющегося
ключом, и второго члена (second) – значения объекта. Сортировка пар выполняется
автоматически по ключу, хотя возможна и программная сортировка.
#include
#include
using namespace std;
void __fastcall TForm1::MapClick (TObject *Sender) {
map m;
map::iterator j;
double r = 10;
m["pi"] = 3.14159;
m["e"] = 2.718;
m["Скорость света"] = 2.998E8;
m["Площадь круга"] = pow(r, 2) * m["pi"];
for (j=m.begin (); j!=m.end (); ++j)

}
92
ListBox1->Items->Add (j->first + '=' + FloatToStr (j->second));
// e=2.718; pi=3.14159; Площадь круга=314.159; Скорость света=2998...
Алгоритм find выполняет поиск объектов контейнера между двумя установленными
итераторами с возвращением итератора найденного объекта, а
в случае отсутствия такового – с возвращением второго итератора.
#include
#include
using namespace std;
void __fastcall TForm1::findClick (TObject *Sender) {
vector v;
vector::iterator j;
int what = 3;
for (int i=-5; iItems->Add (*j);
j = std::find (v.begin (), v.end (), what);
if (j != v.end ()) ShowMessage ("Нашел " + AnsiString (*j)); // Нашел 3
else ShowMessage ("Не нашел");
}
Алгоритмы min и max отыскивают экстремумы.
#include
using namespace std;
void __fastcall TForm1::minMaxClick (TObject *Sender) {
ListBox1->Items->Add (max (15, 5)); // 15
ListBox1->Items->Add (max ('a', 'b')); // b
ListBox1->Items->Add (min (3.14, 24.5)); // 3,14
}
Алгоритмы random_shuffle и sort соответственно перемешивают и сортируют
объекты контейнера.
#include
#include
#include
using namespace std;
void __fastcall TForm1::sortClick (TObject *Sender) {
vector v;

vector::iterator j;
93
randomize ();
for (int i='a'; iItems->Add (*j);
std::sort (v.begin (), v.end ());
for (j = v.begin (); j!=v.end (); ++j) ListBox2->Items->Add (*j);
std::sort (v.begin (), v.end (), greater ());
// ab...z
for (j = v.begin (); j!=v.end (); ++j) ListBox3->Items->Add (*j); // zy...a
}
Алгоритм binary_search ищет объекты на бинарном дереве.
#include
using namespace std;
void __fastcall TForm1::BinSearchClick (TObject *Sender) {
int i, d[] = { 5, 2, 3, 8, 3, 1, 3 };
const int D = sizeof (d) / sizeof (int);
for (i=0; iItems->Add (d[i]);
std::sort (d, d+D);
for (i=0; iItems->Add (IntToStr (i) +
(binary_search (d, d+D, i) ? " есть" : " нет"));
AnsiString s1[] = {"раз", "два", "четыре", "пять" },
s2[] = { "раз", "три", "пять", "семь"};
const int S1 = sizeof (s1) / sizeof (s1[0]), S2 = sizeof (s2) / sizeof (s2[0]);
for (i=0; iItems->Add (s1[i]);
std::sort (s1, s1+S1);
for (i=0; iItems->Add (s2[i] +
(binary_search (s1, s1+S1, s2[i]) ? " есть" : " нет"));
}
Контейнер set поддерживает уникальные ключи и двунаправленные
итераторы, являясь хранилищем упорядоченных объектов, удобным для поиска
и сравнения с аналогичными хранилищами. Он незаменим для выполнения
классических операций на множествах: принадлежности, объединения,
пересечения, вычитания, дополнения. В отличие от vector и map, контейнер
set не позволяет непосредственно воздействовать на значения объектов, требуя
вместо этого вставки измененных объектов извне. В следующем примере
множество s1 заполняется числами, и эти же числа копируются в s2. Затем
отыскивается и удаляется первая половина s2, остаток заполняется новыми

94
числами, и вычисляются результаты объединения и пересечения s1 и s2. В
программе работают алгоритмы advance – перемещение итератора, set_union
– объединение, set_intersection – пересечение множеств.
#include
#include
using namespace std;
void __fastcall TForm1::SetClick (TObject *Sender) {
set s1, s2, s3, s4;
set::iterator j;
for (int i=0; i>1);
s2.erase (s2.begin (), j);
for (int i=10; iItems->Add (*j); // 0...9
for (j=s2.begin (); j!=s2.end (); ++j) ListBox2->Items->Add (*j); // 5...14
for (j=s3.begin (); j!=s3.end (); ++j) ListBox3->Items->Add (*j); // 0...14
for (j=s4.begin (); j!=s4.end (); ++j) ListBox4->Items->Add (*j); // 5...9
}
Наследование
Объектно-ориентированное программирование предусматривает организацию
иерархических связей между абстрактными типами, создаваемыми
программистом с помощью классов. Такие связи реализуются через механизм
наследования, то есть создания новых типов, которым автоматически
передаются данные и функции порождающих их типов – базовых классов.
Общий формат объявления производного, или порожденного, класса:
class имяКласса : [ типДоступа ]
имяБазовогоКласса… {[ Метка ] объявлениеЧленов... };
Права доступа к наследуемым членам определяются типом доступа, назначаемого
одной из лексем: private, protected и public. При любом типе доступа
закрытые члены базового класса остаются недоступными производному

95
классу. При типе доступа private или при отсутствии указания на тип доступа
наследование считается закрытым, то есть наследуемые члены базового
класса с типами доступа public и protected становятся закрытыми членами
производного класса. При типе доступа protected речь идет о защищенном
наследовании, при котором члены базового класса public и protected становятся
защищенными членами производного класса. Тип доступа public соответствует
открытому наследованию, сохраняющему тип доступа базового
класса.
Базовых классов может быть несколько, и в таком случае говорят о
множественном наследовании (multiple inheritance) в отличие от наследования
единичного (unit inheritance). Но класс не может наследовать самого себя.
Пример интегрирования некоторой функции R*pow (sin(t), 2) методом
прямоугольников с использованием класса VRectangle, производного от
VFunction:
class VFunction {
public:
float Time (float R, float t) { return R*pow (sin (t), 2); }
};
class VRectangle: public VFunction {
public:
float step;
VRectangle (float tk) { step = tk / 100; }
};
void MainVIntegral () {
float j, tk = 0.8, t, sum;
VRectangle myIntegral (tk);
for (t=0, sum=0; t

96
Пример программы решения системы алгебраических уравнений с
привлечением механизма наследования:
class VDet {
public:
float re; VDet (float r[]) { re = r[0] * r[4] - r[1] * r[3]; }
};
class VEquX: public VDet {
public:
float rx; VEquX (float r[]): VDet (r) { rx = r[2] * r[4] - r[1] * r[5]; }
};
class VEquY: public VDet {
public:
float ry; VEquY (float r[]): VDet (r) { ry = r[0] * r[5] - r[2] * r[3]; }
};
void MainVEqu() {
// x + 4y = 9; -x + 6y = 1
float member[] = { 1, 4, 9, -1, 6, 1 }; VEquX x (member); VEquY y (member);
}
ShowMessage ("x = " + AnsiString (x.rx / x.re) + '\n' // x = 5
+ "y = " + AnsiString (y.ry / y.re)); // y = 1
Здесь списки инициализации конструкторов пpоизводных классов VEquX,
VEquY содержат запись VDet (r). Они инициализируют в базовом классе VDet
те части классов EquX, EquY, которые принадлежат Det.
Еще один пример наследования:
class VStudent {
protected:
int course, group;
public:
int fac;
AnsiString result;
VStudent (AnsiString name, int y) {
course = 10 – y / 1000; group = y; fac = group / 100 % 10;
result = "\nСтудент " + name + " с факультета " + fac;
}
};
class VBachalour: public VStudent {
public:

};
int spe;
VBachalour (AnsiString n, int a, int b): VStudent (n,a) {
spe = b;
result += "\n" + AnsiString (course) + " курса " + AnsiString (group) +
" группы – бакалавр по специальности " + AnsiString(b);
}
97
void MainBac () {
VBachalour first ("Сидоров", 6431, 225);
if (first.spe > 200 && first.fac == 4)
first.result += "\nЭто специалист по автоматике";
else
first.result += "\nЭто специалист по электротехнике";
ShowMessage (first.result);
}
Пример множественного наследования:
AnsiString result;
class VStud {
protected:
__int64 group, fac, course;
public:
VStud (AnsiString name, __int64 x) {
group = x;
course = 10 - group / 1000;
fac = group / 100 % 10;
if (course > 0 && course < 6)
result = "\nСтудент " + name + " факультета " + AnsiString (fac)
+ "\nкурса " + AnsiString (course) + " группы " + AnsiString (group);
else course = 0;
}
};
class VPensioner {
protected:
__int64 zip;
public:
VPensioner (AnsiString name, __int64 z): zip (z) {
if (zip > 195000L && zip < 200000L)
result = "\nПенсионер " + AnsiString (name) + " из Петербурга";
else zip = 0;
}
};

98
class VPassenger: VStud, VPensioner {
public:
VPassenger (AnsiString name, __int64 data):
VStud (name, data), VPensioner (name, data) {
if (course>0 || zip) { result +="\n имеет право на льготы"; }
else result = "\n Пассажир не имеет прав на льготы";
ShowMessage (result);
}
};
void MainVPassenger() {
VPassenger w ("Сидоров", 8431);
VPassenger x ("Козлов", 197376L);
VPassenger y ("Тихонов", 1234);
VPassenger z ("Степанов", 1);
}
Виртуальные функции и абстрактные классы
При обычном наследовании объект производного класса обладает
свойствами и поведением объектов базового класса. В этом случае говорят о
раннем, или статическом, связывании на стадии компиляции. Виртуальными
(virtual function) называются функции, которые определяются на стадии исполнения,
то есть производится их позднее, или динамическое, связывание.
Для этого объект производного класса снабжается скрытым указателем на
базовый класс, который используется компилятором на стадии выполнения
программы.
При объявлении виртуальной функции к ее имени добавляется лексема
virtual, что позволяет производным классам при необходимости переопределять
такую функцию без изменения ее имени в списке параметров:
virtual Тип имяФункции ([ объявлениеПараметров ]);
«Виpтуальные функции служат центpальным моментом объектноориентированного
программирования, потому что они позволяют опpеделять
базовый класс общего назначения, не тpебуя знания особенностей, котоpые
могут быть пpедусмотpены пpоизводным классом. Пpогpамма на C++ без
виpтуальных функций, веpоятно, пpосто невеpно спpоектиpована» [Голуб].
Иными словами, виpтуальные функции опpеделяют возможности, котоpыми
обладают пpоизводные классы, но котоpые не могут быть pеализованы на
уpовне базового класса.

class VMarket {
public:
virtual void Market1 () { ShowMessage ("Телевизоры"); }
void Market2 () { ShowMessage ("Компьютеры"); }
};
99
class VSection: public VMarket {
public:
void Market1 () { ShowMessage ("SONY"); }
void Market2 () { ShowMessage ("MACINTOSH"); }
};
void MainVirtual1 () {
VMarket *m = new VSection; // ссылка на производный класс
m->Market1 ();
// SONY
m->Market2 ();
// Компьютеры
}
Более сложный пример помогает разобраться с различными вариантами
наследования:
AnsiString result;
class VProcessor {
int frequency;
public:
VProcessor (int j = 100): frequency (j) {}
virtual void Out () { result += "\nПроцессор " + AnsiString (frequency); }
void Out (AnsiString s) { result += "\n" + s + AnsiString (frequency); }
};
class VComputer: public VProcessor {
int hardDisk;
public:
VComputer (int j = 800): VProcessor (133), hardDisk (j) {}
void Out () { result += "\nКомпьютер " + AnsiString (hardDisk); }
int Out (AnsiString s) {
result += "\n" + s + AnsiString (hardDisk);
return hardDisk;
}
};
void MainVirtual2 () {
VProcessor intel, motorola (150), *cirix;
VComputer ibm, macintosh (200),

*proforma = &macintosh;
100
intel.Out (); // Процессор 100
motorola.Out (); // Процессор 150
ibm.Out (); // Компьютер 800
macintosh.Out (); // Компьютер 200
intel.Out ("Intel "); // Intel 100
motorola.Out ("Motorola "); // Motorola 150
ibm.Out ("IBM "); // IBM 800
macintosh.Out ("Macintosh "); // Macintosh 200
cirix = proforma;
cirix->Out (); // Компьютер 200
cirix->Out ("Macintosh "); // Macintosh 133
proforma->Out (); // Компьютер 200
proforma->Out ("Macintosh "); // Macintosh 200
ShowMessage (result);
}
Виртуальная функция, не определенная в базовом классе, называется
чистой виртуальной функцией (pure virtual function) и объявляется как
virtual Тип имяФункции ([ объявлениеПараметров ]) = 0;
Такая функция полностью определяется в производных классах. Базовый
класс, содержащий, по крайней мере, одну чистую виртуальную функцию,
называется абстрактным классом (abstract class).
Абстрактный класс может использоваться лишь в качестве базового
класса для некоторого другого класса. Никакие объекты абстрактного класса
не могут создаваться иначе, как подобъекты, представляющие базовый класс
в объектах некоторого производного от него класса.
class VNewMarket {
public:
virtual void Market1 () = 0;
void Market2 () { ShowMessage ("Компьютеры"); }
};
class VNewSection: public VNewMarket {
public:
void Market1 () { ShowMessage ("SONY"); }
void Market2 () { ShowMessage ("MACINTOSH"); }
};

101
void MainVirtual3 () {
VNewMarket *m = new VNewSection; // ссылка на производный класс
m->Market1 ();
// SONY
m->Market2 ();
// Компьютеры
}
В следующем примере абстрактный класс управляет выводом на экран
разнообразной информации:
class VMan {
protected: long course;
public: virtual AnsiString Out (AnsiString) = 0;
};
class VStudent: public VMan {
protected:
__int64 group, fac;
public:
VStudent (__int64 x) {
group = x; fac = group / 100 % 10; course = 10 - x / 1000;
if (course < 1 || course > 5) course = 0;
}
AnsiString Out (AnsiString name) {
return "\nСтудент " + name + " факультета " + AnsiString (fac)
+ "\nкурса " + AnsiString (course) + " группы " + AnsiString (group);
}
};
class VPensioner: public VMan {
public:
VPensioner (__int64 x) {
if (x > 195000L && x < 200000L) course = x;
else course = 0;
}
AnsiString Out (AnsiString name) {
return "\nПенсионер " + AnsiString(name) + " из Петербурга";
}
};
class VPassenger: VStudent, VPensioner {
public:
AnsiString result;
VPassenger (AnsiString name, __int64 data):
VStudent (data), VPensioner (data) {
If (!(VStudent::course) && !(VPensioner::course))
ShowMessage (" Пассажир не имеет права на льготы.");

102
};
}
}
else {
if (VStudent::course) result = VStudent::Out (name);
if (VPensioner::course) result = VPensioner::Out (name);
ShowMessage (result + "\nимеет право на льготы.");
void MainVirtual4 () {
VPassenger w ("Сидоров", 8431);
VPassenger x ("Козлов", 197376L);
VPassenger y ("Тихонов", 1234);
VPassenger z ("Степанов", 1);
}

103
Список литературы
1. C++Builder 5. Руководство разработчика. Уч. пособие в 2х т. //
Д.Холингвэрт, Д.Баттерфилд, Б.Сворт, Д.Оллсоп. – М., Изд. дом «Вильямс»,
2001. 880 и 832 с.
2. Архангельский А.Я. Программирование в C++Builder 6. – М., Бином,
2003. 1152 с.
3. Бабэ Б. Просто и ясно о Borland C++ – М. Бином, 1995. 400 с.
4. Голуб А. Пpавила пpогpаммиpования C & C++. – М.. Бином, 1996. 272 с.
5. Кнут Д. Искусство программирования для ЭВМ. В 3-х кн. – М. Миp, 1999.
6. Культин Н.Б. Самоучитель С++Builder. – СПб., БХВ-Петербург, 2004. 320
с.
7. Павловская Т.А. С/С++. Программирование на языке высокого уровня. –
СПб., Питер, 2003. 360 с.
8. Сван Т. Освоение Borland C++ 4.5. – Киев. Диалектика. 1996. 400 с.
9. Шамис В.А. Borland C++Builder 6.0. Для профессионалов. – СПб., Питер,
2003. 798 с.

104
Валерий Михайлович Водовозов,
Александр Константинович Пожидаев
Разработка программ под Windows
Учебное пособие
Редактор Н. В. Лукина
Подписано в печать Формат 60×84 1/16. Бумага офсетная.
Печать офсетная. Гарнитура «Times». Печ. л. 4,5.
Тираж 200 экз. Заказ
Издательство СПбГЭТУ «ЛЭТИ»
197376, С.-Петербург, ул. Проф. Попова, 5