5.3. Структура файла реализации модуля

Как правило, файл реализации модуля содержит описание функций, объявленных в заголовочном файле, и функций, объявленных в этом фай­ле. Стандартное расширение файла реализации - ".срр". Обычно файл реа­лизации в окне Редактора кода закрыт формой. Чтобы сделать файл реали­зации видимым, можно, например, нажать клавишу F12. На рис. 13 пока­зан файл реализации.

Unit1.срр 16.04.03 22.40.33

1:

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

3:// --------------------------------------------------------------------------------------------------------------------------

4: #include <vcl.h> //директива препроцессора подключает файлы визуальных

5: //компонентов

6: #progma hdrstop // директива препроцессора указывает компилятору конец

7: // списка общих файлов

8: #include “Unit1.h” //директива препроцессора подключает в файл реализации

9: // заголовочный файл

10: //--------------------------------------------------------------------------------------------------------------------------

1 1 : #pragma package (smart_init) // директива препроцессора указывает компилятору

12: // последовательность инициализации пакетов такой,

13: // какая устанавливается взаимными ссылками

14: // использующих их модулей

15: #pragma resourse “*dfm” //директива препроцессора указывает компилятору,

16: // что для формы надо использовать файл Жт с тем

1 7: // же именем, что и имя данного файла

1 8: //--------------------------------------------------------------------------------------------------------------------------

19: // здесь могут размещаться дополнительные директивы препроцессора (в частности,

20: // include), не включаемые в файл автоматически

2 1: //--------------------------------------------------------------------------------------------------------------------------

22: // объявление указателя *Form1 для объекта формы TForm1

23: TForm1*Form1;

24: //--------------------------------------------------------------------------------------------------------------------------

25: // функция конструктора формы

26:__fastcall TForm::TForm1(TComponent* Owner)

27: : TForm( Owner)

28: {

29: // здесь могут размещаться операторы, необходимые для

30: // инициализации программы (например, при создании формы)

31: }

32: //--------------------------------------------------------------------------------------------------------------------------

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

34: // не объявленных в заголовочном файле; тут же должно быть описание (реализа­ция)

36: // всех функций, объявленных в заголовочном файле, а также могут быть

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

38:// --------------------------------------------------------------------------------------------------------------------------

Рис. 13

После включения директив препроцессора в этом файле делается объявление указателя *TForm. Далее идёт описание функции конструкто­ра формы, которая объявлена в заголовочном файле. Тело этой функции пустое, но в него можно включить операторы (будут выполняться при соз­дании Формы), которые, например, будут выполнять какие-то начальные настройки программы.

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

Все операторы файла реализации (см. рис. 13) заносятся в файл ав­томатически. Имя файлу реализации С++ Builder 5 даёт по умолчанию: для первого модуля - "Unit1.срр", для второго модуля - "Unit2.срр" и т.д.

6. Методика работы в ИСР С++ Builder 5 на примере реализации программы "Пауза"

Создадим приложение "Пауза", которое через две секунды выводит на Форму переменную y и её значение в виде нуля или единицы. Для этого необходимо выполнить следующие действия. 6.1. Открыть проект.

6.1.1. Включить питание компьютера:

- нажать клавишу включения питания на устройстве "Пилот";

- нажать клавишу включения питания на устройстве УПС.

6.1.2. Загрузить операционную систему (ОС) Windows NT 4.0:

- после включения питания компьютера ОС запросит у пользова­теля подтверждения работы: нажать одновременно две клавиши Ctrl и Delete;

- ОС запросит у пользователя подтверждения пароля: нажать кла­вишу Enter. На мониторе компьютера появится рабочий стол Windows NT 4.0 с необходимыми пиктограммами.

6.1.3. Запустить С++ Builder 5:

- щёлкнуть два раза левой кнопки мыши по пиктограмме С++ Builder 5 на рабочем столе Windows NT 4.0.

6.1.4. Открыть проект:

- после включения питания и загрузки С++ Builder 5 первый раз на экране монитора появляется ИСР, в составе которой имеется заготовка бу­дущей программы: форма с именем Form1 и файл реализации с именем Unit1.срр в окне Редактора кода, находящийся за окном формы;

- если в ИСР разрабатывалась какая-то другая программа другим пользователем, то после окончания своей работы, закрытия и сохранения файлов, с которыми он работал, на мониторе останется ИСР, не содержа­щая форму и Редактор кода. В этом случае для работы следует открыть но­вый проект, для чего надо выполнить команду File / New Application - в ИСР появится заготовка будущей программы, содержащая Форму и Ре­дактор кода файла Unit1.срр.

6.2. Сохранить проект.

