Порядок вызова конструкторов и деструкторов

Класс как область видимости

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

 имя_класса:: имя_члена_класса или

:: имя - для имен глобальных функций и переменных.

 Пример:

int ia1;

 void f1(int b1) {

 ia1 = ia1 + b1; }

class x {

 int ia1;

public:

x(){ia1 = 0;}

void f1(int b1){

::f1(b1); // вызов глобальной функции

}

};

int main(){

 x a2;

a2.f1(2);

return 0; }

 

19) Конструктор преобразования и конструкторы с двумя и более параметрами

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

 box b2(1,2,3);

box b3(5);

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

Если уже описан класс T и описывается новый класс X, то его конструкторы преобразования могут иметь любой из следующих прототипов:

X(T);

X(T&);

X(const T&);

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

class X {

 int x1;

 public:

X(int px1 = 0}

};

 Для такого класса будут верны следующие объявления объектов:

int main(){

… Х x1, x2(1); … }

Порядок вызова конструкторов и деструкторов

Итак, конструкторы можно классифицировать по набору входных парамет- ров следующим образом: 1) x() – конструктор умолчания

 2) x(x&), x(const x&) – конструктор копирования

3) x(t), x(t&), x(const t&) – конструктор преобразования

4) конструктор с двумя и более параметрами

При создании объекта конструкторы вызываются в следующем порядке:

1) Конструкторы базовых классов, если класс для создаваемого объекта является наследником других классов в порядке их появления в описании класса. Если в списке инициализации описываемого класса присутствует вызов конструктора преобразования (или конструктора с двумя и более параметрами) базового класса, то вызывается конструктор преобразования (или конструктор с двумя и более параметрами), иначе вызывается конструктор умолчания базового класса.

2) Конструкторы умолчания всех вложенных информационных членов, которые не перечислены в списке инициализации, и конструкторы преобразования, копирования и конструкторы с двумя и более параметрами всех вложенных информационных членов, которые перечислены в списке инициализации. Все перечисленные в данном пункте конструкторы (умолчания, преобразования, копирования, с двумя и более параметрами) вызываются в порядке описания соответствующих информационных членов в классе.

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

Деструкторы вызываются в обратном порядке:

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

2) Деструкторы вложенных объектов в порядке, обратном порядку их описания.

3) Деструкторы базовых классов в обратном порядке их задания.

Перегрузка функций

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

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

Пример:

class X1{

int ix1;

 public:

 int f1(){... }

 ... };

class Y1: protected X1 {

... };

class Z1: public Y1 {

 ... };

class X2{

protected:

 int ix2;

 public:

int f2(){... }

 ... };

class Y2: X2 {...};

class Z2: public Y2 {...};

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

 #include <iostream>

 using namespace std;

class twom {

double x,y;

 public:

twom(double x1=1, double y1=1): x(x1), y(y1) {}

 double sq(){

return x*y; } };

class thm: private twom {

double z;

public:

 thm(double x1 = 1, double y1 = 1,

double z1 = 1):twom(x1,y1), z(z1){}

double vol(){return sq()*z;} };

int main(){

thm t1(1,2,3);

double d1;

d1 = t1.vol();

cout << "vol= " << d1 << '\n';

return 0; }

 

Интерфейсы

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

Интерфейсы, наряду с абстрактными классами и протоколами, устанавливают взаимные обязательства между элементами программной системы, что является фундаментом концепции программирования по контракту (англ. design by contract, DbC). Интерфейс определяет границу взаимодействия между классами или компонентами, специфицируя определённую абстракцию, которую осуществляет реализующая сторона.

Интерфейс в ООП является строго формализованным элементом объектно-ориентированного языка и широко используется в исходном коде программ.

Интерфейсы позволяют наладить множественное наследование объектов и в то же время решить проблему ромбовидного наследования. В языке C++ она решается через наследование классов с использованием ключевого слова virtual.

Шаблонные классы

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

 Объявление шаблона класса:

 template  Список_параметров шаблона   class Имя класса {...};

Процесс генерации объявления класса по шаблону класса и фактическим аргументам шаблона называется инстанцированием шаблона. Обычно он совмещается с объявлением объекта соответствующего конкретного типа.
Синтаксис такого объявления:

 Имя класса      Список_параметров шаблона      Идентификатор объекта;

 Функции-члены класса-шаблона автоматически становятся функциями-шаблонами. Для них не обязательно явно задавать ключевое слово template.

Дружественная функция, которая использует параметры шаблона, сама является шаблоном. Конкретная реализация такой функции с учётом специфицированных параметров (порожденная функция) является дружественной для такого инстанцирования класса, которое совпадает по типам с фактическими типами аргументов порожденной функции.

