Объектно-ориентированное программирование на С++ - eDrive

Федеральное агентство по образованию 

_________________________________________ 

Санкт-Петербургский государственный 

электротехнический университет «ЛЭТИ» 

____________________________________________________________ 

В. М. Водовозов Ф. В. Чмиленко 

Объектно-ориентированное 

программирование на С++ 

Учебное пособие 

Санкт-Петербург 

Издательство СПбГЭТУ «ЛЭТИ» 

2007

ББК 32.973.26-018 

В62 

УДК 681.3.016 (018) 

Водовозов В. М., Чмиленко Ф. В. Объектно-ориентированное программирование 

на С++: Учеб. пособие. СПб.: Изд-во СПбГЭТУ «ЛЭТИ», 2007. 

128 с. 

Дано описание языка С++. Представлены основные этапы процедурного, 

структурного, модульного и объектно-ориентированного программирования 

под Windows. Показаны особенности работы с библиотеками, процедурами, 

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

Предназначено для студентов направления 654500 – «Электротехника, 

электромеханика и электротехнологии» по специальностям: 180100 – «Электромеханика», 

180400 – «Электропривод и автоматизация промышленных 

установок и робототехнических комплексов», 180500 – «Электротехнологические 

установки и системы». 

Рецензенты: кафедра информационных технологий СПбИДПО; 

директор Центра профессиональной подготовки «ИЛН Системс» 

О. В. Степанова 

Утверждено 

редакционно-издательским советом университета 

в качестве учебного пособия 

ISBN 5-7629-0567-5 © В. М. Водовозов, Ф. В. Чмиленко, 2007

Оглавление 

Предисловие............................................................................................................. 5 

Введение в процедурное программирование ....................................................... 7 

Редактор кода.................................................................................................... 7 

Функции............................................................................................................. 8 

Выражения ...................................................................................................... 10 

Классы форм ................................................................................................... 14 

Обработка событий ........................................................................................ 16 

Программирование графики.......................................................................... 19 

Исключения..................................................................................................... 20 

Простые типы данных и операторы ............................................................. 22 

Тип AnsiString ................................................................................................. 26 

Контрольные вопросы.................................................................................... 30 

Составные операторы ........................................................................................... 32 

Операторы перехода....................................................................................... 32 

Условный оператор ........................................................................................ 33 

Оператор выбора ............................................................................................ 34 

Оператор цикла............................................................................................... 35 

Операторы повторения .................................................................................. 36 

Программирование диалогов ........................................................................ 38 


Введение в структурное программирование ...................................................... 40 

Массивы........................................................................................................... 40 

Перестановки и сортировки .......................................................................... 43 

Списки TStringList.......................................................................................... 46 

Структуры и объединения............................................................................. 49 

Динамические структуры данных ................................................................ 51 

Стандартная библиотека STL........................................................................ 59 


Введение в модульное программирование......................................................... 65 

Работа с текстовыми файлами ...................................................................... 65 

Работа с графическими файлами .................................................................. 71 

Работа с двоичными файлами ....................................................................... 74 

Модули DLL и пакеты ................................................................................... 75 

Ресурсы............................................................................................................ 78 

Потоки ............................................................................................................. 79 

Дистрибутивы ................................................................................................. 81 


Приложения баз данных ....................................................................................... 83 

Технологии создания приложений баз данных........................................... 84 

Архитектуры приложений баз данных......................................................... 86 

Подключение к базам данных....................................................................... 88 

Доступ к записям таблиц ............................................................................... 90

Работа с запросами ......................................................................................... 92 

Связывание таблиц и запросов ..................................................................... 93 


Объектно-ориентированное программирование................................................ 95 

Инкапсуляция.................................................................................................. 95 

Конструкторы и деструкторы ....................................................................... 99 

Дружественные функции и классы.............................................................103 

Полиморфизм................................................................................................105 

Шаблоны........................................................................................................109 

Наследование ................................................................................................113 

Виртуальные функции и абстрактные классы ..........................................117 

Контрольные вопросы..................................................................................120 

Приложение. Программные документы ...........................................................122 

Список литературы .............................................................................................124 

Предметный указатель........................................................................................125

5 

Предисловие 

Напрасно обучение без мысли. 

Из Конфуция 

Программирование не чуждо человеческой природе. Тот, кто пишет и 

понимает программы, – не робот и не «создание не от мира сего». Программирование 

– это разновидность моделирования, а без модели, упрощения и 

обобщения нет сознания. Программирование естественно вытекает из нужд и 

потребностей современного культурного общества. 

Более того, если естественный язык – это в первую очередь средство 

общения, то искусственный – это инструмент познания. В этом кроется великая 

польза программирования. И в этом видится смысл известного высказывания 

Н. Винера о том, что «вычислительная машина ценна ровно настолько, 

насколько ценен использующий ее человек». 

«Прекрасное – трудно», считал Платон. И программирование далеко не 

просто. Оно требует внимания и терпения. Многие студенты изначально не 

обладают этими качествами. Но это не значит, что они не могут научиться 

программированию, а означает лишь, что такие черты требуется выработать 

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

освоения того, что Д. Кнут назвал «искусством программирования» [6]. 

Во-первых, постарайтесь максимально использовать мощь визуального 

программирования. Визуальное сродни и ребенку, и взрослому, оно узнаваемо, 

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

в них сложнее сделать ошибку и легче такую ошибку найти [1][2]. 

Сам по себе принцип визуального программирования служит прекрасным 

стимулом для создания хотя бы внешне неповторимых программ. Уникальный 

дизайн форм и элементов управления удается всем. Исходя из этого, при 

конструировании своей программы приложите все усилия, чтобы ваш интерфейс 

отличался от других. Здесь на помощь может прийти пособие [4], 

предшествующее данному изданию. 

Но красивое приложение – это еще не программа, а просто пятно на экране. 

Программа – как девушка: нравится за внешнось, любится за содержание. 

Поэтому одно из первых умений программирования – это умение алго-

6 

ритмизировать поведение объектов, раскладывать его на действия, совершаемые 

во времени. Алгоритм – предшественник логики [10]. Если вы не в 

состоянии последовательно описать работу будущего приложения, то, скорее 

всего, вы не сможете и реализовать его на языке программирования. Начните 

с построения простейшего линейного приближения. Затем детализируйте 

свой алгоритм ветвлениями. Наконец, организуйте циклы. Продумывайте 

каждую разработку на уровне алгоритма, так как «если не поставить себя в 

жесткие рамки с самого начала, программа превратится в огромного монстра, 

не поддающегося отладке» [8]. 

Позаботьтесь, также, об уникальности имен переменных, констант, 

функций и файлов своих проектов. Давать свои (не такие, как в учебнике или 

у товарища) имена трудно, потому что для этого надо иметь свое мнение, которое 

невозможно сформировать без понимания различий между стандартными 

и авторскими элементами программы. Но это хороший стимул, так как 

является одним из первых элементов творчества. 

В ходе работы над программой полезен коллективный подход. Однако, 

принимая помощь, не выпускайте из рук мышки, иначе помощь «прошмыгнет» 

мимо вас и вся достанется тому, кто вам помогает («хочешь научиться 

сам, научи товарища»). 

«Ясные мысли выражаются ясным и понятным языком», подметил 

Р. Гамзатов. Красивое оформление исходного текста программы тоже требует 

умений. Кроме того, оно вырабатывает дисциплину программирования, 

проясняет мысль, учит уважать читателя текста, повышает производительность 

разработки приложений. Когда использовать тот или иной знак пунктуации, 

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

строчные и прописные буквы, что такое «говорящие имена» – эти и другие 

вопросы требуют серьезного внимания. 

Давая эти рекомендации, авторы отлично понимают, что самое простое 

в жизни – это давать советы, а самое сложное – чужим советам следовать. 

Так что совсем не обязательно с нами соглашаться. 

Просто примите к сведению и идите своим путем.

7 

Введение в процедурное программирование 

Упрощайте сложное, и вы получите 

самое существенное. 

Г. Бокль 

Концепция процедурного программирования предполагает «деление 

проблемы на такое множество задач, чтобы, решив каждую из них, можно 

было прийти к решению всей проблемы» [6]. Каждой задаче приводится в 

соответствие отдельная процедура. В языках С/С++, С#, Java процедуры 

представлены функциями, в Visual Basic и Pascal – функциями и подпрограммами. 

Благодаря такой процедурной декомпозиции по принципу «разделяй 

и властвуй» легче управлять большими и сложными программами [8]. 

Она обеспечивает логическую сегментацию проблемы и упрощает отладку. 

Концепция базируется на механизме стандартных типов данных – категорий 

(разрядов), на которые подразделяются данные в соответствии со способами 

их хранения и обработки. Без типизации невозможно программирование. 

В отличие от Excel, Mathcad или Visual Basic, язык С/С++ не «прикрывает» 

типизацию автоматическим присваиванием типа по умолчанию, поэтому 

разбираться с типами данных следует сразу, не откладывая этот вопрос 

«до сессии». 

Редактор кода 

Файлы программ обрабатываются на вкладках окна редактора кода, запускаемого 

через меню View.Units (), View.Toggle Form/Unit 

(). Вкладки с текстами открываются в редакторе кода через меню File 

.Open. Переход между ними удобно выполнять с помощью навигационных 

стрелок в правом верхнем углу окна. В левом поле выделения окна щелчком 

можно расставлять и снимать точки прерывания выполнения программы. Переключение 

между кодами и файлами заголовков выполняется через контекстные 

меню Open Source/Header File () и Open File at Cursor (). Щелчки по именам в текстах программ при нажатой клавише 

превращают их в гиперссылки (hotspot), с помощью которых обычно перемещаются 

между связанными файлами. Другие возможности системы редактирования 

Code Insight приведены в табл. 1:

8 

Подсказки в системе редактирования Code Insight 

Таблица 1 

Технология Клавиши Назначение 

Code Completion Список членов класса после стрелки –> и точки 