6.2.1. Открыть окно сохранения файла, для чего следует нажать бы­струю кнопку Save All - откроется окно Save Unit1 As, показанное на рис. 14.

Рис. 14

6.2.2. В окне Save Unit1 As открыть директорий: C:\ Grypp AT \ Brigada \ Ivanov.

6.2.3. В этом директории создать папку с именем Pause.

6.2.4. Открыть папку Pause.

6.2.5. Сохранить файл реализации в папке Pause с именем PauseUnit1.срр:

- в окне Save Unit1 As (см. рис. 14) в графе "Имя файла" изменить

имя Unit1.срр, предлагаемое С++ Builder 5, на имя PauseUnit1.срр; доба-

вить слева от названия Unit1.срр в поле "Имя файла" название проекта Pause;

- щёлкнуть один раз левой кнопкой мыши по кнопке "Сохранить" (см. рис. 14).

6.2.6. Сохранить файл проекта в папке Pause с именем PauseProject.bpr:

- в окне Save Unit1 As в графе "Имя файла" изменить имя Project.bpr , предлагаемое С++ Builder 5, на имя PauseProject.bpr ; добавить слева от названия Project.bpr в поле "Имя файла" название проекта Pause;

- щёлкнуть один раз левой кнопкой мыши по кнопке "Сохранить". Таким образом, результатом действий по сохранению проекта будет создание папки Pause в нужном директории и сохранение в этой папке проекта с именем Pause. Следует отметить, что имя проекта записывается латинскими буквами.

6.3. Визуальное проектирование.

6.3.1. Перенос на Форму компонентов.

6.3.1.1. Перенести на Форму компонент Label (поле вывода):

- выделить пиктограмму Label (A) на странице Standart;

- щёлкнуть курсором мыши в нужном месте Формы;

- на Форме появится поле вывода, которому С++ Builder 5 при­своит имя Label1.

6.3.1.2. Аналогичным образом перенести на Форму компонент с именем Label2.

6.3.1.3. Перенести на Форму компонент Button (кнопка):

- выделить пиктограмму Button (ОК) на странице Standart;

- щёлкнуть курсором мыши в нужном месте Формы;

- на Форме появится кнопка, которой С++ Builder 5 присвоит имя Button1.

6.3.1.4. Аналогичным образом перенести на Форму компонент с име­нем Button2.

6.3.1.5. Перенести на Форму компонент Timer (таймер):

- выделить пиктограмму Timer (имеет изображение циферблата часов) на странице System;

- щёлкнуть курсором мыши в нужном месте Формы;

- на Форме появится таймер, которому С++ Builder 5 присвоит имя Timer1.

6.3.1.6. Компоненты на Форме должны быть размещены примерно так, как показано на рис. 15.

6.3.2. Занести в заголовок компонента текст на русском языке.

6.3.2.1. Занести текст в заголовок компонента Form1:

- выделить компонент Form1 (щёлкнуть один раз левой кнопкой мыши на пустом месте Формы);

- перейти в окно Инспектора объектов на страницу Properties (свойства);

- изменить текст свойства Caption (заголовок), который по умол­чанию имеет вид Form1, на русский текст "Пауза".

6.3.2.2. Занести текст в заголовок компонента Label1;

- выделить компонент Label1 (щёлкнуть один раз левой кнопкой мыши по компоненту Label1, расположенному на Форме);

- перейти в окно Инспектора объектов на страницу Properties;

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

6.3.2.3. Занести текст в заголовок компонента Button1:

- выделить компонент Button1 (щёлкнуть один раз левой кнопкой мыши по компоненту Button1, расположенному на Форме);

- перейти в окно Инспектора объектов на страницу Properties;

- изменить текст свойства Caption, который по умолчанию имеет вид Button1, на русский текст "Пуск".

6.3.2.4. Аналогичным образом занести в заголовок компонента Button2 русский текст "Закрыть".

6.3.2.5. После выполнения операций по занесению текста на русском языке в заголовки соответствующих компонентов Форма примет вид, по­казанный на рис. 16.

6.3.3. Установить необходимые свойства для компонента Timer1:

- выделить компонент Timer1, щелкнув один раз левой кнопкой мыши по компоненту Timer1 на Форме;

- перейти в окно Инспектора объектов на страницу Properties;

- изменить свойство Enabled (разрешение), которое по умолчанию имеет вид true (истинное), на false (ложное), тем самым запрещая работу Timer1;

- изменить свойство Interval (интервал), которое по умолчанию имеет 1000 мс, на 2000 мс (две секунды).

6.3.4.Создать обработчики событий.

6.3.4.1. Создать обработчик событий для компонента Button1:

- щёлкнуть два раза левой кнопкой мыши по компоненту Button1 (кнопка "Пуск"), находящемуся на Форме, - в окне Редактора кода, в фай­ле реализации, появится функция вида:

void__fastcall TForm1::Button1Click(TObject*Sender)

{

}

6.3.4.2. Аналогичным образом создаётся обработчик событий для компонента Button2 (кнопка "Закрыть") - в файле реализации появится функция вида:

void__fastcall TForm1::Button1Click(TObject*Sender)

{

}

6.3.4.3. Обработчик событий для компонента Timer1 (таймер) созда­ётся аналогично тому, как это делается для кнопок "Пуск" и "Закрыть" - в файле реализации появится функция вида:

void__fastcall::Timer1Timer(TObject*Sender)

{

}

6.3.4.4. После сохранения проекта, выполнения операций визуально­го проектирования головной файл проекта, заголовочный файл и файл реа­лизации примут вид, показанный на рис. 17, 18, 19 соответственно.

PauseProject1.cpp 01.10.02 8:52:46

//--------------------------------------------------------------------------------------------------------------------------

# include <vcl.h>

#pragma hdrstop

USERES(“Project1.res”);

USEFORM(“Unit1.cpp”, Form1);

//--------------------------------------------------------------------------------------------------------------------------

WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)

{

try

{

Application->Initialize();

Application->CreateForm(__classid(TForm1)&Form1);

Application->Run();

}

catch ( Exception &exception)

{

Application->ShowException(&exception);

}

Return 0;

}

//--------------------------------------------------------------------------------------------------------------------------

#include <Extrls.hpp>

//--------------------------------------------------------------------------------------------------------------------------

Class TForm1 : public TForm

{

__published: //IDE-managed Components

TLable* Lable1;

TLable* Lable2;

TButton*Button1;

Tbutton*Button2;

TTimer*Timer1;

void__fastcall Button1Click(TObject*Sender);

void__fastcall Button2Click(TObject*Sender);

void__fastcall Timer1Timer(TObject*Sender);

private: // User declarations

public: // User declarations

­­__fastcall TForm1(TComponent*Owner);

};

//--------------------------------------------------------------------------------------------------------------------------

Extern PACKAGE TForm1*Form1

//--------------------------------------------------------------------------------------------------------------------------

#endif

РИС.18

PauseUnit1.cpp 01.10.02 8:52:46

//--------------------------------------------------------------------------------------------------------------------------

#include<vcl.h>

#pragma hdrstop

#include “Unit1.h”

//--------------------------------------------------------------------------------------------------------------------------

__fastcall TForm::TForm1(TComponent*Owner)

:TForm(Owner)

{

}

//--------------------------------------------------------------------------------------------------------------------------

void__fastcall TForm1:: Button1Click(TObject*Sender)

{

}

//--------------------------------------------------------------------------------------------------------------------------

void__fastcall TForm1:: Button2Click(TObject*Sender)

{

}

//--------------------------------------------------------------------------------------------------------------------------

void__fastcall TForm1::Timer1Timer(TObject*Sender)

{

}

//--------------------------------------------------------------------------------------------------------------------------

РИС. 19

6.4. Программирование файла реализации.

Запрограммированный файл реализации показан на рис.20. Рассмотрим этапы создания этого этапа.

PauseUnit1.cpp 01.10.03 12:32:34

1: //--------------------------------------------------------------------------------------------------------------------------

2:

3: #include<vcl.h>

4: #pragma hdrstop

5: #include “Pause.h”

6: //--------------------------------------------------------------------------------------------------------------------------

7: #pragma package(smart_init)

8: #pragma resourse “*dfm”

9: TForm1*Form1;

10: unsigned short int y;

11: //--------------------------------------------------------------------------------------------------------------------------

12:__fasncall TForm1::TForm1(TComponent*Owner)

13: :TForm(Owner)

14:{

15: y=0;

16: }

17: //--------------------------------------------------------------------------------------------------------------------------

18:

19:

20: void__fastcall TForm1:: Button1Click(TObject*Sender)

21:{

22: //разрешение работы таймера

23: Timer1->Enabled=true;

24:

25: }

26: //--------------------------------------------------------------------------------------------------------------------------

27:

28: void__fastcall TForm1:: Button2Click(TObject*Sender)

29: {

30: // закрытие формы и завершение приложения

31: Close();

32:

33:}

34: //--------------------------------------------------------------------------------------------------------------------------

35:

36: void__fastcall TForm1::Timer1Timer(TObject*Sender)