Пример:

template  <class T> class Y{...};

 template <class T> class X

 {

//...

 public:

friend void f1();

                                                                                             // функция f1() является

                                                                                             // дружественной ко всем

                                                                                             // инстанцированиям

                                                                                             // класса

friend Y f2(Y par1);

                                                                                             // порождение функции f2()

                                                                                            // для фактического типа T

                                                                                            // является дружественной

                                                                                           // только к тому

                                                                                           // инстанцированию класса

                                                                                           // X, которое подходит по

                                                                                          // фактическому

                                                                                          // типу–параметру.

//...

 };

template Y f2(Y par1)

{ /*... */ }

Статические члены создаются для каждого инстанцирования класса.

Пример:

 template class X {

static T x1;

//...

};

int X:: x1 = 0;

 double X:: x1 = 1.5;

 int main() {

X <int>xx1;

X <double>xx2;

...

 return 0; }

61) /* Создается класс Student. Формируется динамический массив объектов. При

тестировании выводится: сформированный список студентов, список студентов

заданного факультета, список студентов для заданных факультета и курса.*/

#include <conio.h>

#include <string.h>

#include <iostream.h>

struct date // дата рождения

{char daymon[6];

int year; };

//======= class Student =================

class Student{

char name[30]; //private

date t;

char adr[30], fac[20];

int kurs;

public:

Student();

char *getfac();

int getkurs();

void show();

};

Student::Student()

{cout<<"Input name:"; cin>>name;

cout<<"Input date of born\n";

cout<<"Day.mon:"; cin>>t.daymon;

cout<<"Year:"; cin>>t.year;

cout<<"Input adr:"; cin>>adr;

cout<<"Input fac:"; cin>>fac;

cout<<"Input kurs:"; cin>>kurs;

}

void Student::show()

{

cout<<"Name:"<<name<<endl;

cout<<"Was born:"<<t.daymon<<'.'<<t.year<<endl;

cout<<"Address:"<<adr<<endl;

cout<<"Fac:"<<fac<<endl;

cout<<"Kurs:"<<kurs<<endl;

}

char *Student::getfac() { return fac; }

int Student::getkurs() { return kurs; }

void spisfac(Student spis[],int n)//список студентов заданного факультетата

{char fac[20];

cout<<"Input faculty:"; cin>>fac;

for(int i=0;i<n;i++)

if(strcmp(spis[i].getfac(),fac)==0)spis[i].show();

}

void spisfackurs(Student spis[],int n)

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

{int i,k;

char fac[20];

cout<<"Input faculty:"; cin>>fac;

cout<<"Input the course:"; cin>>k;

for(i=0;i<n;i++)

if ((strcmp(spis[i].getfac(),fac)==0)&&(spis[i].getkurs()==k))

spis[i].show();

}

//========= main ================

void main()

{ Student *spis;

int n;

cout<<"Input a number of students: "; cin>>n;

spis=new Student [n];

for(int i=0;i<n;i++) {

cout<<"=============================="<<endl;

spis[i].show();

}

spisfac(spis,n);

spisfackurs(spis,n);

delete [] spis;

cout<<"press any key!"

while(!kbhit());

}

 

ООП67)

Разработать класс Train (Пункт назначения, Номер поезда, Время отправления, Число общих мест, Купейных, Плацкартных). Включить в класс методы set (…), get (…), show (…). Определить другие методы. Создать массив объектов. Вывести список поездов, следующих до заданного пункта назначения.

67)#include <iostream>
#include <conio.h>
#include <string.h>

using namespace std;

class train
{
char punkt [20];
int num_train;
double time;
int Placard;
int Kupeynykh;
int common;
public:
train();
char *getpunkt();
int getnum_train();
double gettime();
int getPlacard();
int getKupeynykh();
int getcommon();
void show();
};

train::train()
{
cout «"input punkt:";cin»punkt;
cout «"input num_train:";cin»num_train;
cout «"input time:";cin»time;
cout «"input Placard:";cin»Placard;
cout «"input Kupeynykh:";cin»Kupeynykh;
cout «"input common:";cin»common;
}