Code Parameters – Список параметров функции после скобки ( 

Code Templates Список шаблонов программирования 

Tooltip Expression 

Подсказка значения переменной под курсором в 

Evaluation 

– 

окне отладчика 

Tooltip Symbol Insight – Подсказка объявления объекта в редакторе кода 

Функции 

Исходный текст программы на языке C++ составляют выражения, 

сгруппированные в функции. 

Функции – это единственный вид процедур, используемый в C++. Будучи 

разновидностью процедуры, функция (function) представляет относительно 

автономную именованную часть программы, описывающую поведение 

программных объектов через действия над данными. Программирование 

с использованием функций сокращает размеры исходного текста и упрощает 

его организацию, хотя «экономия пространства не экономит времени» [6]. 

В отличие от простой процедуры, функция обычно имеет возвращаемое 

значение (return value), то есть результат своей деятельности в вызывающем 

ее выражении. 

Каждая функция может многократно вызываться из других функций. В 

момент вызова функция получает исходные данные и начинает выполнять 

предписанные действия над ними. 

Различают встроенные библиотечные и авторские функции. Первые 

хранятся в библиотеках C++. Для доступа к библиотечным функциям в начале 

текста программы указываются имена соответствующих файлов заголовков: 

#include < имяФайлаЗаголовка > 

или 

#include «имяФайлаЗаголовка» 

Файлы заголовков – «это хранилища информации, содержащие описания 

констант и объявления функций» [9]. Каждый такой файл сообщает компилятору 

имена и характеристики функций из других файлов и библиотек,

9 

которые используются в программе. Файлы заголовков главных библиотек 

фирмы Borland приведены в табл. 2. 


Файл заголовка 

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 

Файлы заголовков библиотек фирмы Borland 

Назначение 

Функции распределения памяти 

Функции интерфейса с BIOS 

Функции консольного ввода и вывода 

Функции классификации символов 

Функции доступа к файлам 

Функции ввода и вывода файловых потоков 

Функции-манипуляторы потоков 

Функции потокового ввода и вывода 

Математические функции 

Функции управления процессами 

Функции стандартного ввода и вывода 

Функции преобразования строк 

Функции времени и даты 

Функции библиотек VCL 

Функции для работы в среде Windows 

Выражение, начинающееся символом #, называют директивой препроцессора 

(preprocessor directive). Если имя файла заголовка в директиве 

препроцессора заключено в угловые скобки, компилятор отыскивает его в 

специальной папке \include. Если же это имя заключено в кавычки, поиск будет 

начат из текущей папки. 

В текстах программ C++Builder много директив препроцессора, служащих 

инструкциями для компилятора. Все они располагаются в начале исходного 

текста (табл. 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

10 

С применением авторских функций связаны три понятия: объявление 

функции, определение функции и вызов функции. Каждая функция только 

один раз определяется (declare) (описывается) в тексте. При этом ей присваивается 

уникальное имя и сообщается набор параметров (parameter), то 

есть данных, которые должны поступить к ней прежде, чем подпрограмма 

приступит к их обработке. В ряде случаев определению функции предшествует 

ее объявление (announcement). Объявления и определения функций могут 

выноситься в авторские библиотеки. Каждый программист помещает 

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

этим файлам из файлов кодов, получая доступ к созданным ранее функциям. 

Такое обращение называется вызовом (call). При вызове функции передаются 

аргументы (argument), то есть значения параметров. В процессе компиляции 

автоматически создается список всех функций, необходимых обрабатываемому 

файлу, а в ходе последующей компоновки устанавливаются необходимые 

связи. 

Имена функциям, равно как и переменным, константам, определяемым 

в программах, даются программистами. Имена чувствительны к регистру, 

начинаются с буквы или символа подчеркивания, не содержат пробелов и 

иных символов, кроме подчеркивания, цифр и латинских букв, и отличаются 

от лексем, служащих именами встроенных функций, операторов, констант и 

других элементов языка. Имена функций расширяют набор лексем языка 

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

выражения наряду с лексемами языка. 

Обязательной частью программы является единственная главная функция 

(main function), обычно WinMain, расположенная в файле кода проекта. 

Раздел объявлений и другие функции необязательны. Когда компьютер приступает 

к выполнению программы, он начинает ее с первой строки главной 

функции, независимо от взаимного расположения функций в программе. 

Выражения 

Любое объявление является выражением, содержащим сведения об области 

определения и области значений данных. Объявления функций называют 

прототипами (prototype), т.к. они представляют собой своеобразный 

шаблон, образец использования функции:

11 

[Модификатор] [типФункции] имяФункции 

( типПараметра [ имяПараметра [ = Значение ]]...); 

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

в котором в прямоугольные скобки принято заключать необязательные 

части выражений, а многоточием отмечается возможность повторения элементов 

синтаксической формулы. 

Все выражения в C++, кроме директив препроцессора и комментариев, 

завершаются точкой с запятой. Длинные выражения можно разбивать символом 

\ – признаком продолжения на следующей строке. В круглых скобках 

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

в конце списка параметров, можно сразу присваивать значения – 

это называется инициализацией по умолчанию (default initialization). Тип 

функции (function type) характеризует возвращаемое значение, а тип параметра 

(parameter type) – множество входных данных, обрабатываемых этой 

функцией. Кроме объявления встроенных функций из стандартных библиотек, 

находящихся в файлах заголовков, авторские функции, создаваемые программистом, 

также могут включаться в файлы заголовков. Но часто их объявляют 

и затем определяют прямо в тексте программы. В тех случаях, когда 

функция определяется до ее вызова, объявлять функции необязательно. C++ 

не допускает объявления и определения функций внутри других функций: 

Формат определения авторской функции: 

Заголовок { 

[ объявлениеДанных...] 

Выражение… 

[ return возвращаемоеЗначение;] } 

Заголовок (caption) определяемой функции является своего рода копией 

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

точкой с запятой. Внутри фигурных скобок в определении функции заключается 

ее тело (body). Текст программы содержит выражения, состоящие из 

переменных, констант, операторов, вызовов функций и заканчивающиеся 

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

блоки. 

Обычно каждый блок обрабатывает свои переменные и константы, «не 

заботясь» о других данных программы. В этом «правиле ограниченной видимости» 

заключается автономность, независимость блоков и функций. Дан-

12 

ные, обрабатываемые внутри блока, называют локальными (local variable), 

личными или автоматическими. Память под них выделяется на время работы, 

а по завершении работы функции их значения так же автоматически стираются, 

освобождая место в памяти переменным других частей программы. 

В C++ разрешено совмещать определение коротких функций с их объявлением 

с помощью лексемы inline. Благодаря этому механизму, код функции 

автоматически встраивается в то место, откуда происходит ее вызов, и 

вызов происходит значительно быстрее. 

Если требуется сохранять значения локальных переменных между вызовами 

функций, их объявления снабжают модификатором static. В момент 

объявления статическую переменную можно явно инициализировать. Если 

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

значение. При повторных вызовах выражение инициализации игнорируется. 

Модификатор register направляет локальную переменную на сохранение 

в регистры процессора. А модификатор volatile явно указывает, что локальная 

переменная «изменчива», то есть может в любой момент поменять 

свое значение. 

Кроме локальных данных, в программах существуют глобальные переменные 

(global variable) и глобальные константы (global constant), доступные 

из разных частей программы. Они размещаются в разделе объявлений файла 

и помогают функциям обмениваться информацией, минуя параметры, но порой 

снижают надежность программной системы и увеличивают размер памяти, 

занимаемой программой в ходе выполнения. 

Внешний модификатор extern информирует компилятор о существовании 

внешних данных, находящихся в другом файле кода программы. За 

внешними и глобальными данными память закрепляется постоянно на все 

время работы программы, а в ходе первого вызова они инициализируются 

нулем. 

Каждый вызов функции представляет собой запрос на совершение определенных 

действий. Он осуществляется в соответствии с объявленным 

прототипом и семантической организацией программы: 

имяФункции ([ списокАргументов ]);

13 

В ответ на вызов копия кода функции передается в вызывающую 

функцию для обработки, после чего она удаляется из памяти. Исключением 

являются функции, объявленные с модификатором inline, коды которых обрабатываются 

непосредственно. При вызове функций параметры, инициализированные 

по умолчанию, могут быть опущены в списке передаваемых аргументов. 

В любой части программы можно помещать комментарии – тексты, обрамленные 

символами /* */, или фрагменты строк, начинающиеся символами 

//, не влияющие на ход выполнения программы. 

Ниже приведен пример текста файла проекта на языке C++Builder: 

#include 


// Заголовочный файл описания классов 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 сообщают о модулях,

14 

используемых в проекте. Выражение Application–>Initialize () инициализирует 

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:. Объекты, порождаемые от закрытых 

членов класса, доступны лишь объектам своего класса. Объекты, порождаемые 

защищенными членами, открыты объектам своего класса и производных 

от него классов. Объекты открытых членов могут использоваться во всех 

операциях и взаимодействовать с переменными программы.

15 

Данные в определении класса объявляются со своими типами и именами, 

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

рассматриваемом примере присутствуют указатели на данные Edit1, Edit2, 

Button1, Label1 классов TEdit, TButton, TLabel. Модификатор быстрого вызова 

_ _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) {}

16 

При удалении из формы элементов управления их объявления автоматически 

удаляются из описания класса формы, хотя объявления членфункций 

сохраняются, и при необходимости программисту следует удалить 

их вручную. При переименовании объектов переименовываются и все ссылки 

на них в файле заголовка и в определениях. 

Обработка событий 

Доступ к функциям форм, обрабатывающим события элементов управления, 

может осуществляться через вкладку 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(); 

}

17 

Здесь при выборе пункта меню menuNew свойству Текст поля Edit1 присваивается 

значение «2003», а надписи Label1 передается «Санкт-Петербург». 

При выборе пункта menuDatabase открывается форма Form2, а при выборе 

пункта menuAbout открывается модально форма FormAbout. При нажатии 

кнопки Button1 приложение завершает свою работу. 

В следующем примере показаны обработчики меню открытия и сохранения 

файла, обслуживающие элемент 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 = fn; 

} 

Передача данных между формами, не являющимися модальными, осуществляется 

либо через открытые члены их классов, либо через свойства 

форм. Например, чтобы внести в надпись Label1 активной формы-владельца, 

на которую ссылается указатель this, значение заголовка формы Modeless- 

Form, можно воспользоваться следующим выражением: 

this–>Label1–>Caption = ModelessForm–>Caption; 

Важным достоинством обработчиков является их способность создавать 

новые элементы управления в ходе выполнения программы (runtime 

mode), а не на стадии проектирования (design time mode). Новые объекты порождаются 

оператором new, который выделяет необходимое количество свободной 

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

new, следует удалять из памяти оператором delete, освобождающим 

память. 

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

Это можно делать динамически, по мере необходимости. На стадии 

проектирования имена динамических форм надо удалить из списка Auto-

18 

create forms вкладки Forms (меню Project.Options) или просто вычеркнуть 

соответствующие строки из WinMain, а в нужном месте программы создавать 

их и открывать не модально методом Show или модально методом ShowModal. 

В следующем примере в форме MainForm по щелчку кнопки Button1 создаются 

три формы: не модальная форма ModelessForm, модальная форма 

ModalForm, объявленная глобальной переменной в файле заголовка, и модальная 

форма LocalForm, не связанная с глобальной переменной: 

#include 

#include "Unit1.h" 




__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, не связывающий новую форму с конкретным владельцем. 

Еще один фрагмент программы посвящен созданию кнопки: 

_ _fastcall TForm1::TForm1 (TComponent* Owner): TForm (Owner) { 

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; 

} 

Текст обработчика этой кнопки:

19 

void _ _fastcall TForm1::MyClick (TObject *Sender) { 

ShowMessage (“Привет”); 

} 

Программирование графики 

Графические объекты строятся на канве, являющейся свойством формы 

и ряда визуальных компонентов. Табл. 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); 

} 

20 

Аналогичную задачу можно решить в элементе управления PaintBox по событию 

PainBoxPaint. 

Во втором примере обработчик события, связанного с нажатием кнопки, 

формирует диалог для вставки объекта OLE: 

void _ _fastcall TModalForm::Button1Click (TObject *Sender) { 

OleContainer1–>InsertObjectDialog(); 

} 

Третий пример демонстрирует использование компонента 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 и заключаются в

21 

фигурные скобки. В случае обнаружения ошибки происходит программное 

прерывание. При этом управление передается блоку обработчика исключения 

catch. В скобках указывают спецификацию класса конкретного исключения, 

а для перехвата всех ошибок – многоточие (…). Не менее одного такого 

блока следует за блоком try. Для каждой исключительной ситуации определен 

свой класс. Некоторые классы исключений приведены в табл. 5. 


Класс 

EAccessViolation 

EConvertError 

EDatabaseError 

EDivByZero 

EInOutError 

EPrinterError 

EStackOverflow 

EZeroDivide 

EOverflow 

Некоторые классы исключений 

Описание 

Ошибка доступа в память 

Ошибка преобразования данных 

Ошибка доступа к базе данных 

Ошибка деления на нуль целого числа 

Ошибка файлового обмена 

Ошибка печати 

Переполнение стека 

Ошибка деления на нуль вещественного числа 

Переполнение регистров вещественных чисел 

В приведенном ранее тексте файла проекта в блок try функции WinMain 

помещены выражения инициализации объектов OLE Automation, создания 

главной формы и запуска приложения. В блоке catch в случае исключительной 

ситуации выводится сообщение с указанием ее причины. 

Простой пример обработки исключений показывает, как при возникновении 

любой ошибочной ситуации, например при отсутствии текста в поле, 

можно вывести сообщение: 


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 = “Неверная величина числа”; 

} 

22 

В блоке try можно использовать лексему throw для вызова исключительной 

ситуации или для указания типа исключения, которое вызывает 

функция. Вслед за блоком try вместо catch часто располагают блок _ _finally, 

выполняющийся вне зависимости от наличия исключительной ситуации. 

Простые типы данных и операторы 

Типы данных C++Builder ориентированы на 32-разрядную платформу 

(табл. 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.

23 

Типы указываются во всех объявлениях переменных и констант. Объявления 

переменных могут совмещаться с их инициализацией: 

[Модификатор] [Тип] имяПеременной [=Значение]; 

а во множестве различных объявлений констант инициализация обязательна: 

const Тип имяКонстанты = Значение; 

enum [Тип] { списокЗначений }; 

enum { списокЗначений } имяТипа; 

#define имяКонстанты Значение 

Последний вариант объявления констант введен для совместимости с C. 

Типы переменных, входящих в параметры функций, указываются в 

круглых скобках вслед за именем функции. Если параметр отсутствует, скобки 

остаются пустыми. Тип возвращаемого функцией значения указывается 

при ее объявлении и определении перед именем. Функция, не возвращающая 

значений, объявляется как функция типа void. Если у функции или данных не 

объявлен тип, они получают тип int. 

В соответствии с типами, различают символьные, строковые, целые и 

вещественные константы. Первые заключаются в апострофы (например, ‘e’ 

или ‘1’), вторые – в кавычки («привет»). Целые бывают десятичными (например 

56), восьмеричными (056) и шестнадцатеричными (0хАС), а вещественные 

– десятичными (6.23) и экспоненциальными (5Е-12). Специальную 

группу символьных констант образуют управляющие последовательности 

(табл. 7). 


Управляющие последовательности 

'\0' Ноль '\t' Горизонтальная табуляция 

'\a' Сигнал '\v' Вертикальная табуляция 

'\b' Возврат на символ '\"' Кавычки 

'\f' Новая страница '\'' Апостроф 

'\n' Новая строка '\\' Обратная косая черта 

'\r' Начало строки – – 

Данные, которыми манипулирует программа, хранятся в ячейках памяти 

компьютера, и именованные ячейки памяти мы назвали переменными и 

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

в ходе выполнения программы. Часть ячеек памяти выделяется 

для указания на другие области, и эту часть называют указателями и ссыл-

24 

ками. «Введение связей с другими элементами данных через указатели – 

чрезвычайно важная идея в программировании; это ключ к представлению 

сложных структур» [6]. 

Указатель (pointer) – это специальный тип данных, описывающий не 

значение, а размещение переменной, константы или возвращаемого значения 

функции, «одно из хитроумных понятий C» [9]. Его объявляют как Тип 

*имяУказателя. Оператор разыменования * (dereference operator) служит 

средством доступа к данным, а имяУказателя может быть другим указателем 

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

ссылкой (reference) и объявляют как Тип &имяСсылки. & – это оператор 

взятия адреса, а имяСсылки – значение хранящихся по этому адресу данных. 

Между операторами * и & установлено следующее соотношение: если 

имяУказателя – адpес данных, то *имяУказателя – их значение (т.е. указатель); 

если имяСсылки – значение данных, то &имяСсылки – их адpес (т.е. 

ссылка). 

Однажды инициализировав ссылку, ей нельзя присвоить другое значение. 

И, в отличие от указателей, которые могут быть объявлены без инициализации 

или установлены в нуль, ссылки всегда указывают на конкретные 

данные. 

Использование указателей и ссылок играет важную роль в работе с 

функциями. 

Обычно аргументы, передаваемые в функцию при ее вызове, обрабатываются 

функцией как копии данных, и потому сами данные не меняются в 

ходе выполнения функции. В вызывающем модуле функция может изменить 

только одну переменную – ту, которую она возвращает как результат своей 

работы. Если же требуется, чтобы функция изменяла более одной переменной, 

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

данные, и в первую очередь – адpеса переменных. 

Аналогичное правило действует и при передаче функции в другую 

функцию в качестве аргумента. 

Для выполнения операций над типизированными данными в C++ используется 

более 50 простых операторов. В табл. 8 они расположены по убыванию 

приоритета.

25 

Простые операторы C++ 


Приоритет 

к данным тические ские 

Доступ Арифме- 

Логиче- 

Категория 

Двоичные 

10 Первичные 

() [] {} /* */ // ‘’ 

“” :: ; # -> . 

Нет Нет Нет 

9 Унарные 

& * – + (тип) 

new delete sizeof 

++ –– ! ~ 

8 Мультипликативные Нет * / % Нет >> = 

Нет 

== != 

5 И Нет Нет && & 

4 Исключающее ИЛИ Нет Нет ^ 

3 ИЛИ Нет Нет || | 

2 Условие Нет Нет : Нет 

1 Присваивание = 

*= /= %= 

= 

Нет 

+= –= 

&= |= ^= 

В круглые скобки заключаются списки аргументов, в квадратные – индексы 

массивов, в фигурные – блоки данных, в косые – комментарии. Кроме 

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

обрамляются константы. Двойное двоеточие (::) образует оператор 

области видимости данных. Точка с запятой (;) завершает выражения. Знак 

номера (#) начинает директивы препроцессора. Стрелка ( –> ) и точка (.) отделяют 

свойства и методы классов. Амперсанд (&) и звездочка (*) помечают 

адреса, ссылки и указатели. Оператором new создаются, а оператором delete 

удаляются объекты. 

Унарные операторы обрабатывают один операнд, а бинарные мультипликативные, 

аддитивные и т. п. – два операнда. В частности, унарные операторы 

сложения и вычитания (+, –) меняют знаки операндов. Оператор sizeof 

определяет размер данных. Операторы автоинкремента (++) и автодекремента 

(– –) могут действовать до операции или после ее. Так, действие j = i++ 

аналогично выражениям j = i; i = i+1. А выражение j = – –i можно представить 

как i = i–1; j = i. То же можно сказать и о таких операторах, как *=, /= и им 

подобным. Восклицательный знак (!) служит для отрицания, а тильда (~) – 

для инверсии. 

Кроме того, звездочка (*) является знаком умножения, косая черта (/) – 

деления, а процент (%) – остатка от деления нацело. Двойными стрелками

26 

(>>,

Метод 

IsDelimiter (AnsiString& delimiters, 

int index) 

IsEmpty() 

LastDelimiter (AnsiString& delimit) 

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 () 

27 

Окончание табл. 9 


Подтверждает наличие определенного символа (delimiter) 

в заданной позиции (index) 

Подтверждает, что строка пуста 

Последняя позиция в строке определенного символа 

(delimiter) 

Длина строки в байтах 

Загружает строку из файла 

Сравнение с другой строкой rhs 

Символ под указанным индексом idx 

Инициализация строки другой строкой rhs 

Соединение с другой строкой rhs 

Позиция начала подстроки subStr в строке 

Задают формат строки в стандарте языка С, возвращая 

длину или ссылку на строку 

Задает длину (newLength) строки 

Строка заданного числа (count) символов (ch) 

Подстрока длиной count в позиции index 

Преобразуют строку в число, в т.ч. – в число по 

умолчанию в случае ошибки преобразования 

Удаляют пробелы 

Преобразует в прописные буквы 

Отдельные символы строк класса AnsiString индексируются, начиная с 1. 

В следующем примере приведен текст конструктора формы Form1, в 

котором вычисляется округленное значение гипотенузы и результат направляется 

в надпись Label1. Затем вычисляется средняя длина двух окружностей, 

и округленный результат направляется в надпись Label2. Тексты надписей 

имеют тип данных AnsiString, поэтому используются функции преобразования 

типов FloatToStr и FloatToStrF. 

#include 

#include 




__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); 

} 

28 

В примере задействована математическая библиотека Borland C , подключаемая 

файлом заголовка . Функции этой библиотеки описаны в 

табл. 10: 


Функции 

abs, fabs 

acos, asin, atan 

cos, sin, tan 

exp 

floor 

hypot 

pow, pow10 

seal 

sqrt 

Математические функции Borland C 


Абсолютное значение 

Обратные тригонометрические функции 

Тригонометрические функции 

Экспонента 

Ближайшее меньшее целое 

Гипотенуза 

Степень 

Ближайшее большее целое 

Квадратный корень 

Второй пример посвящен использованию типа 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 ('

29 

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); 

}; 