37: {

38: // Инвертирование у

39: y = ~ y;

40: // Выделение разряда D0 переменной у

41: y=y&0x01;

42: // вывод значений переменной “у” на форму

43: Label2->Caption=“y=”+ AnsiString(y);

44: //окрашивание переменной “y” в красный цвет

44: Label2->Font->Color=clRed;

46: }

47: //--------------------------------------------------------------------------------------------------------------------------

РИС.20

6.4.1. Объявление переменной:

- переменная у объявляется как беззнаковое, короткое, целое чис­ло (строка 10 файла);

Такой вид объявления удобен при работе с внутренним отладчиком С++ Builder 5;

6.4.2. Инициализация переменной:

- в функцию конструктора Формы заносится начальное значение переменной у (строка 15 файла).

6.4.3. Разрешение работы таймера:

- в функцию обработчика события - нажатие клавиши “Пуск” - за­носим разрешение работы таймера (строка 23 файла).

6.4.4. Закрытие приложения:

- в функцию обработчика события - нажатие клавиши "Закрыть" - заносим функцию закрытия приложения (строка 3 1 файла).

6.4.5. Обработка переменной у по заданному алгоритму работы:

- в функцию обработчика событий таймера (функция включается каждые две секунды, если имеется разрешение работы таймера) заносятся операторы (строки 38, ...,45 файла).

6.5. Компиляция проекта,

Компиляция проекта с последующим его выполнением осуществля­ется, например, нажатием быстрой кнопки Run (см. рис. 6) или клавиши F9. После компиляции и компоновки создаётся выполняемый файл с рас­ширением .ехе, который запускается на выполнение. Однако создание файла .ехе производится только в случае, если при компиляции и компо­новке не обнаружены ошибки.

В случае обнаружения ошибки в программе в окне Редактора кода можно увидеть сообщение об ошибке, показанное на рис. 21.

Рис.21

Сообщение состоит из двух частей:

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

I - вторая часть представляет текст, объясняющий суть ошибки (текст 1 расположен в нижней части окна Редактора кода).

В данном случае компилятор сообщает, что используется неопреде­лённый ранее символ “Y”

6,6. Включение и остановка проекта.

В случае успешного выполнения компиляции и компоновки про­грамма запускается на выполнение, и на экране монитора появится Форма, вид которой был показан ранее на рис. 16.

Включение программы осуществляется одним щелчком левой кнопки мыши по кнопке "Пуск" - на экране появится Форма, вид которой показан на рис. 22. На форму выводится переменная у и её возможные значения О или 1 через каждые две секунды в соответствии с формулировкой алго­ритма.

Закрытие проекта (программы) происходит нажатием клавиши "За­крыть" (либо кнопкой со значком "X" в правом верхнем углу Формы).

Рис.22

6.7. Отладка проекта.

Отладка проекта (программы), например, выполнение её по шагам, предполагает выявление ошибок алгоритмического характера, которые не обнаруживаются при компиляции и компоновке. Для решения поставлен­ной задачи необходимо выбрать в файле реализации строку кода, начиная с которой следует выполнять программу по шагам. Подводим мышью кур­сор к выбранной строке кода (к любой её части) файла реализации и щёл­каем один раз левой кнопкой мыши. Курсор остаётся в этой строке, тем самым отмечая её. Затем нажимаем клавишу F4, которая запускает про­грамму на компиляцию и выполнение - на экране появляется Форма (см. рис. 16). Нажимаем клавишу "Пуск", тем самым вызываем действия, обу­словленные алгоритмом работы. Программа выполняется непрерывно до оператора, отмеченного курсором. На экране появляется окно, показанное на рис. 23.

По достижении отмеченной строки кода программа приостанавлива­ется и отмеченная строка окрашивается синим цветом. Слева от выбранной строки появляется стрелка зелёного цвета, указывающая на выбранную строку. Далее, нажимая быструю кнопку Step Over (см. рис. 6) или нажи­мая клавишу F8 на клавиатуре, можно выполнить программу по шагам.

В процессе выполнения программы по шагам можно с помощью внутреннего отладчика С++ Builder 5 видеть значения интересующих нас переменных в том виде (типе), как они объявлены в программе. Получение этой информации требует установить курсор на интересующую нас пере­менную. Через некоторое время (порядка одной-двух секунд) ниже этой переменной появится маленькое окно в виде всплывающей подсказки, в котором будет показана переменная и её значения в данный момент вре­мени (см. рис. 23). В нашем случае изображается у = 0.

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

Прекращение процесса отладки производится одновременным нажа­тием клавиш Ctrl и F2.

Для распечатки файла необходимо активизировать требуемый файл в окне Редактора кода (сделать его видимым), далее следует выполнить ко­манду File/Print/OK.

Рис.23