void train::show()
{
cout«"punkt:"«punkt«endl;
cout«"num_train:"«num_train«endl;
cout«"time:"«time«endl;
cout«"Placard:"«Placard«endl;
cout«"Kupeynykh:"«Kupeynykh«endl;
cout«"common:"«common«endl;
}
char *train::getpunkt() {return punkt;}
int train::getnum_train() { return num_train; }
double train::gettime() { return time; }
int train::getPlacard() { return Placard; }
int train::getKupeynykh() { return Kupeynykh; }
int train::getcommon() { return common; }
void spistrian(train spis[],int n)
{
// int train;
// cout«"input train:"; cin»train;
for (int i=0;i<n;i++)
// if(strcmp(spis[i].getnum_train(),train)==0)
spis[i].show();
}
void spistrianpunkt(train spis [], int n)
{
int i,k;
char punkt[20];
//int trian();
//cout«"input trian:"; cin»trian;
cout«"input serchin punkt:"; cin»punkt;
for(i=0;i<n;i++)
if ((strcmp(spis[i].getpunkt(),punkt)==0))
spis[i].show();
}

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char** argv) {

train *spis;
int n;
cout«"input a number of train:"; cin»n;
spis=new train [n];
for (int i=0;i<n;i++)
{
cout«"=========="«endl;
spis[i].show();
}
//cout«"=======================";
spistrianpunkt(spis,n);
delete [] spis;
cout«"press sny key!";
while(!kbhit());
return 0;
}

Разработать класс Patient (Фамилия, Имя, Отчество, Адрес, Номер медицинской карты, Диагноз). Включить в класс методы set (…), get (…), show (…). Определить другие методы. Создать массив объектов. Вывести список пациентов, имеющих данный диагноз.

73)#include <iostream>
#include <conio.h>
#include <string.h>
using namespace std;

class patient{
char familya[30];
char imiya[30];
char otchestvo[30];
int nomer karty;
char adres[20],diagnoz[20];

public:
patient();
char *getfamiliya();
char *getimiya();
char *getotchestvo();
char *getdiagnoz();
char);
int getnomer karty(;
void show();
};
patient::patient()
{cout«"Input familya:"; cin»familya;
cout«"Input imiya";cin»imiya;
cout«"Input otchestvo:"; cin»otchestvo;
cout«"Input diagnoz:"; cin»diagnoz;
cout«"Input adres";cin»adres;
cout«"Input nomer karty:"; cin»nomer karty;
}
void patient::show()
{
cout«"familya:"«familya«endl;
cout«"imiya:"«imiya«endl;
cout«"otchestvo:"«otchestvo«endl;
cout«"diagnoz:"«diagnoz«endl;
cout«"adres:"«adres«endl;
cout«"nomer karty:"«nomer karty«endl;
}
char *patient::getfamilya() { return familya; }
char *patient::getimiya() { return imiya; }
char *patient::getotchestvo() { return otchestvo; }
char *patient::getdiagnoz() { return diagnoz; }
char *patient::getadres() { return adres; }
int patient::getnomer karty() { return nomer karty; }
void spispatient(patient spis[],int n)
{

for(int i=0;i<n;i++)

spis[i].show();
}
void spisdiagnoz(patient spis[],int n)
{
int i,k;
char specifieddiagnoz[20];

cout«"Input specifieddiagnoz:"; cin»specifieddiagnoz;
for(i=0;i<n;i++)
if ((strcmp(spis[i].getdiagnoz(),specifieddiagnoz)==0))
spis[i].show();
}

int main(int argc, char** argv) {
patient *spis;
int n;
cout«"input a number of patient:"; cin»n;
spis=new patient [n];
for (int i=0;i<n;i++)
{
cout«"=========="«endl;
spis[i].show();
}
spisaddress(spis,n);
delete [] spis;
cout«"press sny key!";
while(!kbhit());
return 0;
}

 

Класс как область видимости

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

 имя_класса:: имя_члена_класса или

:: имя - для имен глобальных функций и переменных.

 Пример:

int ia1;

 void f1(int b1) {

 ia1 = ia1 + b1; }

class x {

 int ia1;

public:

x(){ia1 = 0;}

void f1(int b1){

::f1(b1); // вызов глобальной функции

}

};

int main(){

 x a2;

a2.f1(2);

return 0; }

 

19) Конструктор преобразования и конструкторы с двумя и более параметрами

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

 box b2(1,2,3);

box b3(5);

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

Если уже описан класс T и описывается новый класс X, то его конструкторы преобразования могут иметь любой из следующих прототипов:

X(T);

X(T&);

X(const T&);

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

class X {

 int x1;

 public:

X(int px1 = 0}

};

 Для такого класса будут верны следующие объявления объектов:

int main(){

… Х x1, x2(1); … }

Порядок вызова конструкторов и деструкторов

Итак, конструкторы можно классифицировать по набору входных парамет- ров следующим образом: 1) x() – конструктор умолчания

 2) x(x&), x(const x&) – конструктор копирования

3) x(t), x(t&), x(const t&) – конструктор преобразования

4) конструктор с двумя и более параметрами