При нажатии кнопки данные из полей формы преобразуются к нужному 

формату, обрабатываются в соответствии с условием конкретной задачи, и 

результат возвращается в надпись: 


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; 

} 

Далее следуют обработчики кнопки 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; 

} 

30 

Еще один пример посвящен передачи данных из модальной формы в 

обычную. Необходимые данные должны быть получены до того, как модальная 

форма будет уничтожена. Это удобно делать, в частности, через дополнительный 

параметр конструктора. В рассматриваемом примере таким параметром 

является указатель *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; 

} 

Контрольные вопросы 

1. В чем заключается разница между объявлением, определением и вызовом 

функций 

2. Как обмениваются данными функции 

3. В чем состоит разница между локальными и глобальными данными 

4. В чем разница между параметром функции и ее аргументом 

5. Существует ли разница в терминах функция, член-функция и метод

31 

6. Как передаются данные при вызове функции и при возврате результата в 

вызывающую функцию. 

7. В чем разница между переменными и константами 

8. Для чего члены класса делятся на закрытые и открытые 

9. В чем заключается разница между классом формы и объектом формы 

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

11. Для чего служит файл заголовка 

12. Для чего предназначен конструктор формы 

13. Для чего служат и как используются события 

14. Чем обработчик события отличается от других функций 

15. Как формы обмениваются данными между собой 

16. Для чего служат операторы New и delete 

17. Каковы главные особенности графических объектов 

18. Какую роль играет событие FormPaint при работе с графическими объектами 

19. Какую роль играют исключения и их обработчики 

20. Как выполняется отладка программ в режиме обработки исключений 

21. Нужно ли указывать типы данных при объявлении и инициализации переменных 

22. Чем различаются типы данных char, char* и AnsiString 

23. Чем различаются типы данных int, float и double 

24. Для чего функция имеет тип 

25. Что такое указатель 

26. Для чего используются параметры-указатели 

27. Для чего служат операторы доступа к данным 

28. Для чего служат логические операторы 

29. Для чего служат двоичные операторы 

30. Чем различаются операторы || и |, && и & 

31. Можно ли применять операторы отношения к данным типов char, char* и 

AnsiString 

32. Можно ли применять оператор присваивания к разнотипным данным 

33. Для чего служат и как используются методы класса AnsiString 

34. Для чего операторы ранжируются по приоритетам 

35. Что такое типизированные классы

32 

Составные операторы 

Длинна та дорога, где нет поворота 

Английская пословица 

Использование составных операторов – первый шаг к структурному 

программированию. До сих пор наши программы были линейными, они реализовали 

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

и кажутся более понятными, как более понятной бывает любая упрощенная 

модель. 

Ветвящиеся алгоритмы намного сложнее, но ближе к действительности, 

ибо «каждая точка нашей жизни есть точка выбора» (А. Даниэль). Такие 

алгоритмы реализуются с использованием составных операторов перехода, 

условия, выбора, цикла и повторения. Ветвления в программах часто оказываются 

опасными и скользкими. Только практика позволяет освоить технику 

выбора необходимых управляющих структур, грамотного выхода из составных 

операторов и обработки ошибочных ситуаций. 

Операторы перехода 

Ветвящиеся и циклические алгоритмы управления информационными 

процессами реализуются с помощью составных операторов. Такие операторы 

часто входят друг в друга, образуя управляющих структуры. 

Традиционным средством организации нелинейных процессов являются 

операторы перехода, служащие для изменения хода вычислительных процессов. 

К таким операторам относятся: break, continue, return, goto Метка. 

Первый из операторов перехода прекращает выполнение самого внутреннего 

из составных операторов, передавая управление следующему за прерываемым 

оператором. Второй прерывает выполнение составного оператора, 

передавая управление в его конец. Третий завершает выполнение функции. 

Оператор goto передает управление на метку внутри текущей функции, 

состоящую из имени и двоеточия. Применение его не поощряется в современном 

программировании, так как нарушает принцип процедурного подхода. 

«Goto - неизбежное зло, ибо программы с безусловными переходами 

трудно понять» [3]; «любая программа может обойтись без оператора goto» 

[5].

Условный оператор 

33 

С помощью условного оператора ход вычислительного процесса организуется 

в зависимости от значения логического выражения: 

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 = "Точка вне круга"; 

} 

Другой пример посвящен сравнению двух слов: 


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, 


drawing = false; Canvas–>TextOut (X, Y, "Стоп!"); 

}

void _ _fastcall TForm1::FormMouseMove (TObject *Sender, 

TShiftState Shift, int X, int Y) { 

if (drawing) Canvas–>LineTo (X, Y); 

} 

34 

Еще одна функция показывает работу методов Delete (удаление букв) и 

Length (длина строки) класса AnsiString в операции сцепления первой буквы 

слова a, точки и слова b: 


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; 

} 

Составные операторы могут иметь любую глубину вложенности. Но 

«вложенный набор операторов if...else иногда напоминает водопровод старого 

дома: система работает, но трудно понять, какая труба куда ведет» [9]. 

Оператор выбора 

Оператор выбора служит для организации хода вычислительного процесса 

в зависимости от значения выражения или переменной: 

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;

} 

35 

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); 

}; 

__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; 

// ch – переменная-счетчик цикла 

AnsiString alphabet; 

for (ch='A'; chLabel1–>Caption = alphabet; 

} 

36 

Во втором примере для извлечения символов в операциях сравнения 

строк и формирования строки символов алфавита служит метод 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; 

} 

Для досрочного завершения цикла в его тело включают операторы перехода. 

При отсутствии выражения условия или итерации образуются «вечные 

циклы», например for (;;). 

Операторы повторения 

Операторы повторения предназначены для организации вычислительных 

процессов, повторяющихся заранее неизвестное число раз. Различают 

операторы повторения с предусловием и с постусловием: 

while (истинноеЛогическоеВыражение ) Выражение… 

do Выражение… while (истинноеЛогическоеВыражение ); 

Значение логического выражения обычно меняется в теле оператора в 

ходе выполнения выражений. В противном случае образуются «вечные циклы» 

(endless repetition) типа while (1) или do while (!0). До начала работы оператора 

с предусловием должно быть сформировано истинное логическое выражение. 

Для досрочного завершения выполнения операторов повторения в 

выражениях размещаются операторы перехода. Примеры:

37 

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; 

} 

Оператор повторения с постусловием относится к числу наименее надежных 

управляющих структур, так как условие его завершения проверяется 

только после начала работы. 


int x = 9; 

do 

MyForm–>Label1–>Caption = MyForm–>Label1–>Caption + 

IntToStr (x––) + " в квадрате равно " + IntToStr (x * x) + '\n'; 

while (x); 

} 

А вот пример «вечного цикла», выход из которого возможен только с 

помощью оператора перехода: 


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 + " год"; 

}

Программирование диалогов 

38 

Составные операторы помогают организовать диалог с пользователем с 

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

особенно удобно на этапе подготовки и отладки приложений. 


Функции сообщений 

Функция 

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 




void __fastcall TForm1::Button1Click (TObject *Sender) { 

if (MessageDlg ("Создать/выбрать папку", mtConfirmation, 

TmsgDlgButtons ()

39 

В следующем примере последовательность окон сообщений информирует 

о владельце, объектах владения и дочерних компонентах некоторой 

формы, созданной в ходе выполнения программы. 

void OwnersAndParents () { 

AnsiString info; 

int i; 

ShowMessage ("Этой формой владеет " + MyForm–>Owner–>Name); 

for (i=0; iComponentCount; ++i) 

info = info + '\n' + MyForm–>Components[i]–>Name; 

ShowMessage ("Объекты владения формы " + info); 

info.Delete (1,info.Length ()); 

for (i=0; iControlCount; ++i) 

info = info + '\n' + MyForm–>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); 

} 


1. Для чего служат и как различаются между собой операторы перехода 

2. Как определить глубину вложенности составных операторов 

3. В чем состоит разница между условным оператором и оператором выбора 

4. Может ли оператор выбора использоваться без оператора break 

5. Может ли оператор выбора использоваться с операторами continue и goto 

6. Можно ли совмещать операторы условия и выбора 

7. Чем различаются операторы цикла и повторения и что у них общего 

8. Для чего применяется «вечный цикл» 

9. Для чего применяются цикл без счетчика, цикл без инициализации, цикл 

без итерации 

10. Какие окна диалога используются в Windows 

11. Что называют возвращаемым значением окна диалога 

12. Как используются возвращаемые значения окон диалога в составных операторах

40 

Введение в структурное программирование 

Подобное к подобному влечется 

Из Платона 

Концепция структурного программирования предполагает ранжирование 

алгоритма решения задачи по своеобразным «уровням абстрактных машин» 

[6]. При этом производится пошаговое уточнение алгоритма за счет 

расчленения задачи на подзадачи до тех пор, пока мельчайшую из подзадач 

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

структуры, объединения, списки, стеки, деки, деревья, векторы и т. п. являются 

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

Массивы 

Для группового представления и обработки однотипных данных применяются 

составные типы – массивы (array). В объявлениях массива используются 

прямоугольные скобки: 

Тип имяМассива [ [Размер] ]…[={списокЗначений} ]; 

Массивы инициализируются одним из двух способов: 

имяМассива [ Индекс ]…=Значение; 

имяМассива [ [Размер] ]…= { списокЗначений }; 

Размер и индекс относятся к целому типу. Они указываются в квадратных 

скобках вслед за именем массива. При наличии списка значений один из 

размеров можно опускать: он рассчитывается автоматически. 

Массивы индексируются с нуля. Число размеров определяет размерность 

массива, а число членов (элементов) массива равно произведению всех 

размеров. Пример: 

void Arrays1 () { 

AnsiString students[] = {"Иванов", "Петров", "Сидоров"}; 

MyForm–>Edit1–>Text = students[0]; 



}

41 

Число байтов, выделяемое массиву при инициализации, определяется 

как произведение размера типа и числа членов. Для резервирования и освобождения 

этой памяти целесообразно использовать выражения 

Пример: 

имяМассива = new Тип [ Размер ]…; 

delete [ ] имяМассива; 


AnsiString *whos; 

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; }

42 

Примером массива является свойство Cells компонента StringGrid, которым 

задается содержание ячейки, адресуемой индексами. Массивами описывают 

также отдельные панели строки состояния и строки списков. 


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] = "Нулевая строка списка"; 

} 

Массивы эффективно используются в графике, например, для рисования 

