русс | укр

Языки программирования

ПаскальСиАссемблерJavaMatlabPhpHtmlJavaScriptCSSC#DelphiТурбо Пролог

Компьютерные сетиСистемное программное обеспечениеИнформационные технологииПрограммирование

Все о программировании


Linux Unix Алгоритмические языки Аналоговые и гибридные вычислительные устройства Архитектура микроконтроллеров Введение в разработку распределенных информационных систем Введение в численные методы Дискретная математика Информационное обслуживание пользователей Информация и моделирование в управлении производством Компьютерная графика Математическое и компьютерное моделирование Моделирование Нейрокомпьютеры Проектирование программ диагностики компьютерных систем и сетей Проектирование системных программ Системы счисления Теория статистики Теория оптимизации Уроки AutoCAD 3D Уроки базы данных Access Уроки Orcad Цифровые автоматы Шпаргалки по компьютеру Шпаргалки по программированию Экспертные системы Элементы теории информации

ИЕРАРХИЯ: ТОЧКА, КРУГ, ЦИЛИНДР


Дата добавления: 2014-09-29; просмотров: 2662; Нарушение авторских прав


 

Введение

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

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

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

Базовый класс может наследоваться как public (открытый), protected (защищенный) или private (закрытый). Защищенное и закрытое наследования встречаются редко. В случае public открытые элементы базового класса становятся открытыми элементами производного класса, а защищенные элементы базового класса становятся защищенными элементами производного класса. Закрытые элементы базового класса никогда не бывают доступны для производного класса. Элементы базового класса, которые не должны быть доступны производному классу через наследование, объявляются в базовом классе закрытыми.

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

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



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

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

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

Виртуальные функции и полиморфизм

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

Виртуальная функция объявляется с помощью ключевого слова virtual, предшествующего прототипу функции в базовом классе, например, virtual float getX()const;. Функция может быть чистой виртуальной, тогда virtual float getX()const=0;. Несмотря на то, что некоторые функции могут быть неявно виртуальными, поскольку они были объявлены такими на более высоком уровне иерархии, рекомендуется явно объявлять функции виртуальными на каждом уровне иерархии, чтобы обеспечить ясность программы.

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

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

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

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

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

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

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

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

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

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

Конструкторы не могут быть виртуальными.

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

 

Проектирование приложения.

Выбор, размещение и задание свойств компонентов.

Коды классов, функций и обработчиков событий

 

Сохраните модуль главной формы под именем LR_9, а проект – под именем PR_LR_9.

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

1.Модуль f_point

 

Заголовочный файл f_point.h

#ifndef f_pointH

#define f_pointH

//Объявление класса f_point

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

class f_point

{

public:

f_point(float=0, float=0); //конструктор с умолчанием

void setpoint(float,float); //установка координат точки

float getX() const {return x;}// возвращение координаты x

float getY() const {return y;}// возвращение координаты y

protected:

float x,y; // координаты точки

};

#endif

 

Файл реализации f_point.cpp

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

#pragma hdrstop

#include "f_point.h"

//Определения функций-элементов класса f_point

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

//в конструкторе вызывается функция установки координат точки

f_point::f_point(float a, float b) {setpoint(a,b);}

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

// установка координат точки

void f_point::setpoint(float a, float b) {x=a; y=b;}

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

#pragma package(smart_init)

 

2.Модуль f_circle

 

Заголовочный файл f_circle.h

#ifndef f_circleH

#define f_circleH

#include "f_point.h"

//Объявление класса f_circle

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

class f_circle:public f_point

{

public:

//конструктор с умолчанием

f_circle(float r=0.0, float x=0.0, float y=0.0);

void setradius(float); //установка радиуса

virtual float getradius() const; //возвращение радиуса

float area() const; //вычисление площади

protected:

float radius; //радиус круга

};

#endif

 

Файл реализации f_circle.cpp

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

#pragma hdrstop

#include "f_circle.h"

//Определения функций-элементов класса f_circle

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

//конструктор f_circle вызывает конструктор f_point через //инициализатор элементов-координат, затем инициализирует радиус

f_circle::f_circle(float r,float a, float b)

:f_point(a,b)

{ radius=r;}

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

