1. Интегрированная среда C++Builder

2. Программа на С++ и ее выполнение.

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

5. Обработка исключений в блоках try ... catch

1. ИНТЕГРИРОВАННАЯ СРЕДА C++BUILDER

С++ Builder – это система визуального объектно-ориентированного программирования, одна из самых мощных систем, позволяющих на современном уровне создавать как отдельные прикладные программы Windows, так и разветвленные комплексы, предназначенные для работы в корпоративных сетях и Интернет.

По популярности уступает его родной сестре Delphi, разработанной той же фирмой Borland. Но это явление временное, т.к. язык С++, лежащий в основе С++ Builder, более мощный, чем Object Pascal, на котором построена Delphi. И библиотеки функций намного обширнее библиотек Object Pascal.

С++Builder позволяет решить множество задач:

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

- Быстро создавать профессионально выглядящий оконный интерфейс для любых приложений, написанных на любом языке. С помощью С++Builder можно объединить ПП DOS, Windows и др.

- Создавать мощные системы работы с локальными и удаленными БД.

- Создавать многозвенные распределенные приложения, основанные на различных технологиях.

- Создавать приложения, которые управляют другими приложениями (MSOfficce).

- Создавать кроссплатформенные приложения, которые можно компилировать и эксплуатировать как в Windows, так и в Linux.

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

- Создавать профессиональные программы установки для приложений Windows и др.

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

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

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

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

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

Типы объектов, и в частности, компонентов библиотек С++Builder оформляются в виде классов. Классы – это типы, определяемые пользователем. В классах описываются свойства объектов, его методы и события, на которые он может реагировать. Язык С++ предусматривает только инструментарий создания классов, а сами классы создаются разработчиками программного обеспечения. Они включены в библиотеки системы. Но это нисколько не мешает вам создавать свои классы.

Благодаря важному свойству классов – наследованию, новый класс может наследовать свойства, методы и события своего родительского класса, т.е. того класса на основе которого он создается. Например, при создании новой кнопки можно взять за основу один из уже разработанных классов кнопок и только добавить к нему какие-то новые свойства или отменить какие-то свойства и методы родительского класса.

Благодаря визуальному ООП была создана технология, получившая название быстрая разработка приложений. Она характерна для нового поколения систем программирования, к которому относится С++Builder.

Взаимодействие приложений в ИС.

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

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

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

Следующим шагом стало разработка COM технологии (компонентная модель объектов). Это стандартизированное описание функций (служб) программы, к которым она дает доступ другим программам. При этом не важно, на каких языках написаны программы и где они выполняются – в одном потоке, в разных потоках, на разных компьютерах. Основной здесь является понятие интерфейса. Каждый объект COM имеет несколько интерфейсов, дающих доступ к его функциям.

2. ПРОГРАММА НА С++ BUILDER И ЕЕ ВЫПОЛНЕНИЕ

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

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

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

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

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

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

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

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

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

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

Головной файл содержит функцию WinMain (main – для консольного). Обычно мы его не видим и не трогаем. Для просмотра: меню Project| ViewSource

// директивы препроцессора

#include <vcl.h>

#pragma hdrstop

// макросы, подключающие файлы ресурсов и форм

USERES ("Projectl . res") ;

USEFORM("Unitl.cpp", Forml);

USEFORM("Unit2.cpp", Form2);

/ / __________________________________________________________

// функция main

WINAPI WinMain (HINSTANCE, HINSTANCE, LPSTR, int)

{

try

{ Application->Initialize () ;

Application->CreateForm( _ classid (TForm1) , &Forml)

Application->CreateForm( classid(TForm2) , &Form2);

Application->Run();

}

catch (Exception &exception)

{

Application->ShowException(&exception);

}

return 0;

}

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

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

После всех этих вспомогательных предложений в файле расположена главная функция программы - - WinMain. Ее первым параметром является дескриптор данного экземпляра приложения. Дескриптор — это некий уникальный указатель, позволяющий Windows разбираться в множестве одновременно открытых окон различных приложений. Иногда вы будете использовать дескрипторы при обращении к различным функциям API Windows (API Windows — это пользовательский интерфейс Windows, содержащий множество полезных функций). Второй параметр WinMain - - дескриптор предыдущего экземпляра вашего приложения(если пользователь выполняет одновременно несколько таких приложений). Третий параметр является указателем на строку с нулевым символом в конце, содержащую параметры, передаваемые в программу через командную строку. Иногдатакие параметры используются для переключения режимов работы программы или для задания различных опций при запуске приложения из диспетчера программ или функцией WinExec.

Последний параметр определяет окно приложения. Этот параметр может в дальнейшем передаваться в функцию ShowWindow.

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

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

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

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

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

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

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

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

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

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

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

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

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

//

#fifndef UnitlH

#define UnitlH

//

#include «Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

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

// препроцессора (в частности, include),

// не включаемые в файл автоматически

//

// объявление класса формы TForml

class TForml : public TForm

{

published: // IDE-managed Components

// размещенные на форме компоненты

TButton *Buttonl;

TLabel *Labell;

void fastcall ButtonlClick(TObject *Sender);

private: // User declarations

// закрытый раздел класса

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

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

public: // User declarations

// открытый раздел класса

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

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

fastcall TForml(TComponent* Owner);

};

//

extern PACKAGE TForml *Forml;

// ,

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

// которые не включаются в класс формы;

// доступ к ним из других блоков возможен только при соблюдении

// некоторых дополнительных условий

#endif

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

/ /

finclude <vcl.h>

#pragma hdrstop

#include "Unitl.h"

//

tpragma package(smart_init)

tpragma resource "*.d£m"

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

// препроцессора (в частности, include),

// не включаемые в файл автоматически

// объявление объекта формы Forml

TForml *Forml;

//

// вызов конструктора формы Forml

fastcall TForml::TForml(TComponent* Owner)

: TForm(Owner)

^ , {

// сюда вы можете поместить операторы,

// которые должны выполняться при создании формы

}

//

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

// доступ к которым из других модулей возможен только при

// соблюдении некоторых дополнительных условий;

// тут же должны быть реализации всех функций, объявленных в

// заголовочном файле, а также могут быть реализации любых

// дополнительных функций, не объявленных ранее

void fastcall TForml::ButtonlClick(TObject *Sender)

(

Close () ;

}

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

После директив препроцессора следует описание класса формы. Имя класса вашей формы — TForml. Класс содержит три раздела: published — открытый раздел, содержащий объявления размещенных на форме компонентов и обработчиков событий в них, private — закрытый раздел класса, и public — открытый раздел класса. В данном случае в разделе published вы можете видеть объявления указателей на два компонента: компонент Buttonl типа TButton и компонент Labell типа TLabel. Там же вы видите объявление функции ButtonlClick — введенного пользователем обработчика события щелчка на кнопке Buttonl. Все, что имеется в разделе published, C++Builder включает в него автоматически в процессе проектирования вами формы. Так что вам не приходится, как правило, работать с этим разделом. А в разделы private и public вы можете добавлять свои объявления типов, переменных, функций. То, что вы или C++Builder объявите в разделе public, будет доступно для других классов и модулей. То, что объявлено в разделе private, доступно только в пределах данного модуля. Как вы можете видеть, единственное, что C++Builder самостоятельно включил в раздел public, это объявление (прототип) конструктора вашей формы TForml.

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

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

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

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

Имена файлам модулей C++Builder дает по умолчанию: для первого модуля имя равно "Unitl", для второго — "Unit2" и т.д.