геометрических фигур по канве формы: 

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, 


Label1–>Caption = X; Label2–>Caption = Y; 

Label3–>Caption = Canvas–>Pixels[X][Y]; 

Canvas–>Pixels[X][Y] = clWhite; 

}

Перестановки и сортировки 

43 

Простым алгоритмом описывается широко распространенная в программировании 

операция перестановки (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”); 

} 

Следующий пример иллюстрирует перестановку членов массива: 

void Swap (AnsiString a[], int n) { 

int i, j; 

for (i=0, j=n–1; i

44 

Сортировка объединением предусматривает получение одной последовательности 

данных, построенной по определенному правилу, из двух и более 

последовательностей, построенных по тому же правилу. 

Простейший из алгоритмов сортировки – алгоритм упорядочения методом 

«пузырька» (bubble sorting). В нем последовательно проверяются все 

пары данных сортируемого массива, и там, где первый член больше второго, 

выполняется перестановка. 

Сортировка методом выборки минимального или максимального члена 

(exchange sorting) заключается в последовательной выборке наименьшего из 

оставшихся членов списка. При этом перебор списка проводится более медленно, 

чем сравнение предыдущим методом. Еще медленнее работает метод 

вставки (insertion sorting), когда члены просматриваются по одному, и каждый 

новый член вставляется в подходящее место среди ранее упорядоченных 

данных. Этот алгоритм эффективен при малых массивах (до 50 – 100 членов), 

особенно, если они частично отсортированы. По методу Шелла (Shell sorting), 

в отличие от «пузырька», переставляются не соседние, а далеко отстоящие 

члены, что иногда повышает скорость в 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

} 

45 

for (int i=1; i=0 + 1; – –j) 

if (array[j–1] > 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; 

} 

} 

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;

46 

} 

for (i=0; i 0, если elem1 больше, чем elem2: 

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. Это один из самых популярных 

классов, представляющий удобный контейнер для хранения строк 

и связанных с ними объектов. Методы класса позволяют загружать и сохра-

47 

нять, создавать списки, манипулировать строками, сортировать, вставлять, 

добавлять и удалять их. 

Временные списки и списки длительного пользования проектируют поразному. 

Первые обычно создаются и разрушаются в пределах одной функции: 


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) { 

delete ConstList; 

} 

void __fastcall TForm1::FormMouseDown (TObject *Sender, 


TVarRec v [] = {X,Y}; 

ConstList–>Add (Format ("Курсор в (%d,%d)", v, ARRAYSIZE (v) – 1)); 

} 

Новая строка в конец списка добавляется методом Add. Количество 

строк в списке вычисляется методом Count, а свойство Strings содержит весь 

массив строк, доступных по их индексам, начиная с 0. Метод IndexOf определяет 

индекс строки, содержащей указанный текст, например: 

void StringLists2 () { 

MyForm–>ConstList–>Add ("Конец"); 

MyForm–>ConstList–>Strings [ConstList–>Count–1] = 

MyForm–>ConstList–>IndexOf ("Конец"); 

} 

Чтобы добавить i-ю строку в список, используется метод Insert. Для 

добавления строк из другого списка служит методы Assign и AddStrings. 

Перемещение строк внутри списка выполняется методом Move. Удалением

48 

ремещение строк внутри списка выполняется методом Move. Удалением 

строки занимается метод Delete, а Clear очищает список: 


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); 

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); 

} 

49 

Структуры и объединения 

Упростить представление и групповую обработку разнотипных данных 

помогают структуры (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; 

} 


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 ("Заполнить ячейки"); } 

} 

50 

Следующий пример посвящен пузырьковой сортировке строк String- 

Grid с использованием структуры: 


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; 

} 

}

51 

При передаче в функцию в качестве аргументов могут использоваться 

как имена полей, так и указатели на адреса. Применение указателя в качестве 

значения аргумента избавляет от необходимости копирования в функцию 

всех данных, но в этом случае они остаются беззащитными перед изменениями 

в теле функции. Для устранения этой проблемы перед указателем 

можно помещать лексему const. Пример передачи данных структуры: 

struct x { int size, price; }; 

void Change1 (x y) { y.size = y.price; } 

void Change2 (x *y) { y–>size = y–>price; } 


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), изменяются в размере по 

мере заполнения и освобождения их от данных и обычно не требуют последовательного 

размещения элементов в памяти компьютера. Динамические 

структуры не входят в состав типов данных традиционных языков програм-

52 

мирования и присутствуют в них как классы. Они, как правило, разрабатываются 

программистами или берутся из библиотек – контейнеров. Каждая 

структура характеризуется порядком заполнения (allocation) и порядком обхода 

(traversal). 

Некоторые характеристики классов динамических структур C++Builder 

приведены в табл. 12: 


Свойства и методы контейнерных классов C++Builder 

Имя Член Классы Назначение 

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';

53 

} // 0 1 Иванов 2 Петров 3 Сидоров 

while (s–>AtLeast (1)) 

b += AnsiString (s–>Count ()) + ' ' + (char*) s–>Pop () + '\n'; 

ShowMessage (b + '0'); // 3 Сидоров 2 Петров 1 Иванов 0 

} 

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 ())); 

} 

Далее приведен пример разработки авторского символьного стека без 

привлечения библиотечного класса TSteak: 

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) { 


while (!Empty (stk)) result += AnsiString (stk–>s[stk–>top––]) + '\n'; 


} 

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

54 

TQueue *q = new TQueue; 

for (int i=0; iPush (a[i].c_str()); 

b += AnsiString (q–>Count ()) + ' ' + (char*) q–>Peek () + '\n'; 

} // 0 1 Иванов 2 Иванов 3 Иванов 

while (q–>AtLeast (1)) 

b += AnsiString (q–>Count ()) + ' ' + (char*) q–>Pop () + '\n'; 

ShowMessage (b + '0'); // 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; 

}

55 

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 Смирнов 

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; 

} 

Пример разработки авторского списка без привлечения библиотечного 

класса TList: 

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;

56 

last = current; 

} 

} 

void Info () { 


if (first) { 

result = "Список: "; 

current = first; 

do { result += AnsiString (current–>value) + ' '; current = current–>p; } 

while (current); 

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

Allocate (k[0], k[1], book1); Allocate (k[2], k[3], book2); 

for (i=0; i

58 

Можно использовать любой порядок заполнения узлов, но обычно этот 

порядок зависит от значений данных в них: узлы с меньшим значением присоединяют 

слева, а с большим значением – справа. Чтобы обойти дерево, отметив 

каждый узел один раз, используют один из трех способов (рис. 1). При 

прямом порядке обхода (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);

59 

else ShowMessage ("Такой член уже есть"); 

} 

} 

AnsiString Process (vTree *node) { 

static AnsiString result; 

result += AnsiString (node–>data) + ' '; 

return result; 

} 

AnsiString InOrder (vTree *node) { 


If (node != 0) { 

InOrder(node–>left); 

result = Process (node); 

InOrder (node–>right); 

} 

return result; 

} 

Стандартная библиотека STL 

Библиотека STL (Standard Templates Library) представляет набор шаблонов 

классов С++, включающий контейнеры, итераторы, аллокаторы и алгоритмы, 

в пространстве имен std. Контейнеры (container) служат классами, 

организующими хранение объектов. Неупорядоченные контейнеры представляют 

vector, list, deque. К упорядоченным контейнерам относятся set, 

map, hash-set, hash-map и их разновидности. Итераторами (iterator) называют 

средства перемещения по объектам контейнеров. Обычно эту роль играют 

указатели, поддерживающие итерацию. Итераторы бывают прямыми и 

обратными, константными и неконстантными, изменяющими содержимое 

контейнера. Низкоуровневые функции распределения памяти контейнеров 

называют аллокаторами (allocator). С их помощью все члены STL автоматически 

выделяют и освобождают память, не требуя от программиста использования 

операторов new и delete. Для манипулирования данными в контейнерах 

служат алгоритмы (algorithm). Обычно на них возлагаются стандартные 

операции сортировки, поиска, сравнения, перестановки и т.п. 

Контейнер vector, описанный в файле заголовка является динамическим 

массивом переменного размера. Подобно стеку, он обеспечивает 

добавление объектов в конец функцией push_back и удаление их оттуда 

функцией pop_back. Кроме того, в нем реализована вставка объектов в про-

60 

извольное место функцией 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, 

может заполняться и освобождаться от объектов с двух сторон. 

#include 


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

61 

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 


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) 

ListBox1–>Items–>Add (j–>first + '=' + FloatToStr (j–>second)); 

// e=2.718; pi=3.14159; Площадь круга=314.159; Скорость света=2998... 

} 

Алгоритм find выполняет поиск объектов контейнера между двумя установленными 

итераторами с возвращением итератора найденного объекта, а 

в случае отсутствия такового – с возвращением второго итератора. 

#include 

#include 


void __fastcall TForm1::findClick (TObject *Sender) { 

vector v;


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 ("Не нашел"); 

} 

62 

Алгоритмы min и max отыскивают экстремумы. 

#include 


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 


void __fastcall TForm1::sortClick (TObject *Sender) { 

vector v; 


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 ()); 

for (j = v.begin (); j!=v.end (); ++j) ListBox3–>Items–>Add (*j); 

} 

Алгоритм binary_search ищет объекты на бинарном дереве. 

#include 


void __fastcall TForm1::BinSearchClick (TObject *Sender) { 

// ab...z 

// zy...a

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]) " есть" : " нет")); 

} 

63 

Контейнер set поддерживает уникальные ключи и двунаправленные 

итераторы, являясь хранилищем упорядоченных объектов, удобным для поиска 

и сравнения с аналогичными хранилищами. Он незаменим для выполнения 

классических операций на множествах: принадлежности, объединения, 

пересечения, вычитания, дополнения. В отличие от vector и map, контейнер 

set не позволяет непосредственно воздействовать на значения объектов, требуя 

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

множество s1 заполняется числами, и эти же числа копируются в s2. Затем 

отыскивается и удаляется первая половина s2, остаток заполняется новыми 

числами, и вычисляются результаты объединения и пересечения s1 и s2. В 

программе работают алгоритмы advance – перемещение итератора, set_union 

– объединение, set_intersection – пересечение множеств. 

#include 

#include 


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 



} 

64 


1. Для чего предназначены массивы в программировании 

2. Как объявляются и инициализируются массивы 

3. Чем различаются статические и динамические массивы и в чем состоят 

достоинства и недостатки каждого из них 

4. Как передаются массивы в функции 

5. Какова связь между именем массива и его адресом Можно ли применять к 

массиву операцию взятия адреса. 

6. Как определяется адрес элемента массива по его индексу 

7. Каковы основные свойства компонента StringGrid 

8. Что такое рекурсия 

9. Какие свойства визуальных компонентов представлены массивами 

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

массива 

11. Каков принцип сортировки данных методом «пузырька» 

12. За сколько циклов выполняется сортировка методом «пузырька» 

13. Для чего функции qsort требуется в качестве аргумента авторская функция 

14. Чем структура отличается от массива 

15. В чем состоит разница между структурой и объединением 

16. Как инициализируются поля структуры 

17. Как рассчитывается объем памяти, занимаемый структурой 

18. Может ли структура содержать массив, а массив – структуру 

19. Какие известны динамические структуры данных 

20. Каков принцип действия стека 

21. Каков принцип действия очереди

22. Каков принцип действия линейного списка 

23. Каков принцип действия дека 

24. Чем определяется порядок обхода двоичного дерева 

25. Каково назначение стандартной библиотеки STL 

26. Каково назначение контейнеров и итераторов 

27. В чем состоит различие прямого и обратного итераторов 

28. Как организован контейнер map 

29. Как организован контейнер set 

30. Как подключается к проекту библиотека STL 

65 

Введение в модульное программирование 

Требуется гораздо больше ума, чтобы передать 

свои мысли, чем чтобы их иметь 

Из Гельвеция 

Концепция модульного программирования предполагает конструирование 

программ из модулей, т. е. групп файлов каждая из которых освещает 

свой раздел общей проблемы. Текстовые, графические, исполнительные файлы, 

ресурсы и библиотеки тесно переплетаются в модулях. Модуль визуального 

программирования часто состоит из файлов отдельных форм: кода, заголовка, 

структуры и диаграммы, к которым после компиляции добавляются 

объектные файлы. Особого внимания требуют такие модульные системы, как 

библиотеки статической и динамической компоновки, справочные средства и 

потоки данных [7]. 

Работа с текстовыми файлами 

Файл (file) представляет именованную область накопителя, предназначенную 

для хранения, передачи и приема структурированной информации. 

Число одновременно открытых файлов и их размер определяются возможностями 

операционной системы и ресурсами компьютера. 

Ряд визуальных компонентов поддерживает файловый обмен своими 

методами SaveToFile и LoadFromFile. К ним относится строковый класс 

TStrings и производные от него классы. 

В частности, для загрузки и сохранения строк в текстовом файле используются 

методы SaveToFile и LoadFromFile компонента TStringList, орга-

66 

низующие обмен таким образом, что каждая строка файла соответствует 

строке списка. Компонент можно применять для заполнения элементов 

управления классов Memo и RichEdit или для сохранения содержимого элементов 

управления классов List и ComboBox, например: 


TStringList *sl = new TStringList; 

sl–>Add (“Раз”); 

sl–>Add (“Два”); 

sl–>Add (“Три”); 

sl–>SaveToFile ("d:/Temp/File.txt")); 

sl–>Clear (); 

sl–>LoadFromFile ("d:/Temp/File.txt")); 

} 

// Заполнение поля Memo 


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; j

StringGrid1–>Cells[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); 

} 

67 

Для проведения файлового обмена без рассмотренных компонентов в 

C++Builder используются функции, приведенные в табл. 13. Работа с файлом 

ведется с помощью файловых переменных (file variable), связываемых с конкретными 

файлами. Файл открывается для чтения, записи или других операций. 

После работы файл следует закрыть. 


Функция 

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); 

} 

} 

68 

Во втором примере создается файл, в него заносятся два числа, и файл 