//установка радиуса круга

void f_circle::setradius(float r) {radius=r;}

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

//получение радиуса круга

float f_circle::getradius() const {return radius;}

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

//вычисление площади круга

float f_circle::area() const

{return 3.14159*radius*radius;}

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

#pragma package(smart_init)

 

3.Модуль f_cylinder

 

Заголовочный файл f_cylinder.h

#ifndef f_cylinderH

#define f_cylinderH

#include "f_circle.h"

//Объявление класса f_cylinder

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

class f_cylinder:public f_circle

{

public:

//конструктор с умолчанием

f_cylinder (float h=0.0, float r=0.0,

float x=0.0, float y=0.0);

void setheight(float); //установка высоты

float getheight () const; //возвращение высоты

//вычисление и возвращение площади поверхности цилиндра

float area() const;

float volume() const; //вычисление и возвращение объема

protected:

float height; //высота цилиндра

};

#endif

 

Файл реализации f_cylinder.cpp

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

#pragma hdrstop

#include "f_cylinder.h"

//Определения функций-элементов класса f_cylinder

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

//Конструктор f_cylinder вызывает конструктор f_circle

f_cylinder::f_cylinder(float h, float r, float x, float y)

:f_circle (r,x,y) //вызов конструктора базового класса

{height=h;}

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

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

void f_cylinder::setheight(float h) {height=h;}

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

//получение высоты цилиндра

float f_cylinder::getheight() const {return height;}

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

//вычисление и возвращение площади поверхности цилиндра

float f_cylinder::area() const

{

return 2*f_circle::area()+

2*3.14159*radius*height;

}

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

//вычисление и возвращение объема цилиндра

float f_cylinder::volume() const

{return f_circle::area()*height;}

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

#pragma package(smart_init)

 

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

4.Модуль shape

 

Заголовочный файл shape.h

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

// Объявление абстрактного базового класса shape

#ifndef shapeH

#define shapeH

class shape

{

public:

virtual float getX()const=0;

virtual float getY()const=0;

virtual float getradius()const {return 0.0;}

virtual float getheight()const {return 0.0;}

virtual float area()const {return 0.0;}

virtual float volume()const {return 0.0;}

};

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

#endif

 

Файл реализации shape.cpp

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

#pragma hdrstop

#include "shape.h"

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

#pragma package(smart_init)

 

5.Модуль point

 

Заголовочный файл point.h

//Объявление класса point

#ifndef pointH

#define pointH

#include "shape.h"

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

class point:public shape

{

public:

point(float=0, float=0);

void setpoint(float,float);

virtual float getX()const {return x;}

virtual float getY()const {return y;}

private:

float x,y;

};

#endif

 

Файл реализации point.cpp

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

//Определения функций-элементов класса point

#pragma hdrstop

#include "point.h"

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

point::point(float a, float b) {setpoint(a,b);}

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

void point::setpoint(float a, float b)

{x=a; y=b;}

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

#pragma package(smart_init)

 

6.Модуль circle

 

Заголовочный файл circle.h

//Объявление класса circle

#ifndef circleH

#define circleH

#include "point.h"

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

class circle:public point

{

public:

circle(float r=0.0, float x=0.0, float y=0.0);

void setradius(float);

virtual float getradius()const;

virtual float area()const;

private:

float radius;

};

#endif

 

Файл реализации circle.cpp

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

//Определения функций-элементов класса circle

#pragma hdrstop

#include "circle.h"

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

circle::circle(float r, float a, float b)

:point(a,b) //вызов конструктора базового класса

{ radius = r>0?r:0; }

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

void circle::setradius(float r) { radius = r>0?r:0; }

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

float circle::getradius()const {return radius;}

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

float circle::area()const {return 3.14159*radius*radius;}

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

#pragma package(smart_init)

 

7.Модуль cylinder

 

Заголовочный файл cylinder.h

//Объявление класса cylinder

#ifndef cylinderH

#define cylinderH

#include "circle.h"

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

class cylinder:public circle

{

public:

cylinder(float h=0.0, float r=0.0, float x=0.0, float y=0.0);

void setheight(float);

virtual float getheight () const;

virtual float area()const;

virtual float volume()const;

private:

float height;

};

