Наследование. Открытое, защищенное и закрытое
Наследование – это одна из главных особенностей ООП. Наследование
заключается в том, что один класс наследует некоторые свойства другого. Этот принцип предполагает использование базового класса, описывающего наиболее общие свойства ряда объектов. Производные классы включают в себя все черты базового класса, а также добавляют новые, характерные только для объектов данного класса. Спецификация описания производного класса имеет следующий синтаксис:
сlass имя_производного_класса : [атрибут] имя_базового_класса
{тело_произв_класса} [список объектов];
Двоеточие отделяет производный класс от базового. Как отмечалось ра-
нее, ключевое слово class может быть заменено на слово struct. При этом все компоненты будут иметь атрибут public. Следует отметить, что объединение (union) не может быть ни базовым, ни производным классом.
Одна из особенностей порожденного класса – видимость унаследованных
компонент базового класса. Для определения доступности компонент базового класса из компонент производного класса используются ключевые слова: private, protected и public (атрибуты базового класса). Например:
class base
{ private : private-компоненты;
public : public-компоненты;
protected : protected-компоненты;
};
class proizv_priv : private base { любые компоненты};
class proizv_publ : public base { любые компоненты};
class proizv_prot : protected base { любые компоненты};
Производный класс наследует атрибуты компонент базового класса в за-
висимости от атрибутов базового класса следующим образом:
если базовый класс имеет атрибут public, то компоненты public и protected
базового класса наследуются с атрибутами public и protected в производном классе. Компоненты private остаются private-компонентами базового класса; если базовый класс имеет атрибут protected, то компоненты public и protected базового класса наследуются с атрибутом protected в производном классе. Компоненты private остаются private-компонентами базового класса; если базовый класс имеет атрибут private, то компоненты public и protected базового класса наследуются с атрибутами private в производном классе. Компоненты private остаются private-компонентами базового класса. Отмеченные типы наследования называются: внешним, защищенным и внутренним наследованием.
Из этого видно, что использование атрибутов private и protected ограничи-
вает права доступа к компонентам базового класса через производный от базового класс. Доступ к данным базового класса из производного осуществляется по имени (опуская префикс).
#include <iostream>
using namespace std;
#include <string.h>
#define n 10
class book // базовый класс book
{ protected:
char naz[20]; // название книги
int kl; // количество страниц
public:
book(char *,int); // конструктор класса book
~book(); // деструктор класса book
};
class avt : public book // производный класс
{ char fm[10]; // фамилия автора
public:
avt(char *,int,char *); // конструктор класса avt
~avt(); // деструктор класса avt
void see();
};
enum razd {teh,hyd,uch};
class rzd : public book // производный класс
{ razd rz; // раздел каталога
public:
rzd(char *, int, razd); // конструктор класса rzd
~rzd(); // деструктор класса rzd
void see();
};
book::book(char *s1,int i) : kl(i)
{ cout << "\n работает конструктор класса book";
strcpy(naz,s1);
}
book::~book()
{cout << "\n работает деструктор класса book";}
avt::avt(char *s1,int i,char *s2) : book(s1,i)
{ cout << "\n работает конструктор класса avt";
strcpy(fm,s2);
}
avt::~avt()
{cout << "\n работает деструктор класса avt";}
void avt::see()
{ cout<<"\nназвание : "<<naz<<"\nстраниц : "<<kl;
}
rzd::rzd(char *s1,int i,razd tp) : book(s1,i), rz(tp)
{ cout << "\n работает конструктор класса rzd";
}
rzd::~rzd()
{cout << "\n работает деструктор класса rzd";}
void rzd::see()
{ switch(rz)
{ case teh : cout << "\nраздел технической литературы"; break;
case hyd : cout << "\ nраздел художественной литературы "; break;
case uch : cout << "\ nраздел учебной литературы "; break;
}
}
int main()
{avt av("Книга 1",123," автор1");//вызов конструкторов классов book и avt
rzd rz("Книга 1",123,teh); //вызов конструкторов классов book и rzd
av.see();
rz.see();
}
Виртуальные функции.
Прежде чем коснуться самого применения виртуальных функций, необ-
ходимо рассмотреть такие понятия, как раннее и позднее связывание.
Во время раннего связывания вызывающий и вызываемый методы связы-
ваются при первом удобном случае, обычно при компиляции.
При позднем связывании вызываемого и вызывающего методов они не
могут быть связаны во время компиляции. Поэтому реализован специальный механизм, который определяет, как будет происходить связывание вызываемого и вызывающего методов, когда вызов будет сделан фактически. Очевидно, что скорость и эффективность при раннем связывании выше, чем при использовании позднего связывания. В то же время позднее связывание обеспечивает некоторую универсальность процесса связывания. Один из основных принципов объектно-ориентированного программирования предполагает использование идеи «один интерфейс – множество методов реализации». Эта идея заключается также в том, что базовый класс обеспечивает все элементы, которые производные классы могут непосредственно использовать, плюс набор функций, которые производные классы должны реализовать путем их переопределения. Наряду с механизмом перегрузки функций это достигается использованием виртуальных (virtual) функций. Виртуальная функция
– это функция, объявленная с ключевым словом virtual в базовом классе и переопределенная в одном или нескольких производных от этого классах. При вызове объекта базового или производных классов динамически (во время выполнения программы) определяется, какую из функций требуется вызвать, основываясь на типе объекта. Преимущество применения виртуальных методов заключается в том, что при этом используется именно механизм позднего связывания, который допускает обработку объектов, тип которых неизвестен во время компиляции.
#include "iostream"
#include "iomanip"
using namespace std;
#include "string.h"
class grup // базовый класс
{ protected:
char *fak; // наименование факультета
long gr; // номер группы
public:
grup(char *FAK,long GR) : gr(GR)
{ if (!(fak=new char[20]))
{ cout<<"ошибка выделения памяти"<<endl;
return;
}
strcpy(fak,FAK);
}
~grup()
{ cout << "деструктор класса grup " << endl;
delete fak;
}
virtual void see(void); // объявление виртуальной функции
};
class stud : public grup // производный класс
{ char *fam; // фамилия
int oc[4]; // массив оценок
public:
stud(char *FAK,long GR,char *FAM,int OC[]): grup(FAK,GR)
{ if (!(fam=new char[20]))
{ cout<<"ошибка выделения памяти"<<endl;
return;
}
strcpy(fam,FAM);
for(int i=0;i<4;oc[i]=OC[i++]);
}
~stud()
{ cout << "деструктор класса stud " << endl;
delete fam;
}
void see(void);
};
void grup::see(void) // описание виртуальной функции
{ cout << fak << gr << endl;}
void stud::see(void) //
{ grup ::see(); // вызов функции базового класса
cout <<setw(10) << fam << " ";
for(int i=0; i<4; cout << oc[i++]<<’ ’);
cout << endl;
}
int main()
{ int OC[]={4,5,5,3};
grup gr1("факультет 1",123456), gr2("факультет 2",345678), *p;
stud st("факультет 2",150502,"Иванов",OC);
p=&gr1; // указатель на объект базового класса
p->see(); // вызов функции базового класса объекта gr1
(&gr2)->see(); // вызов функции базового класса объекта gr2
p=&st; // указатель на объект производного класса
p->see(); // вызов функции производного класса объекта st
return 0;
}