закрывается. Затем файл открывается для чтения и возвращается его содержимое. 

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; } 


ShowMessage (AnsiString (getStr, readLen)); 

} 

В третьем примере после открытия первого файла определяется его 

размер, указатель возвращается в начало, и в массив читается его содержимое. 

Затем открывается второй файл для записи в него содержимого массива.


AnsiString from = MyForm–>Edit1–>Text, to = MyForm–>Edit2–>Text; 

} 

try { 

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); 


iFile = FileOpen (to, fmOpenWrite); 

FileWrite (iFile, c, len); 

ShowMessage (from + " –> " + to + '\n' + AnsiString (c, len)); 

delete [] c; 


} catch (...) { ShowMessage ("Ошибка одной из файловых операций"); } 

69 

Аналогичный пример посвящен отображению содержания файла в 

надписи 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); 


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 ());


} 

} 

70 

Следующий пример посвящен изменению содержимого файла. Вначале 

текст файла считывается в массив, который преобразуется в строку. В этой 

строке отыскивается заданное слово и заменяется фразой «[Удалено]», а 

файл заполняется пробелами. После этого измененная строка возвращается в 

файл. 


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); 


AnsiString c = AnsiString::StringOfChar (' ', bLen); 

FileWrite (bFile, c.c_str (), bLen); 


FileWrite (bFile, bText.c_str (), bText.Length ()); 

FileClose (bFile); 

} catch (...) { ShowMessage ("Ошибка файловой операции"); } 

ShowMessage (bText); 

} 

Пример удаления фрагмента, заданного в 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 ()); 


} 

} 

71 

Еще один пример демонстрирует процесс поиска файла, в том числе с 

символом подстановки *, в текущей папке и в папке Windows: 


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 + " !"); 

} 

Работа с графическими файлами 

К графическим компонентам, поддерживающим файловый обмен 

своими методами SaveToFile и LoadFromFile, относятся TPicture, TOLE- 

Graphic, TGraphic и производные от них классы. Рассмотрим несколько примеров: 

Пример использования графических файлов: 

// Картинки из файлов 

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); 

SpeedButton1–>Glyph–>LoadFromFile (fName); 

} 

72 

Некоторые особенности использования компонента Image отражает 

табл. 14. 


Свойство 

Picture 

Width, Height 

Proportional 

Strech 

AutoSize 

Center 

Visible 

Canvas 

Свойства компонента Image 


Отображаемый файл 

Ширина и высота 

Автоматическое масштабирование без искажения иллюстрации в границах 

элемента управления 

Подгонка иллюстрации под размер элемента управления с искажением 

Подгонка элемента управления под размер иллюстрации 

Размещение иллюстрации в центре элемента управления 

Вывод на экран 

Экранная поверхность для отображения 

Компонент поддерживает графические форматы .BMP, .ICO и .WMF. 

Для работы с форматом .JPG надо подключить файл заголовка . 

Следующий пример показывает функцию, отображающую первый из 

графических файлов, размещенных в папке приложения, а также вариант ее 

использования: 

#include 

#include // для работы функции SelectDirectory 

AnsiString myPath = “”; // текущая папка с иллюстрациями 

TSearchRec sr; 

// результат поиска 

void TForm1::FirstPicture () { 

if (FindFirst (myPath + “*.jpg”, faAnyFile, sr) == 0) { 

Image1–>Picture–>LoadFromFile (myPath + sr.Name); 

Label1–>Caption = sr.Name; 

}

73 

Фрагмент обработчика кнопки перехода на следующий файл текущей 

папки может быть таким: 

if (FindNext (sr) == 0) { 

Image1–>Picture–>LoadFromFile (myPath + sr.Name); 

Label1–>Caption = sr.Name; 

} 

В свою очередь, обработчик кнопки поиска файлов открывает стандартное 

окно поиска папки с файлами и вновь вызывает функцию отображения 

первого файла папки: 

if (SelectDirectory ("Выбор папки", "", myPath)) 

{ myPath += "\\"; FirstPicture (); } 

Визуальный компонент Bitmap поддерживает работу с битовыми образами 

– небольшими картинками формата .BMP, которыми удобно манипулировать 

в памяти компьютера, обращаясь к свойствам (табл. 15) и методам 

компонента. 


Свойство 

Width, Height 

Empty 

Transparent 

TransparentColor 

Canvas 

Свойства компонента Bitmap 


Ширина и высота загружаемой иллюстрации 

Признак отсутствия иллюстрации 

Устанавливает «прозрачность», т. е. не отображает цвет, указанный в 

свойстве TransparentColor, по умолчанию – цвет нижнего левого 

пиксела 

Прозрачный цвет, который не выводится на экран при установленном 

свойстве Transparent 

Экранная поверхность для отображения 

Следующий пример демонстрирует мультипликацию – движение 

битового образа sprite на фоне иллюстрации back. Рисование образа по канве 

Canvas выполняется методом канвы Draw в событии формы FormPaint по командам 

невидимого объекта класса Timer (Interval 100 мс). Координаты x, y и 

объекты back и sprite созданы как переменные формы: 


int x, y; 

Graphics::TBitmap *back = new Graphics::TBitmap; 

Graphics::TBitmap *sprite = new Graphics::TBitmap; 

__fastcall TForm1::TForm1 (TComponent* Owner) : TForm (Owner) { 

back–>LoadFromFile ("1.bmp");

sprite–>LoadFromFile ("2.bmp"); 

sprite–>Transparent = true; 

x = –20; 

// исходная позиция за пределами формы 

y = 20; 

} 

void __fastcall TForm1::FormPaint (TObject *Sender) { 

Canvas–>Draw (0, 0, back); 

// отображение фона 

Canvas–>Draw (x, y, sprite); 

// и объекта 

} 

void __fastcall TForm1::Timer1Timer (TObject *Sender) { 

TRect reback; 

// восстанавливаемая область фона 

reback = Rect (x, y, x+sprite–>Width, y+sprite–>Height); 

Canvas–>CopyRect (reback, back–>Canvas, reback); // восстановление 

x += 2; 

// движение вправо 

if (x > ClientWidth) x = –20; 

// возврат 

Canvas–>Draw (x, y, sprite); 

// рисование объекта 

} 

74 

Работа с двоичными файлами 

Разработано множество способов запуска исполнительных файлов из 

приложений C++. 

В файле заголовка объявлена группа функций семейства 

exec… Эти функции загружают в память и открывают исполнительные файлы 

(дочерние процессы), одновременно лишая ресурсов и прекращая родительский 

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

вызываемому дочернему процессу, а при запуске каждая такая функция передает 

несколько дополнительных параметров этому процессу: 

exec…(путь, параметры). 

Например: 

execl (“MyFile.exe”, “MyFile.exe”, NULL); 

Суффиксы l, v, p, e, добавляемые к имени exec, раскрывают требования 

к параметрам. Так, l свидетельствует о постоянном фиксированном числе параметров, 

v говорит о непостоянном массиве указателей в списке параметров, 

p указывает, что путь следует искать в переменной окружения path, а e – в 

списке параметров окружения дочернего процесса. 

В случае неудачного запуска exec… возвращает –1, а глобальная переменная 

errno устанавливается в одно из следующих значений: EACCESS –

75 

отказ в доступе, EMFILE – много открытых файлов, ENOENT – не найден 

путь, ENOEXEC – мало памяти. 

В файле заголовка shellapi.h объявлена серия полезных функций запуска 

приложений без закрытия родительского процесса. Среди них – WinExec, 

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, 

информацией о вызывающем приложении, а приложение, в свою очередь, 

лучше контролирует поведение связанного модуля. К сожалению BPL обслуживают 

только приложения C++Builder, тогда как DLL более универсальны 

и работают с любыми приложениями в разных операционных системах. 

Модули DLL и BPL можно подключать к приложению статически (design 

time mode) и динамически (runtime mode). Статически загружаемые модули 

связываются с главной программой при ее компоновке и остаются загруженными 

в память все время, пока выполняется приложение. Такие модули 

содержат экспортируемые функции, описание которых помещается в файлы 

библиотек импорта LIB – Library Import File, которые также подключаются 

на этапе компоновки. Динамически загружаемые модули в процессе работы 

при необходимости можно выгружать из памяти, освобождая при этом ре-

76 

сурсы. В ряде режимов возможна работа таких приложений и без них. Дополнительные 

библиотеки импорта здесь не используются. 

Библиотека 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); 

Лексема __declspec со спецификатором класса памяти dllexport гарантирует 

совместимость библиотеки с Microsoft C/C++. После компоновки проекта 

будет создан файл библиотеки (.LIB) и исполняемый файл (.DLL). 

Для статического подключения DLL к имеющемуся проекту надо добавить 

в него файл .LIB (Project.Add to Project) из проекта DLL и включить 

файл заголовка из DLL. После компоновки можно обращаться к хранящимся 

там данным. 

Пример использования библиотечных функций:

77 

//myApplication.cpp 

#include "myDLL.h" 

void __fastcall TForm1::Button1Click (TObject *Sender) { Message ("Привет "); } 

void __fastcall TForm1::Button2Click (TObject *Sender) { About ("Привет "); } 

Динамическое подключение выполняется иначе: 


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 – файл заголовка; 

.LIB – статическая библиотека (коллекция файлов OBJ) для подключения 

в режиме design time, если установлен параметр компиляции GI (Generate 

LIB file); 

.OBJ – двоичный образ модуля пакета.

78 

Для динамического подключения пакетов вызывающее приложение 

следует оснащать функциями LoadPackage и FreePackage вместо LoadLibrary 

и FreeLibrary. 

Ресурсы 

Ресурсы – это битовые образы, хранящиеся непосредственно в исполнительном 

файле, а не отдельно от приложения. При создании приложения 

ресурсы помещаются в файл ресурсов проекта .RES автоматически или командой 

SaveToResource и могут загружаться из него командой LoadFromResource. 

Ресурсы создаются с помощью встроенного в C++Builder графического 

редактора Image Editor и им же включаются в файл ресурсов приложения как 

графические образы Bitmaps, указатели мыши Cursors и значки Icons. Этот 

же редактор используется для создания отдельных файлов типов .RES, .BMP, 

.ICO, .CUR, которые впоследствии могут быть подключены к другим проектам. 

Например, для добавления в текущий файл ресурсов нового значка надо 

в меню File.Open редактора Image Editor открыть файл ресурсов проекта 

(.RES). Далее через меню Resource.New.Icon создать новый значок и, выделив 

его, открыть окно редактора (Resource.Edit), нарисовать или импортировать 

значок и закрыть окно. Через меню Resource.Rename назвать значок, 

например, MYICON. и сохранить его. 

Аналогичным образом через меню Resource.New.Cursor создать новый 

курсор, открыть окно редактора, нарисовать или импортировать курсор и закрыть 

окно. Через меню Resource.Rename назвать курсор, например, 

MYCURSOR. В заключение остается сохранить файл ресурсов и закрыть 

Image Editor. 

Для создания нового файла ресурсов с графическим образом дается команда 

New.Resource File в меню File. В окне ресурсов новый рисунок формируется 

по команде Resource.New.Bitmap редактором Resource.Edit или копируется 

через буфер обмена и сохраняется (File.Save) в одной папке с приложением. 

Пользуясь Image Editor, таким же путем создаются отдельные файлы 

значков и курсоры.

79 

Для подключения нового файла ресурсов к проекту вводится директива 

препроцессора #pragma resource "имяФайла.res" и дается команда загрузки, 

например: 

Image1–>LoadFromResourceName ((int)HInstance, “имяРесурса”) 

Примеры подключения новых курсоров и значков: 

const TCursor cur = 5; 

// свободная константа 

Screen–>Cursors[cur] = LoadCursor (HInstance, "MYCURSOR"); 

Cursor = cur; 

// новый курсор 

Icon–>Handle = LoadIcon (HInstance, "MYICON"); // новый значок 

Значки и курсоры из отдельных файлов подключаются методом 

LoadFromFile (имяФайла.ico) объекта Icon и функцией LoadCursorFromFile 

(имяФайла.cur) вместо LoadCursor. 

Для работы с обновленным файлом ресурсов следует закрыть приложение, 

затем вновь открыть и перестроить его. 

Потоки 

Потоки – это отдельно работающие части одной программы. Многие 

программы используют несколько потоков, среди которых можно выделить 

первичный поток, отвечающий за создание окон и обработку сообщений, и 

вторичные потоки, в которых выполняются фоновые операции: загрузка 

больших файлов, проведение вычислений и т. п. 

В С++Builder потоками управляет абстрактный класс TThread, и каждый 

вторичный поток представляет отдельный экземпляр наследника этого 

класса. 

Поток создается через меню File.New на базе шаблона TThread Object в 

виде модуля без формы и кроме обычного конструктора содержит заготовку 

исполнительного метода Execute. В отличие от конструктора формы, конструктор 

потока имеет параметр CreateSuspended. Когда он установлен (true), 

созданный поток сразу не запускается, а ожидает вызова стартового метода 

Resume. В противном случае сразу вслед за созданием происходит запуск 

потока. 

Наиболее распространенные характеристики класса TThread приведены 

в табл. 16.

80 

Свойства и методы объектов Thread 


Свойство, метод 

FreeOnTerminate 

Handle 

Priority 

ReturnValue 

Suspended 

Terminated 

ThreadID 

DoTerminate () 

Execute () 

Resume () 

Suspend () 

Synchronize () 

Terminate () 

WaitFor () 


Автоматическое удаление потокового объекта по завершении работы 

потока 

Дескриптор потока для вызова функций API 

Приоритет потока 

Возвращаемое значение по завершении работы потока 

Признак приостановки работы потока 

Признак прекращения работы потока 

Идентификатор потока 

Вызов обработчика события OnTerminate без прекращения работы 

потока 

Код, выполняемый при запуске потока 

Возобновление работы приостановленного потока 

Приостановка работы потока 

Синхронизация обращения к библиотеке VCL в первичном потоке 

Прекращение работы потока 

Ожидание прекращения работы потока 

В метод Execute программист должен поместить код, который будет 

выполняться после загрузки потока в фоновом режиме по отношению к первичному 