#endif

 

Файл реализации cylinder.cpp

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

//Определения функций-элементов класса cylinder

#pragma hdrstop

#include "cylinder.h"

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

cylinder::cylinder(float h, float r, float x, float y)

:circle(r,x,y)

{ height = h>0?h:0; }

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

void cylinder::setheight(float h) { height = h>0?h:0; }

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

float cylinder::getheight() const {return height;}

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

float cylinder::area()const

{

return 2*circle::area()+2*3.14159*circle::getradius()*height;

}

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

float cylinder::volume()const { return circle::area()*height; }

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

#pragma package(smart_init)

 

В нижеприведенных заголовочном файле модуля формы LR_9.h и форме с результатами выполнения задания (рис.9.1) можно получить информацию для размещения компонентов на форме.

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

#ifndef LR_9H

#define LR_9H

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

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include <ExtCtrls.hpp>

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

class TForm1 : public TForm

{

__published: // IDE-managed Components

TMemo *Memo1;

TMemo *Memo2;

TLabel *Label4;

TLabel *Label5;

TButton *Button1;

TGroupBox *GroupBox1;

TLabel *Label1;

TLabeledEdit *LabeledEdit1;

TLabeledEdit *LabeledEdit2;

TGroupBox *GroupBox2;

TLabel *Label2;

TLabeledEdit *LabeledEdit3;

TLabeledEdit *LabeledEdit4;

TLabeledEdit *LabeledEdit5;

TGroupBox *GroupBox3;

TLabeledEdit *LabeledEdit9;

TLabel *Label3;

TLabeledEdit *LabeledEdit6;

TLabeledEdit *LabeledEdit7;

TLabeledEdit *LabeledEdit8;

TButton *Button2;

TButton *Button3;

TButton *Button4;

TButton *Button5;

void __fastcall Button1Click(TObject *Sender);

void __fastcall Button2Click(TObject *Sender);

void __fastcall Button4Click(TObject *Sender);

void __fastcall Button3Click(TObject *Sender);

void __fastcall Button5Click(TObject *Sender);

private: // User declarations

public: // User declarations

__fastcall TForm1(TComponent* Owner);

};

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

extern PACKAGE TForm1 *Form1;

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

#endif

 

Рис.9.1 – форма с результатами выполнения задания

 

Перенесем на форму компоненты и зададим значения их свойствам. Со страницы Стандарт – три панели общего назначения GroupBox1,2,3 ( в свойство Caption впишите соответственно точка, круг, цилиндр), пять меток Label1,…,5 (Caption – координаты, координаты центра, координаты центра основания, без виртуальных функций, с виртуальными функциями), два компонента Memo1,2, пять кнопок Button1,…,5 (Caption – вычислить, очистить, вычислить, очистить, выход), причем под меткой Label4 (без виртуальных функций) расположено окно Memo1 и кнопки Button1,2 (соответственно вычислить, очистить). Со страницы Дополнительно – девять окон редактирования с присоединенными к ним метками LabeledEdit1,…,9, причем первые два окна расположены на панели GroupBox1 (точка), следующие три - на панели GroupBox2 (круг), и последние четыре - на панели GroupBox3 (цилиндр).

В представленном ниже файле реализации модуля формы LR_9.cpp программа драйвер иерархии по варианту 1 расположена в обработчике щелчка на кпопке Button1 (вычислить), а по варианту 2 – Button3 (вычислить).

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

 

#include <vcl.h>

#pragma hdrstop

 

#include "LR_9.h"

#include "f_cylinder.h"

#include "cylinder.h"

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

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

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

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

Memo1->Text="";

Memo2->Text="";

}

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

 

void __fastcall TForm1::Button1Click(TObject *Sender)