потоку. Кроме того, в метод Execute обычно включают еще три выражения: 

if (Terminated) break; 

FreeOnTerminate = true; 

// для прекращения работы потока 

// для автоматического освобождения памяти 

// потоком после завершения его работы 

Synchronize (имяФункции); // для синхронизации доступа к объектам 

// библиотеки VCL, за исключением 

// графических объектов 

Функцию, имя которой выступает в качестве аргумента метода Synchronize, 

объявляют и определяют в этом же файле потока, например: 

void __fastcall TThread1::Display () { Form1–>Label1–>Caption = “Пример”; } 

Для работы с формой в файл кода потока включают заголовок файла 

формы. Если в методе Execute присутствует код работы с графикой, его обрамляют 

выражениями, блокирующими вывод графики из других потоков: 

Form1–>Image1–>Сanvas1–>Lock (); 

Вывод графики на канву 

Form1–>Image1–>Сanvas1–>Unlock ();

81 

Управление созданным потоком осуществляется из первичного потока, 

обычно – из формы. Для этого в файл кода формы включается заголовок 

файла потока. В класс формы добавляется ссылка на объект потока, например, 

TThread1 *thread, в конструкторе формы создается экземпляр потока, 

который потом используется по ходу программы: 

… 

TThread1 *thread; 

… 

thread = new TThread1 (true); 

… 

thread->Resume (); 

… 

thread–>Suspend (); 

… 

thread–>Terminate (); 

… 

// запуск потока 

// приостановка 

// завершение 

Дистрибутивы 

Установка приложений на компьютере пользователя обычно производится 

с помощью инсталляционного пакета – дистрибутива. Такие файловые 

пакеты готовятся с использованием программы InstallShield Express, которая 

создает проект – Setup Project – и в специальной среде разработки помогает 

программисту выполнить необходимые этапы подготовки дистрибутива. 

На этапе организации дистрибутива вводятся основные сведения (general 

information) об авторе, фирме, теме и названии программного продукта, 

которые при установке будут занесены в реестр для последующего изменения 

или удаления приложения. Здесь же назначается папка для установки 

(INSTALLDIR) и приводится дополнительная информация. Разработчик определяет 

составные части (features) дистрибутива, его программные, графические, 

библиотечные, справочные файлы и разделяет их на две группы. 

Первая часть файлов устанавливается в обязательном порядке (always install), 

тогда как вторая – по желанию пользователя (custom setup). В зависимости от 

наличия или отсутствия второй части намечаются три способа установки 

продукта: Typical – автоматическое развертывание наиболее важных с точки 

зрения разработчика файлов, Minimal – автоматическое развертывание минимально 

допустимого набора файлов, Custom – автоматическая установка

82 

обязательных файлов и произвольное развертывание файлов, выбираемых 

пользователем. 

На этапе определения состава приложения (specify application data) 

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

InstallShield Express становится подобной Проводнику Windows, поддерживая 

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

(drag & drop). Пользуясь этим инструментом, разработчик копирует 

файлы из папок своего компьютера (source computer) в будущие папки машины 

пользователя (destination computer). Здесь же определяется потребность 

в дополнительных модулях и библиотеках (merge modules) и проверяется 

зависимость файлов приложения от программной среды (dependencies). 

На следующем этапе проектирования дистрибутива планируются действия 

по конфигурированию системы пользователя (target system). При этом 

задаются папки и ярлыки, которые потребуется создать; изменения, которые 

предстоит провести в меню, в реестре и в файлах инициализации (.ini); ресурсы, 

драйверы, базы и источники данных, которые необходимо сгенерировать. 

Задаются типы файлов (file extensions), которые развертываемое приложение 

будет обрабатывать особым образом. 

Далее формируется интерфейс пользователя дистрибутива. Разработчику 

предлагаются 12 стандартных окон диалога и баннеры для их оформления. 

В состав окон, которые можно использовать в ходе установки, входят: 

стартовое окно (Install Welcome), лицензионное соглашение (EULA – End- 

User License Agreement), комментарии к установке (Readme), сведения о 

пользователе (Customer Information), путь развертывания приложения (Destination 

Folder), выбор типа установки (Tipical/Minimal/Custom), стартовое 

предупреждение (Ready To Install), наблюдение за ходом установки (Setup 

Progress), завершение (Complete Success) и др. 

В ходе подготовки дистрибутива формируются, также, требования к 

аппаратному и программному обеспечению пользователя, производится создание 

дистрибутивных носителейи выполняется тестирование созданного 

продукта. Не покидая среды InstallShield Express, разработчик может провести 

имитацию установки приложения на своей машине, а также пробную установку 

программы. 

Проект сохраняется для последующего совершенствования или использования 

при создании других дистрибутивов.

83 


1. Какие визуальные компоненты поддерживают файловые метолы 

2. Как называется и для чего предназначено значение, возвращаемое функциями 

FileCreate и FileOpen 

3. Для чего предназначена функция FileSeek и какие аргументы требуются 

для ее вызова 

4. Какие параметры имеет функция FileWrite 

5. Как программируется работа с графическими файлами 

6. В чем состоит принцип мультипликации 

7. Какие функции используются для открытия исполнительных файлов 

8. Как выполняется статическая компоновка 

9. Как выполняется динамическая компоновка 

10. В чем заключаются преимущества и недостатки пакетов перед библиотеками 

DLL 

11. Какие ресурсы можно использовать в приложениях 

12. В чем различие между файлом ресурсов и встроенными в приложение ресурсами 

13. Для чего используется многопоточное программирование 

14. Для чего служит переменная FreeOnTerminate класса TThread 

15. Зачем нужен параметр в конструкторе класса TThread 

16. Что входит в состав дистрибутива 

17. Какие этапы сопровождают установку программного продукта 

Приложения баз данных 

У памяти хороший вкус 

Французское изречение 

База данных – это хранилище информации, организуемое и обрабатываемое 

в накопителях в соответствии с определенными правилами хранения 

и доступа. Логическая автономность данных является первым существенным 

отличием баз данных от прочего программного обеспечения. Строго 

оговоренная принадлежность данных к определенным классам и их безусловная 

типизация отличает базу данных от текстовых и табличных процессоров, 

а широкая гамма допустимых операций над множествами является важным 

преимуществом ее перед пакетами прикладных программ и системами

84 

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

обеспечения способствует эффективной структуризации информации, 

сведению к минимуму повторяющихся данных, ускорению обработки информации 

прямо на носителе, удобству обновления документов, обеспечению 

целостности данных, регулированию прав доступа к информации, облегчению 

автоматизации обработки данных и ведения отчетности. 

C++Builder позволяет создавать эффективные СУБД – системы управления 

базами данных (DBMS). 

Технологии создания приложений баз данных 

Для поддержки приложений баз данных разработаны различные технологии, 

приведенные в табл. 17. 


Технология 

ADO 

BDE 

dbExpress 

Технологии доступа к базам данных 

Область применения 

Все базы данных, поддерживающие стандарт OLE DB 

Реляционные базы данных xBase, Paradox, InterBase 

Различные базы данных 

Универсальная технология ADO – ActiveX Database Objects – разработана 

в «Microsoft» в соответствии со стандартом OLE DB (Object Linking and 

Embedding of DataBases). Она является развитием ODBC (Open DataBase 

Connectivity) – открытой двухуровневой системы подключения баз данных, 

ставшей стандартом для большинства приложений. Верхний уровень (клиент 

ODBC) играет роль интерфейса с приложением и поддерживает стандартные 

функции API. Нижний уровень выполняет функции специализированного 

драйвера преобразования информации в соответствии с форматом конкретной 

СУБД (сервера ODBC). Средства поддержки ADO строятся как модели 

составных объектов COM (Component Object Model). Технология ориентирована 

на Интернет (HTTP, InternetExpress, FastNet) и сети, работающие под 

Windows, при взаимодействии с любыми СУБД, оснащенными драйверами 

ODBC. Кроме того, ADO предлагает разработчикам поддержку данных, хранящихся 

в не реляционном формате, например XML или сообщений электронной 

почты. Специальные версии ADO относятся к категории распределенных 

(многоуровневых) архитектур. В них программы разделяются на секции, 

взаимодействующие на основе разнообразных протоколов. Это CORBA

85 

для построения масштабируемых приложений, не зависящих от платформ; 

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, а): 

• интерфейс пользователя (user interface); 

• компоненты связи интерфейса пользователя с наборами данных, 

именуемые источниками данных (data sources); 

• наборы данных (datasets), представляющие записи таблиц и запросов 

баз данных; 

• средства подключения к базам данных (data connections).

Программа 

86 

Программа 

Application server 

Интерфейс 

(User interface) 

Источник данных 

(Data source) 

Набор данных 

(Dataset) 

Подключение 

(Data connection) 

Данные 

Интерфейс 

пользователя 

Источник данных 

клиента 

Набор данных 

клиента 

Подключение 

к серверу 

Client 

Источник сервера 

(Provider) 

Целевой 

набор данных 

(Unidirectional 

data source) 

SQL-соединение 

(SQL connection) 

Сервер базы данных 

(Database server) 

а. б. 

Рис. 2. Варианты организации приложений баз данных 

Интерфейс пользователя строится на базе традиционных форм. Источники 

данных связывают интерфейс пользователя с наборами данных. При 

этом несколько элементов управления интерфейса можно подключать к одному 

источнику данных для синхронной обработки одной и той же информации. 

Основу приложений составляют наборы данных, представляющие даталогические 

модели одной или нескольких таблиц или запросов и отражающие 

состояние и изменение физических данных носителя информации. Каждой 

таблице или запросу ставится в соответствие свой набор данных. 

Архитектуры приложений баз данных 

Наборы данных различных типов используют разнообразные механизмы 

подключения к данным, которые, в свою очередь, определяют архитектуру 

приложений баз данных. К основным способам подключения относятся: 

• прямое подключение; 

• подключение через вспомогательный набор данных; 

• архитектура «клиент-сервер».

87 

В 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,б. В отличие от предыдущих архитектур, 

для подключения здесь привлекается источник данных сервера – провайдер, 

к которому обращается клиент для получения или передачи данных. 

Приложение-сервер может предоставлять запрошенные данные или отказывать 

в сервисе в зависимости от принятой стратегии управления и ситуации в 

сети.

88 

Подключение к базам данных 

Хорошим стилем программирования считается отделение интерфейса 

пользователя от компонентов связи с базой данных. Этим достигается повышенная 

гибкость проекта, позволяющая менять средства связи независимо от 

интерфейса или усовершенствовать интерфейс без изменения подключений. 

Инструментом такого разделения в C++Builder служат модули данных Data 

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) 

можно ознакомиться, если открыть Администратор источников данных

89 

ODBC в папке Панель управления Windows. Вкладки этой программы посвящены 

трем категориям источников: 

• пользовательский DSN единственного пользователя одного компьютера; 

• системный DSN всех пользователей компьютера; 

• файловый DSN, доступный всем пользователям сети, имеющих 

одинаковые драйверы, независимо от компьютера. 

На отдельной вкладке представлены установленные на компьютере 

драйверы ODBC. Для работы с конкретной базой данных обычно подключают 

имеющийся или создают новый источник данных, используя соответствующий 

драйвер. Этот источник впоследствии распространяют в комплекте с 

приложением и базой данных. 

Поэтому для формирования строки подключения под кнопкой Build 

обычно выбирается Microsoft OLE DB Provider for ODBC Drivers, служащий 

универсальным механизмом доступа к продуктам «Microsoft». На вкладке 

Connection этого же окна в поле переключателя Use connection string под 

кнопкой Build выбирается источник данных. Если требуемый источник данных 

отсутствует и его следует создать, то в поле DSN Name под кнопкой 

New указывается одна из строк: 

• Microsoft Access Driver, обслуживающая Microsoft Access; 

• Microsoft dBase Driver для работы с базами xBase; 

• Microsoft Excel Driver для работы с таблицами Microsoft 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, ""); 

Доступ к записям таблиц 

90 

Доступ к записям реализуется через таблицы, запросы и хранимые 

процедуры баз данных. 

Для работы с таблицами с помощью компонента ADOTable вкладки 

ADO в модуль данных добавляются элементы управления доступом к каждой 

таблице. Их свойство Connection инициализируется именем объекта 

ADOConnection, а в свойство TableName вписываются имена соответствующих 

таблиц. Каждый элемент управления ADOTable аккумулирует все записи 

и поля своей таблицы. 

Для подключения к форме с помощью компонента DataSource вкладки 

Data Access панели компонентов в модуль данных добавляется источник 

данных для каждой таблицы. В их свойстве DataSet указываются имена соответствующих 

компонентов ADOTable. Свойство AutoEdit разрешает режим 

редактирования записей, вводимых в поля наборов данных. 

После подключения в модуле данных устанавливается в true свойство 

Active элементов доступа к таблицам для их открытия. Аналогично выполняется 

открытие таблиц из программы, например: 

ADOTable1–>TableName = "Countries"; 

ADOTable1–>Active = true; 

Следующий пример демонстрирует подключение к файлу MYDBF.DSN, 

соединяющему с базой данных формата FoxPro, dBase или Clipper с открытием 

таблицы 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 { 




rst–>TableName = "T"; 


} catch (...) { ShowMessage (s); } 

} 

} 

91 

Возможно подключение и при отсутствии файла .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 { 




rst–>TableName = "Т"; 


} 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"; 


DBGrid1–>DataSource = DataModule1–>DataSourceXLS; 

} catch (...) { ShowMessage (“Не подключились”); } 

} 

Работа с запросами 

92 

К подключенной базе данных можно обращаться с запросами на выборку, 

создание, обновление и удаление таблиц. Для этого на вкладке ADO 

присутствует компонент ADOQuery, создающий объекты-запросы. В свойстве 

Connection этого компонента указывается имя объекта ADOConnection, а в 

редакторе свойства SQL формируется требуемое SQL–выражение. Примеры 

запросов на выборку: 

select * from Robots where radius > 10 

select model, country, mass from Robots 

Через запросы на выборку при необходимости формируются вычисляемые 

(расчетные) поля. В следующих примерах с помощью расчетов создаются 

поля inertia и ценаВВалюте: 

select model, country, mass*radius*radius as inertia from Robots 

select модель, цена, цена/30 as ценаВВалюте from Товары 

Запросы на выборку удобны, также, для нахождения итоговых результатов: 

минимума, максимума, среднего по полю: 

select min (цена) as минимум, max (цена) as максимум, avg (цена) as 

среднее from Товары 

В свойстве SQL одного компонента сохраняется только один запрос. 

Поэтому ввод каждой строки запроса надо завершать установкой свойства 

Active в true для его проверки и выполнения. При этом C++Builder передает 

запрос серверу, который выполняет его и возвращает приложению результирующий 

набор (result set). С этой же целью удобно использовать метод Requery, 

обновляющий элемент управления.

93 

Для подключения запросов на выборку к форме, в модуль данных добавляются 

источники данных DataSource. 

Запросы действия, не возвращающие наборов данных, можно формировать 

как с помощью компонента TADOQuery, так и с использованием TA- 

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

или программным путем вводится следующее выражение SQL и 

вновь повторяется активизация элемента управления. В свою очередь, компонент 

TADOCommand, как правило, используется только для программной 

реализации запросов. Текстом запроса в нем инициализируется свойство 

CommandText, а для выполнения запроса запускается метод Execute. 

Примеры запросов на создание таблицы Robots с ключевым полем 

model и таблицы Countries с ключевым полем country: 

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)) 

Следующие примеры посвящены вставке в таблицу Robots новой записи, 

замене названия страны и удалению всех записей, удовлетворяющих определенному 

условию: 

insert into Robots values ('Тест', 'Россия', 'Сферическая', 3, 5 ) 

update Robots set country='Франция' where country='Россия' 

delete from Robots where country='Франция' 

В последнем примере приведен фрагмент программы заполнения случайными 

числами двух полей таблицы T, содержащей три записи: 

TADOCommand *ac = ADOCommand1; 

for (int i=0; iCommandText = “iisert into T(field1, field2) values (” + 

FloatToStr (random (100)) + “,” + FloatToStr (random (100)) + “)”; 

ac–>Execute (); 

} 

Связывание таблиц и запросов 

Формирование базы данных при необходимости продолжают на вкладке 

Diagram модуля данных, где из элементов управления ADOTable и ADO- 

Query собирается структурная схема базы данных. На вкладке Diagram между 

ними можно просматривать и устанавливать связи четырех типов:

94 

• Property от дочернего элемента управления к родителю (сплошная 

линия со стрелкой), например, от полей к таблице; 

• Master/Detail от главной таблицы (master) к подчиненной (detail) (линия, 

на которой главная таблица помечена большим прямоугольником, 

а подчиненная – маленьким прямоугольником и указано поле 

связи); 

• типа Lookup (линия с изображением глаза); 

• ссылка Comment Allude (стрелка). 

Пользуясь контекстными меню, эти связи удобно удалять и редактировать. 

При этом тип Lookup отображает поля подстановки данных из других 

таблиц, а Comment Allude подключает комментарии Comment Block к компонентам 

структуры, облегчая тем самым оформление схемы базы данных перед 

выводом ее в печать командой Print контекстного меню. 

Чтобы связать между собой две таблицы, следует при нажатой кнопке 

Master/Detail провести линию от главной таблицы к подчиненной, и в открывшемся 

окне указать имена зависимых полей и нажать кнопку Add. В результате 

автоматически заполнится свойство MasterFields подчиненной таблицы 

именем соответствующего поля главной таблицы MasterSource. Эти же 

данные можно занести вручную через редакторы названных свойств. 

Чтобы создать в неактивной таблице новое поле подстановки, следует в 

контекстном редакторе ее ветви Fields окна Object TreeView выбрать New 

Field и, установив переключатель Lookup, задать имя, тип и размер поля, 

ключи (Key), источник (Dataset) и поле подстановки (Result Field). 

Подготовленный модуль данных сохраняется, и в редакторе форм подключается 

к модулю формы (File.Include Unit Hdr). В форму помещаются элементы 

управления данными с вкладки Data Controls панели компонентов. 

Это таблицы DBGrid и навигаторы DBNavigator, а также поля таблиц DBText, 

DBEdit, DBMemo, DBImage и другие. Компоненты вкладки Data Controls отличаются 

от рассмотренных ранее компонентов вкладки Standard наличием 

свойств DataSource и DataField, обеспечивающих их совместную работу с 

источниками данных. В свойстве DataSource указываются соответствующие 

объекты модуля данных, а в DataField – поля таблиц и запросов. Здесь также 

возможна подстановка (свойство столбца PickList), но не из таблицы, а из 

фиксированного списка значений.

95 


1. В чем преимущества баз данных перед авторскими файлами данных 

2. Каковы основные характеристики реляционных СУБД 

3. Каковы достоинства и недостатки технологии ADO 

4. Каковы достоинства и недостатки технологии BDE 

5. Каковы достоинства и недостатки технологии DBExpress 

6. Какие звенья служат для подключения приложения к базам данных 

7. Что называется провайдером (поставщиком) и источником данных, через 

которых осуществляется подключение 

8. Через какие визуальные компоненты выполняется редактирование данных 

в подключенных таблицах 

9. Какие функции выполняют запросы действия 

10. В чем разница между компонентами TADOQuery и TADOCommand 

11. Для чего и как производится связывание таблиц 

12. Чем различаются поля PickUp и Loolup 

Объектно-ориентированное программирование 

Что посеешь, то и пожнешь 

Русская пословица 

Концепция объектно-ориентированного программирования предполагает 

конструирование программ из объектов – представителей классов. В качестве 

классов выступают библиотечные и пользовательские типы даных с 

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

способствует экономии памяти и упрощает описание и отображение объектов, 

облегчает их систематизацию и стандартизацию. Формирование программ 

из объектов является основным инструментом современного программирования. 

Главными механизмами объектно-ориентированного подхода 

служат инкапсуляция, полиморфизм и наследование. 

Инкапсуляция 

Создание авторских классов начинается с их объявления в файле заголовка 

модуля. После объявления или одновременно с ним класс определяется 

(описывается). Встроенное объявление и определение членов выполняется в 

формате обычных переменных и функций:

96 

class имяКласса { 

[Метка] 

[объявлениеЧленов…] 

[встроенноеОпределениеЧленов…] }; 

Если не дается встроенное определение, в файле кода модуля приводится 

внешнее определение членов: 

Тип имяКласса :: имяЧлен-данного [ =Значение]; 

Тип имяКласса :: имяЧлен-функции телоЧлен-функции 

Использование внешних определений повышает наглядность текста программы 

и облегчает его последующую модификацию. Члены класса могут 

принадлежать к другим классам, и их именуют в этом случае вложенными 

классами. Глубина вложенности не ограничивается, хотя «большое число 

уровней абстракции так же плохо, как и их отсутствие» [5]. 

После объявления и определения создаются объекты класса. Каждый 

класс может использоваться для порождения множества объектов: 

имяКласса имяОбъекта; 

имяКласса *имяОбъекта = new имяКласса; 

Инициализация и обращение к членам класса выполняются по разнообразным 

схемам. Обращение к членам своего класса производится по именам, 

без указания имени объекта: 

имяЧлена [= Значение]; 

При этом адресация выполняется с помощью неявного аргумента 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); 

} 

}; 

97 

Для создания объектов класса в других формах, в их файлах кода размещаются 

ссылки на файл заголовка класса VPC. Ниже приведен пример 

функции MainVPC, «воспользовавшейся услугами» класса VPC для обработки 

объекта myCPU, и таких функций может быть множество: 

void MainVPC () { 

AnsiString company = "Acer"; 

VPC myCPU; 

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

void VIntegral :: Trap (double xk, double h, double f, 

double (*fnc) (double x, double y)) 

{ for (x=h, sum=0; x

99 


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 (); 

} 

Конструкторы и деструкторы 

Для автоматической инициализации объектов класса используются 

конструкторы – бестиповые, одноименные с классом член-функции: 

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:

100 

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; 

} 

} 

} 

AnsiString VList::Out () { 


for (i=0; i

} 

101 

VList a (3); 

// конструктор класса VList 

a.Add (&x); a.Add (&y); a.Add (&z); 

ShowMessage ("Поступили:\nЭВМ–Цена\n\n" + a.Out ()); 

a.Delete (&y); 

ShowMessage ("Остались:\nЭВМ–Цена\n\n" + a.Out ()); 

Инициализация объектов класса может проводиться не только с помощью 

операторов в теле конструктора, но и посредством списка инициализации 

(initialisation list). Такой список помещают через двоеточие вслед за заголовком 

конструктора. 

Конструктор, не требующий аргументов, называется конструктором 

по умолчанию (default constructor), или параметризованным конструктором. 

Это может быть конструктор с пустым списком параметров или конструктор, 

в котором части объявления параметров, завершающей список, присвоены 

значения. 

Следующий пример сложения матрицы с числом демонстрирует инициализацию 

списком и работу конструктора по умолчанию: 

class VMatrix { 

int i, j; 

AnsiString temp; 

float m[3][3], k; 

public: 

VMatrix (float a[][3], float c = 1); 

void Out (); 

}; 

VMatrix::VMatrix (float a[][3], float c): k(c) { 

for (i=0; i

} 

102 

VMatrix second (M, 5); // инициализируем значением 5 

second.Out (); // 6,7,8, 9,10,11, 12,13,14 

Процесс освобождения памяти после уничтожения объектов можно сопровождать 

деструктором (destructor) – бестиповым открытым методом без 

параметров, имя которого совпадает с именем класса и имеет префикс ~ 

(тильда). Деструктор всегда вызывается автоматически, то есть неявно, при 

выходе из блока, в котором был объявлен объект. Он также включается при 

вызове оператора delete для указателя на объект, имеющий деструктор, или в 

том случае, когда необходимо удалить объект, вложенный в удаляемый. В 

любом случае работа деструктора сопровождает процесс освобождения памяти, 

выделенной конструктором. Каждый класс имеет только один деструктор, 

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

понаблюдать в следующем примере: 

class VPair { 

int first, second; 

public: 

VPair (int one, int two): first (one), second (two) 

{ ShowMessage ("Объект создан"); } 

~VPair () { ShowMessage ("Объект удален"); } 

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; 


public:

}; 

VStackAndQueue (AnsiString str); 

void Push (AnsiString str); 

void PopStack (); 

void PopQueue (); 

int Empty () { return top == –1; } 

int Full () { return top == size; } 

103 

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

104 

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 = "Проверка: ";} 

}; 

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;

}; 

105 

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 

} 

Используя дружественные функции, следует помнить, что «подобно 

оператору goto, друзья снижают надежность программного кода... Потребность 

в объявлении одних классов друзьями других свидетельствует о плохо 

продуманной иерархии классов» [9]. Поэтому обращаться к помощи друзей 

следует лишь при крайней необходимости. 

Полиморфизм 

Полиморфизм как способность одинаковых операторов и одноименных 

функций к избирательному (зависящему от типа) поведению реализуется в 

C++ в первую очередь через механизмы перегрузки (overloading) операторов 

и функций. 

Суть перегрузки операторов заключается в создании функцииоператора, 

использующей в качестве имени лексему operator и следующий за 

ней перегружаемый оператор. Объявление перегрузки аналогично объявлению 

обычной дружественной функции или член-функции класса: 

Тип operator знакОперации ( [объявлениеПараметров] ); 

Перегрузке могут подлежать все простые операторы, за исключением 

«.», «.*», «:», «sizeof», «::». Язык не позволяет задать для перегружаемого 

оператора иной символ, кроме тех, что определены в списке операторов. 

Нельзя изменять синтаксис использования оператора: унарный оператор не

106 

перегружается в бинарный, префиксный – в постфиксный и т.п. Операторы 

«+», «–», «*», «&» могут быть как бинарными, так и унарными. 

Перегружаются только опеpатоpы в операциях, для которых по крайней 

мере один из параметров является членом структуры или класса. С учетом 

неявного указателя this, при выполнении одноместных операций аргумент 

может опускаться, а в двухместных операциях допустимо оставлять 

один аргумент. 

Для знакомства с перегрузкой одноместных операторов рассмотрим 

одну из распространенных задач программирования – вывод текущего времени 

на экран. На основании показаний системных часов компьютера такая 

программа формирует на экране время в днях, часах и минутах. Чтобы в каждом 

такте часов не пересчитывать время заново, здесь переопределен оператор 

инкремента, что позволяет использовать не абсолютный, а относительный 

отсчет времени: 

class VClock { 

private: 

__int64 total, secs, mins, hours, days; 

public: 

VClock (__int64 i); 

void Out (); 

VClock operator++ (); 

}; 

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 (); 

t2.Out (); 

++t1; ++t2; 

ShowMessage ("Новое время:"); 

t1.Out (); 

t2.Out (); 

107 

// 0 дн. 0 час. 0 мин. 59 сек. 

// 1 дн. 23 час. 59 мин. 59 сек. 

// 0 дн. 0 час. 1 мин. 0 сек. 

// 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

}; 

108 

public: 

VComputers (AnsiString a, int b) { type = a; price = b; } 

VComputers (const VComputers &par) { 

type = "Macintosh"; price = par.price * 2; 

} 

void Out () { ShowMessage (type + " стоит " + AnsiString (price)); } 

void MainVComputers() { 

VComputers myCPU ("Intel Pentium", 990); 

VComputers yourCPU (myCPU); 

myCPU.Out (); 

yourCPU.Out (); 

} 

Здесь объект myCPU инициализируется через конструктор VComputers 

(AnsiString, int), а объект yourCPU – через конструктор VComputers (const 

VComputers &). Оба выводятся на экран функцией Out. 

В следующем примере производится перегрузка конструктора для сложения 

транспонированнной матрицы с числом: 

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

} 

109 

AnsiString temp; 

for (i=0; i

110 

} 

} 

else { 

if (m[j].heat < m[j–1].heat) { 

Swap (m[j–1].name, m[j].name); Swap (m[j–1].heat, m[j].heat); 

} 

} 