{

float x1,y1,x2,y2,r1,x3,y3,r2,h;

x1=StrToFloat(LabeledEdit1->Text);

y1=StrToFloat(LabeledEdit2->Text);

x2=StrToFloat(LabeledEdit3->Text);

y2=StrToFloat(LabeledEdit4->Text);

r1=StrToFloat(LabeledEdit5->Text);

x3=StrToFloat(LabeledEdit6->Text);

y3=StrToFloat(LabeledEdit7->Text);

r2=StrToFloat(LabeledEdit8->Text);

h=StrToFloat(LabeledEdit9->Text);

f_point fp(x1,y1),*pfp;

f_circle fcir(r1,x2,y2), *pfcir;

f_cylinder fcyl(h,r2,x3,y3), *pfcyl;

Memo1->Lines->Add("отображение объектов по их именам");

Memo1->Lines->Add("");

Memo1->Lines->Add("точка");

Memo1->Lines->Add(

" x = "+FloatToStrF(fp.getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(fp.getY(),ffGeneral,5,3));

Memo1->Lines->Add("");

Memo1->Lines->Add("круг");

Memo1->Lines->Add(

" x = "+FloatToStrF(fcir.getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(fcir.getY(),ffGeneral,5,3)+

" r = "+FloatToStrF(fcir.getradius(),ffGeneral,5,3));

Memo1->Lines->Add("площадь круга = "+

FloatToStrF(fcir.area(),ffGeneral,5,3));

Memo1->Lines->Add("");

Memo1->Lines->Add("цилиндр");

Memo1->Lines->Add(

" x = "+FloatToStrF(fcyl.getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(fcyl.getY(),ffGeneral,5,3)+

" r = "+FloatToStrF(fcyl.getradius(),ffGeneral,5,3)+

" h = "+FloatToStrF(fcyl.getheight(),ffGeneral,5,3));

Memo1->Lines->Add("площадь поверхности цилиндра = "+

FloatToStrF(fcyl.area(),ffGeneral,5,3));

Memo1->Lines->Add("объем цилиндра = "+

FloatToStrF(fcyl.volume(),ffGeneral,5,3));

Memo1->Lines->Add("");

Memo1->Lines->Add(

"отображение объектов по указателю класса точка");

Memo1->Lines->Add("");

pfp=&fp;

Memo1->Lines->Add("точка");

Memo1->Lines->Add(

" x = "+FloatToStrF(pfp->getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(pfp->getY(),ffGeneral,5,3));

Memo1->Lines->Add("");

pfp=&fcir;

Memo1->Lines->Add("круг");

Memo1->Lines->Add(

" x = "+FloatToStrF(pfp->getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(pfp->getY(),ffGeneral,5,3));

Memo1->Lines->Add("");

pfp=&fcyl;

Memo1->Lines->Add("цилиндр");

Memo1->Lines->Add(

" x = "+FloatToStrF(pfp->getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(pfp->getY(),ffGeneral,5,3));

Memo1->Lines->Add("");

Memo1->Lines->Add(

"отображение объектов по указателю класса круг");

Memo1->Lines->Add("");

pfcir=&fcir;

Memo1->Lines->Add("круг");

Memo1->Lines->Add(

" x = "+FloatToStrF(pfcir->getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(pfcir->getY(),ffGeneral,5,3)+

" r = "+FloatToStrF(pfcir->getradius(),ffGeneral,5,3));

Memo1->Lines->Add("площадь круга = "+

FloatToStrF(pfcir->area(),ffGeneral,5,3));

Memo1->Lines->Add("");

pfcir=&fcyl;

Memo1->Lines->Add("цилиндр");

Memo1->Lines->Add(

" x = "+FloatToStrF(pfcir->getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(pfcir->getY(),ffGeneral,5,3)+

" r = "+FloatToStrF(pfcir->getradius(),ffGeneral,5,3));

Memo1->Lines->Add("площадь основания цилиндра = "+

FloatToStrF(pfcir->area(),ffGeneral,5,3));

Memo1->Lines->Add("");

Memo1->Lines->Add(

"отображение объектов по указателю класса цилиндр");

Memo1->Lines->Add("");

pfcyl=&fcyl;

Memo1->Lines->Add("цилиндр");

Memo1->Lines->Add(

" x = "+FloatToStrF(pfcyl->getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(pfcyl->getY(),ffGeneral,5,3)+

" r = "+FloatToStrF(pfcyl->getradius(),ffGeneral,5,3)+

" h = "+FloatToStrF(pfcyl->getheight(),ffGeneral,5,3));

Memo1->Lines->Add("площадь поверхности цилиндра = "+

FloatToStrF(pfcyl->area(),ffGeneral,5,3));

Memo1->Lines->Add("объем цилиндра = "+

FloatToStrF(pfcyl->volume(),ffGeneral,5,3));

Memo1->Lines->Add("");

Memo1->Lines->Add(

"отображение объектов по указателю класса точка");

Memo1->Lines->Add(

"после приведения к типу указателя класса круг");

Memo1->Lines->Add("");

pfp=&fcir;

pfcir=(f_circle*)pfp;

Memo1->Lines->Add("круг");

Memo1->Lines->Add(

" x = "+FloatToStrF(pfcir->getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(pfcir->getY(),ffGeneral,5,3)+

" r = "+FloatToStrF(pfcir->getradius(),ffGeneral,5,3));

Memo1->Lines->Add("площадь круга = "+

FloatToStrF(pfcir->area(),ffGeneral,5,3));

Memo1->Lines->Add("");

pfp=&fcyl;

pfcir=(f_circle*)pfp;

Memo1->Lines->Add("цилиндр");

Memo1->Lines->Add(

" x = "+FloatToStrF(pfcir->getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(pfcir->getY(),ffGeneral,5,3)+

" r = "+FloatToStrF(pfcir->getradius(),ffGeneral,5,3));

Memo1->Lines->Add("площадь основания цилиндра = "+

FloatToStrF(pfcir->area(),ffGeneral,5,3));

Memo1->Lines->Add("");

Memo1->Lines->Add(

"отображение объектов по указателю класса точка");

Memo1->Lines->Add(

"после приведения к типу указателя класса цилиндр");

Memo1->Lines->Add("");

pfp=&fcyl;

pfcyl=(f_cylinder*)pfp;

Memo1->Lines->Add("цилиндр");

Memo1->Lines->Add(

" x = "+FloatToStrF(pfcyl->getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(pfcyl->getY(),ffGeneral,5,3)+

" r = "+FloatToStrF(pfcyl->getradius(),ffGeneral,5,3)+

" h = "+FloatToStrF(pfcyl->getheight(),ffGeneral,5,3));

Memo1->Lines->Add("площадь цилиндра = "+

FloatToStrF(pfcyl->area(),ffGeneral,5,3));

Memo1->Lines->Add("объем цилиндра = "+

FloatToStrF(pfcyl->volume(),ffGeneral,5,3));

}

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

 

void __fastcall TForm1::Button2Click(TObject *Sender)

{

Memo1->Clear();

}

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

 

void __fastcall TForm1::Button3Click(TObject *Sender)

{

float x1,y1,x2,y2,r1,x3,y3,r2,h;

x1=StrToFloat(LabeledEdit1->Text);

y1=StrToFloat(LabeledEdit2->Text);

x2=StrToFloat(LabeledEdit3->Text);

y2=StrToFloat(LabeledEdit4->Text);

r1=StrToFloat(LabeledEdit5->Text);

x3=StrToFloat(LabeledEdit6->Text);

y3=StrToFloat(LabeledEdit7->Text);

r2=StrToFloat(LabeledEdit8->Text);

h=StrToFloat(LabeledEdit9->Text);

shape *psh;

point p(x1,y1),*pp;

circle cir(r1,x2,y2),*pcir;

cylinder cyl(h,r2,x3,y3),*pcyl;

Memo2->Lines->Add(

"отображение объектов по их именам");

Memo2->Lines->Add("");

Memo2->Lines->Add("точка");

Memo2->Lines->Add(

" x = "+FloatToStrF(p.getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(p.getY(),ffGeneral,5,3));

Memo2->Lines->Add("");

Memo2->Lines->Add("круг");

Memo2->Lines->Add(

" x = "+FloatToStrF(cir.getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(cir.getY(),ffGeneral,5,3)+

" r = "+FloatToStrF(cir.getradius(),ffGeneral,5,3));

Memo2->Lines->Add("площадь круга = "+

FloatToStrF(cir.area(),ffGeneral,5,3));

Memo2->Lines->Add("");

Memo2->Lines->Add("цилиндр");

Memo2->Lines->Add(

" x = "+FloatToStrF(cyl.getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(cyl.getY(),ffGeneral,5,3)+

" r = "+FloatToStrF(cyl.getradius(),ffGeneral,5,3)+

" h = "+FloatToStrF(cyl.getheight(),ffGeneral,5,3));

Memo2->Lines->Add("площадь поверхности цилиндра = "+

FloatToStrF(cyl.area(),ffGeneral,5,3));

Memo2->Lines->Add("объем цилиндра = "+

FloatToStrF(cyl.volume(),ffGeneral,5,3));

Memo2->Lines->Add("");

Memo2->Lines->Add("отображение объектов по указателю");

Memo2->Lines->Add("абстрактного базового класса форма");

Memo2->Lines->Add("");

Memo2->Lines->Add("точка");

psh=&p;

Memo2->Lines->Add(

" x = "+FloatToStrF(psh->getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(psh->getY(),ffGeneral,5,3));

Memo2->Lines->Add("");

Memo2->Lines->Add("круг");

psh=&cir;

Memo2->Lines->Add(

" x = "+FloatToStrF(psh->getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(psh->getY(),ffGeneral,5,3)+

" r = "+FloatToStrF(psh->getradius(),ffGeneral,5,3));

Memo2->Lines->Add("площадь круга = "+

FloatToStrF(psh->area(),ffGeneral,5,3));

Memo2->Lines->Add("");

Memo2->Lines->Add("цилиндр");

psh=&cyl;

Memo2->Lines->Add(

" x = "+FloatToStrF(psh->getX(),ffGeneral,5,3)+

" y = "+FloatToStrF(psh->getY(),ffGeneral,5,3)+

" r = "+FloatToStrF(psh->getradius(),ffGeneral,5,3)+

" h = "+FloatToStrF(psh->getheight(),ffGeneral,5,3));

Memo2->Lines->Add("площадь поверхности цилиндра = "+

FloatToStrF(psh->area(),ffGeneral,5,3));

Memo2->Lines->Add("объем цилиндра = "+

FloatToStrF(psh->volume(),ffGeneral,5,3));

}

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

void __fastcall TForm1::Button4Click(TObject *Sender)

{Memo2->Clear();}

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

void __fastcall TForm1::Button5Click(TObject *Sender)

{ exit(0); }

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

Тестирование и использование приложения

1.Выполните тестирование согласно рис.9.1 и получите результаты, представленные на рис.9.2. Объясните полученные результаты.

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

 

 

Рис.9.2 – результаты выполнения задания

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

1.Приведите примеры прямого, косвенного, множественного, открытого, защищенного и закрытого наследования. Как в этих случаях осуществляется доступ к открытым, защищенным и закрытым элементам базового класса?

2.Как можно отобразить объекты классов иерархии?

3.При каком условии и почему каждый объект производного класса является также объектом соответствующего базового класса?

4.Какой класс иерархии имеет наибольшее количество объектов?

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

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

7.Почему можно присваивать указатель производного класса (адрес объекта производного класса) указателю базового класса, но не наоборот?

8.Когда указатель на объект производного класса неявно преобразуется в указатель на объект базового класса? Приведите пример.

9.Как указатель базового класса преобразовать в указатель производного класса? На что должен указывать при этом указатель базового класса?

10.Как отображается объект производного класса по указателю базового класса?

11.Как переопределяют функцию-элемент базового класса в производном классе? Приведите пример.

12.Как создается объект производного класса иерархии? Как он разрушается?

13.Влияет ли создание производного класса на исходный код базового класса?

14.Как можно изменять базовый класс, чтобы не вносить изменений в производный класс?

15.Что является признаком абстрактного базового класса?

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

17.Почему предпочтительнее создавать иерархию классов, порожденную абстрактным базовым классом?

18.Какое требование нужно соблюдать при переопределении виртуальных функций?

19.Что такое статическое связывание? Приведите пример.

20.Объясните суть полиморфизма. Когда и как используется полиморфизм? Как реализовать полиморфизм?

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

22.Как реализовано динамическое связывание?

23.Как виртуальные функции и полиморфное программирование могут исключить потребность в применении логики оператора switch?

24.Почему деструкторы необходимо объявлять виртуальными?

25.Почему конструкторы не могут быть виртуальными?

 

Задания

 

1.Форма : прямоугольник : параллелепипед (периметр, площадь, площадь поверхности, объем).

2.Точка : окружность : дуга : сегмент (длина, периметр, площадь).

3.Форма : круг : прямой круговой конус : усеченный прямой круговой конус (площадь, площадь поверхности, объем).

4.Двумерная форма : квадрат : ромб (периметр, площадь).

5.Строка : строка-идентификатор. Если в составе инициализирующей строки будут встречены недопустимые символы, строка-идентификатор создается пустой. (Использовать динамическую память, реализовать операции: =, +, >).

6.Строка : битовая строка. Если в составе инициализирующей строки будут встречены любые символы, отличные от символов ‘0 ’ или ‘1 ’, битовая строка принимает нулевое значение. (Использовать динамическую память, реализовать операции: =, +, ==).

7.Строка : десятичная строка. Строки производного класса могут содержать только символы ‘–‘ и ‘+’, задающие знак числа, и цифры. Символы ‘-‘ или ‘+’ могут находиться только в первой позиции числа, причем символ ‘+’ может отсутствовать, в этом случае число считается положительным. Если в составе инициализирующей строки будут встречены любые символы, отличные от допустимых, десятичная строка принимает нулевое значение. (Использовать динамическую память, реализовать операции: =, +, *, >).

8.Строка : комплексное число. Строки производного класса состоят из двух полей, разделенных символом ‘i’. Первое поле задает значение реальной части числа, а второе – мнимой. Каждое из полей может содержать только символы десятичных цифр и символы ‘–‘ и ‘+’, задающие знак числа. Символы ‘–‘ или ‘+’ могут находиться только в первой позиции числа, причем символ ‘+’ может отсутствовать, в этом случае число считается положительным. Если в составе инициализирующей строки будут встречены любые символы, отличные от допустимых, комплексное число принимает нулевое значение. Примеры строк: 33i12, -7i100, +5i-21. (Использовать динамическую память, реализовать операции: =, +, *, ==).

9.Переменная целого типа : множество целых (операции =, +, >).

10. Числовая переменная : массив : матрица (сложение, умножение, сортировка).

 

БИБЛИОГРАФИЧЕСКИЙ СПИСОК

1.Дейтел Х.М., Дейтел П.Дж. Как программировать на С++. Четвертое издание. Пер. с англ. – М.:ООО “БИНОМ-Пресс”, 2006 г. - 912 с.

2.Топп У. Структуры данных в С++: Пер. с англ./У. Топп, У. Форд. – М.: БИНОМ, 1999 г. - 816 с.: ил.

3.Архангельский А.Я. Программирование в C++ Builder 6. – М.:ЗАО “Издательство БИНОМ”, 2004 г. – 1152 с.

4.Чуркин В.В. Сборник заданий по технологии программирования. - Киров: Изд. ВятГУ, 2009 г. - 54 с.

5.Чуркин В.В. Основы интегрированной среды разработки приложений Borland C++ Builder 6. – Киров: Изд. ВятГУ, 2005 г. – 116 с.

 



<== предыдущая лекция | следующая лекция ==>
БИНАРНОЕ УПОРЯДОЧЕННОЕ ДЕРЕВО | ПРОГРАММИРОВАНИЕ НА ЯЗЫКЕ ВЫСОКОГО УРОВНЯ ПАСКАЛЬ


Карта сайта Карта сайта укр


Уроки php mysql Программирование

Онлайн система счисления Калькулятор онлайн обычный Инженерный калькулятор онлайн Замена русских букв на английские для вебмастеров Замена русских букв на английские

Аппаратное и программное обеспечение Графика и компьютерная сфера Интегрированная геоинформационная система Интернет Компьютер Комплектующие компьютера Лекции Методы и средства измерений неэлектрических величин Обслуживание компьютерных и периферийных устройств Операционные системы Параллельное программирование Проектирование электронных средств Периферийные устройства Полезные ресурсы для программистов Программы для программистов Статьи для программистов Cтруктура и организация данных


 


Не нашли то, что искали? Google вам в помощь!

 
 

© life-prog.ru При использовании материалов прямая ссылка на сайт обязательна.

Генерация страницы за: 0.878 сек.