ShowMessage (m[0].name + AnsiString (m[0].heat) + '\n' 

+ m[1].name + AnsiString (m[1].heat) + '\n' + m[2].name 

+ AnsiString (m[2].heat)); 

} 

Однажды созданный шаблон можно сохранить в файле заголовка и вызывать 

его оттуда по имени: 

template void Sort (T array[], int size) { 

for (int i=0; i (const VPrice); 

friend AnsiString &operator

111 

}; 

int VPrice::operator > (const VPrice amount) { 

return (dollars > amount.dollars) || 

(dollars == amount.dollars && cents > amount.cents); 

} 

AnsiString &operator

const MAX = 10; 

112 

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 ("В стеке вещественные числа: " + 

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

113 

void MainVVector () { 

VVector d; 

// создаются векторы 

VVector f; 

VVector c; 

for (int i=0; i

114 

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

115 

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; 


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); 

} 

}; 

void MainBac () { 

VBachalour first ("Сидоров", 6431, 225); 

if (first.spe > 200 && first.fac == 4) 

first.result += "\nЭто специалист по автоматике"; 

else 

first.result += "\nЭто специалист по электротехнике"; 

ShowMessage (first.result); 

} 

Пример множественного наследования:


116 

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; 

} 

}; 

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 Пассажир не имеет прав на льготы"; 


} 

}; 

void MainVPassenger() { 

VPassenger w ("Сидоров", 8431); 

VPassenger x ("Козлов", 197376L); 

VPassenger y ("Тихонов", 1234); 

VPassenger z ("Степанов", 1); 

}

117 

Виртуальные функции и абстрактные классы 

При обычном наследовании объект производного класса обладает 

свойствами и поведением объектов базового класса. В этом случае говорят о 

раннем, или статическом, связывании на стадии компиляции. Виртуальными 

(virtual function) называются функции, которые определяются на стадии исполнения, 

то есть производится их позднее, или динамическое, связывание. 

Для этого объект производного класса снабжается скрытым указателем на 

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

программы. 

При объявлении виртуальной функции к ее имени добавляется лексема 

virtual, что позволяет производным классам при необходимости переопределять 

такую функцию без изменения ее имени в списке параметров: 

virtual Тип имяФункции ([ объявлениеПараметров ]); 

«Виpтуальные функции служат центpальным моментом объектноориентированного 

программирования, потому что они позволяют опpеделять 

базовый класс общего назначения, не тpебуя знания особенностей, котоpые 

могут быть пpедусмотpены пpоизводным классом. Пpогpамма на C++ без 

виpтуальных функций, веpоятно, пpосто невеpно спpоектиpована» [5]. Иными 

словами, виpтуальные функции опpеделяют возможности, котоpыми обладают 

пpоизводные классы, но котоpые не могут быть pеализованы на 

уpовне базового класса. 

class VMarket { 

public: 

virtual void Market1 () { ShowMessage ("Телевизоры"); } 

void Market2 () { ShowMessage ("Компьютеры"); } 

}; 

class VSection: public VMarket { 

public: 

void Market1 () { ShowMessage ("SONY"); } 

void Market2 () { ShowMessage ("MACINTOSH"); } 

}; 

void MainVirtual1 () { 

VMarket *m = new VSection; // ссылка на производный класс 

m–>Market1 (); 

// SONY 


// Компьютеры 

}

118 

Более сложный пример помогает разобраться с различными вариантами 

наследования: 


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; 

} 

}; 


VProcessor intel, motorola (150), *cirix; 

VComputer ibm, macintosh (200), 

*proforma = &macintosh; 

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 


} 

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

чистой виртуальной функцией (pure virtual function) и объявляется как

119 

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"); } 

}; 


VNewMarket *m = new VNewSection; // ссылка на производный класс 


// SONY 


// Компьютеры 

} 

В следующем примере абстрактный класс управляет выводом на экран 

разнообразной информации: 

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)

120 

+ "\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: 


VPassenger (AnsiString name, __int64 data): 

VStudent (data), VPensioner (data) { 

If (!(VStudent::course) && !(VPensioner::course)) 

ShowMessage (" Пассажир не имеет права на льготы."); 

else { 

if (VStudent::course) result = VStudent::Out (name); 

if (VPensioner::course) result = VPensioner::Out (name); 

ShowMessage (result + "\nимеет право на льготы."); 

} 

} 

}; 


VPassenger w ("Сидоров", 8431); 

VPassenger x ("Козлов", 197376L); 

VPassenger y ("Тихонов", 1234); 

VPassenger z ("Степанов", 1); 

} 


1. Что такое объявление и определение класса 

2. Каково назначение конструкторов и деструкторов класса 

3. Что называется конструктором по умолчанию 

4. Что называется копирующим конструктором 

5. Как происходит передача объектов класса в функции 

6. Что такое дружественные функции и классы

121 

7. В чем заключается смысл перегрузки операторов 

8. Для чего выполняется перегрузка функций 

9. Какими достоинствами и недостатками обладают шаблоны 

10. В чем заключаются преимущества использования механизма наследования 

в программировании 

11. Как производится единичное наследование в программировании 

12. Какие данные и методы подлежат наследованию 

13. Что такое защищенные члены класса 

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

15. Чем отличается виртуальная функция от «чистой» виртуальной функции 

16. Каково назначение абстрактных классов в програмировании

122 

Приложение. Программные документы 

Сведения, необходимые для разработки, изготовления, сопровождения 

и эксплуатации программных продуктов, оформляются в виде программных 

документов в соответствии с комплексом государственных стандартов 

ГОСТ 19. 

По ГОСТ 19.101-87 в состав программной документации входят: 

• спецификация – описание состава программы и ее документации; 

• ведомость держателей подлинников – перечень организаций, на которых 

хранятся подлинники программных документов (код документа 

05); 

• текст программы с необходимыми комментариями (12); 

• описание программы – описание ее логической структуры и функционирования 

(13); 

• программа и методика испытаний – сведения о параметрах, подлежащих 

проверке при испытаниях программы, а также о порядке и 

методике их контроля (51); 

• техническое задание – назначение и область применения программы, 

технические, технико-экономические и специальные требования, 

предъявляемые к ней, а также стадии, сроки разработки и виды 

испытаний; 

• пояснительная записка – схемы и описание алгоритмов и порядка 

его функционирования, а также обоснование принятых технических 

и технико-экономических решений (81); 

• эксплуатационные документы. 

Эксплуатационные документы содержат сведения, необходимые для 

обеспечения функционирования и эксплуатации программы: 

• ведомость эксплуатационных документов (20); 

• формуляр – основные характеристики программы, комплектность и 

сведения об эксплуатации (30); 

• описание применения – назначение и область применения программы, 

применяемые методы, класс решаемых задач, ограничения для 

применения, минимальная конфигурация технических средств (31);

123 

• руководство системного программиста – сведения для проверки, 

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

конкретного применения (32); 

• руководство программиста по эксплуатации программы (33); 

• руководство оператора – процедуры общения персонала с вычислительной 

системой в ходе выполнения программы (34); 

• описание языка, включая синтаксис и семантику (35); 

• руководство по техническому обслуживанию – порядок применения 

тестовых и диагностических программ при обслуживании (36). 

ГОСТ разрешает объединять отдельные виды эксплуатационных документов, 

за исключением первых двух. Необходимость такого объединения 

предусматривается техническим заданием. Объединенному документу присваивают 

наименование и обозначение одного из объединяемых документов. 

В соответствии с ГОСТ 19.103-78, обозначения программ и документов 

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

обозначения программы и ее спецификации: 

A.B.XXXXX-XX 

Здесь A – код страны, B – код организации-разработчика, XXXXX – регистрационный 

номер, XX – номер издания программы или редакции документа. 

Коды страны и организации-разработчика присваиваются в установленном 

порядке, номер издания программы или редакции документа – в порядке возрастания 

от 01 до 99. 

Структура обозначения других программных документов: 

A.B.XXXXX-XX YY ZZ-Z 

Здесь A.B.XXXXX-XX – обозначение программы или ее спецификации, YY – 

код вида документа по ГОСТ 19.101-87, ZZ – номер документа данного вида, 

Z – номер части документа.

124 

Список литературы 

1. C++Builder 5. Руководство разработчика. Уч. пособие в 2-х т. // Д. Холингвэрт, 

Д. Баттерфилд, Б. Сворт, Д. Оллсоп. М.: Изд. дом «Вильямс», 2001. 

880 и 832 с. 

2. Архангельский А. Я. Программирование в C++Builder 6. М.: Бином, 2003. 

1152 с. 

3. Бабэ Б. Просто и ясно о Borland C++. М.: Бином, 1995. 400 с. 

4. Водовозов В. М., Пожидаев А. К. Конструирование приложений для Windows: 

Учеб. пособие. СПб.: Изд-во СПбГЭТУ «ЛЭТИ», 2004. 72 с. 

5. Голуб А. Пpавила пpогpаммиpования C & C++. М.: Бином, 1996. 272 с. 

6. Кнут Д. Искусство программирования для ЭВМ. В 3-х кн. М.: Миp, 1999. 

7. Культин Н. Б. Самоучитель С++Builder. СПб.: БХВ-Петербург, 2005. 

320 с. 

8. Павловская Т. А. С/С++. Программирование на языке высокого уровня: 

Учебник. СПб.: Питер, 2003. 360 с. 

9. Сван Т. Освоение Borland C++ 4.5. Киев: Диалектика. 1996. 400 с. 

10. Шамис В. А. Borland C++Builder 6.0. Для профессионалов. СПб.: Питер, 

2003. 798 с.

125 

Предметный указатель 

алгоритм, algorithm...................6, 59 

аллокатор, allocator.......................59 

аргумент, argument .......................10 

вершина, top ...................................52 

ветвь, branch ..................................57 

вход, input .......................................53 

вызов, call........................................10 

выход, output...................................53 

гиперссылка, hotspot........................7 

дек, deque........................................57 

дерево двоичное, binary tree..........57 

деструктор, destructor................102 

директива препроцессора, 

preprocessor directive ....................9 

дистрибутив, distributive..............81 

документ программный, program 

document....................................122 

заголовок, caption...........................11 

значение возвращаемое, return value 

........................................................8 

инициализация по умолчанию, 

default initialization .....................11 

интерфейс пользователя, user 

interface........................................85 

исключение, exception....................20 

источник данных, data source.......85 

итератор, iterator..........................59 

класс , class......................................14 

класс абстрактный, abstract class 

....................................................119 

класс дружественный, friend class 

....................................................104 

класс типизированный, typed class 

......................................................22 

константа глобальная, global 

constant ........................................12 

конструктор , constructor..............15 

конструктор копирующий, copying 

constructor....................................99 

конструктор по умолчанию, default 

constructor ................................. 101 

контейнер, container ..................... 59 

корень, root..................................... 57 

лист, sheet...................................... 57 

массив, array................................... 40 

моделирование, modelling............... 5 

модель, model................................... 5 

набор данных, dataset.................... 85 

наследование единичное, unit 

inheritance ................................. 113 

наследование множественное, 

multiple inheritance ................... 113 

обработчик исключения, exception 

handler ......................................... 20 

объединение, union ........................ 51 

объявление, announcement ............ 10 

оператор разыменования, 

dereference operator .................... 24 

определение, declaration................ 10 

очередь, queue................................ 53 

пакет, package............................... 75 

параметр, parameter ..................... 10 

перегрузка, overloading ............... 105 

переменная внешняя, extern variable 

..................................................... 12 

переменная глобальная, global 

variable ........................................ 12 

переменная изменчивая, volatile 

variable ........................................ 12 

переменная локальная, local variable 

..................................................... 12 

переменная регистровая, register 

variable ........................................ 12 

переменная статическая, static 

variable ........................................ 12 

переменная файловая, file variable 

..................................................... 67 

перестановка, swap....................... 43

подключение, connection ...............85 

порядок заполнения, fill allocation52 

порядок обратный, breadth-first 

traversal........................................58 

порядок обхода, traversal...............52 

порядок прямой, depth-first traversal 

......................................................58 

порядок симметричный, 

simmetrical traversal....................58 

программирование, programming...5 

прототип, prototype......................10 

результирующий набор, result set 92 

рекурсия, recursion.........................46 

сортировка , sorting .......................43 

сортировка быстрая, quick sorting 

......................................................44 

сортировка вставкой, insertion 

sorting...........................................44 

сортировка выборкой, exchange 

sorting...........................................44 

сортировка методом «пузырька»,, 

bubble sorting...............................44 

сортировка методом Шелла, Shell 

sorting...........................................44 

список инициализации, initialisation 

list...............................................101 

список линейный, linear list ...........54 

список связный, linked list.............51 

5 

список циклический, cyclic list...... 54 

ссылка, reference............................ 24 

стек, stack ...................................... 52 

структура , structure...................... 49 

структура динамическая, dynamic 

data structure................................ 51 

СУБД, DBMS................................. 84 

таблица главная, master ............... 94 

таблица подчиненная, detail ........ 94 

тип параметра, parameter type ... 11 

тип порядковый, ordered data type 

..................................................... 22 

узел, node........................................ 54 

указатель, pointer.......................... 24 

файл, file......................................... 65 

функции тело, function body ........ 11 

функция , function............................. 8 

функция виртуальная, virtual 

function...................................... 117 

функция встроенная, inline variable 

..................................................... 12 

функция главная, main function.... 10 

функция дружественная, friend 

function...................................... 103 

функция чистая виртуальная, pure 

virtual function .......................... 118 

шаблон, template .......................... 109 

язык, language .................................. 5

5 

Валерий Михайлович Водовозов, 

Федор Викторович Чмиленко 

Объектно-ориентированное программирование на С++ 

Учебное пособие 

Редактор 

Подписано в печать . Формат 60×84 1/16. 

Бумага офсетная. Печать офсетная. Печ. л. . 

Гарнитура «Times». Тираж 150 экз. Заказ . 

Издательство СПбГЭТУ «ЛЭТИ» 

197376, С.-Петербург, ул. Проф. Попова, 5

Объектно-ориентированное программирование на С++ - eDrive

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?