Лекции по СП, страница 4

char *address;

public:

Person (char *n, int a, char *addr);

~Person ();

char* getName () const { return name; }

void print () const { /* печать данных */ };

};

Person::Person (char *n, int a, char *addr){

name = new char [strlen(n) + 1];

strcpy (name, n); age = a;

addr = new char [strlen(addr) + 1];

strcpy (address, addr);

}

Person::~Person () {delete[] name; delete[] address;}

Опишем теперь класс-сотрудника. Наследование осуществляется с указанием одного из трёх модификаторов доступа, но, как привило, используется public. Конструкторы, деструкторы и операции присваивания не наследуются, поэтому в следующем коде мы унаследуем 3 поля и 2 метода.

class Employee: public Person { // работник

protected:

char *appointment;

int level;

double earnings;

public:

Employee (char *n, int a, char *addr,

char *app, int l, int ear); // ear – креатив ТВ 

~Employee();

void print () const;

};

Возникает вопрос, как повторно использовать код конструктора? А вот так:

Employee::Employee (char *n, int a, char *addr,

char *app, int l, int ear): Person (n, a, addr){

appointment = new char [strlen(app) + 1];

strcpy (appointment, app);

level = l; earnings = ear;

}

Сначала работает конструктор Person, а потом наш конструктор. Если не написать двоеточие с «вызовом» конструктора класса Person, будет вызываться конструктор умолчания для Person (а в данном случае мы получим ошибку компиляции). Опишем теперь деструктор, иначе будет работать дефолтный, а он нам не подходит.

Employee::~Employee {delete[] appointment;}

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

Оставим getName() такой, какая она была, а print() перегрузим. Можно считать базовый класс об’емлющей областью описания, а производный – внутренней. Таким образом, если описать функцию, которая была об’явлена в базовом классом, то функция из базового класса скрывается.

void Employee::print() const{

Person::print(); // вызываем print() базового

/* печать appointment, level и earnings */

}

int main (){

Person h (“Andrey Ivanov”, 20, “fds7”);

Employee e (“Boris I. Berezin”, 58, “635”,

“top-manager”, 12, 65536.00);

h.print(); // информация об Андрюхе – 3 поля

e.print(); // информация о БИБ – 6 полей

cout<<h.getName()<<endl // Андрей

<<e.getName()<<endl; // Березин

Person *pp = &h; // указатель на базовый

Employee *pe = &e; // указатель на производный

pp->print(); // Андрей

pe->print(); // Борис Иванович

}

Как и в C, в C++ можно присваивать значение одного указателя значению другого указателя без явного преобразования, если:

• если они указывают на один тип (с точностью до typedef);

• указателю на void можно присваивать указатель любого типа;

• присваиваем целый 0 (преобразуется к NULL).

В C++ появилась новая тема. Без явного преобразования указателю на базовый тип можно присвоить значение указателя на производный тип. Такое присваивание возможно, если первый класс однозначный, доступный и базовый по отношению ко второму:

pp = pe;

Класс называется доступным, если он наследуется со словом public или protected.

Если используется модификатор public, то все члены класса наследуются так же, как они об’явлены в базовом. Если мы напишем protected, то public-члены будут наследоваться как protected. Если мы напишем private, то доступа к членам базового класса не будет, хотя имена их будут «считаться» используемыми.. ХЗ зачем нужно, но так можно…

Например, мы пишем инструкцию:

pp->print();

Возникает дилемма, что вызывать? Существует два типа определения:

• статическое – по типу указателя,

• динамическое – по типу об’екта, на который он указывает.

Если не используются виртуальные функции, то функция определяется статически. В нашем случае вызовется Person::print().

При динамическом вызове мы сталкиваемся с динамическим полиморфизмом, а не со статическим, как раньше. В этом случае компилятор анализирует об’ект, который лежит по указателю. Но для этого нужно определить виртуальную функцию. Для этого при об’явлении функции в базовом классе указывают ключевое слово virtual:

virtual void print () const;

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

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

Библия виртуальных функций by ТВ.

Чтобы включился механизм виртуализации, должны быть выполнены следующие требования:

• присутствует иерархия классов;

• в базовом классе функция об’явлена как виртуальная;

• в производном классе описана функция с таким же профилем (совпадают имя, список параметров с точностью до имён и тип результата);

• используется вызов функции через указатель (без уточнения с помощью оператора разрешения контекста ::).

Однако к этим четырём заповедям нужно прибавить ещё некоторые замечания:

• Если описывать функцию вне класса, то в её профиле virtual не повторяют. В описании функции в производном классе также можно указать virtual, но это ни на что не повлияет, разве что на наследство производного.

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

• Если списки параметров совпадают, а типы результата существенно отличаются, мы получим синтаксическую ошибку.

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

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

• Если вызываем метод через об’ект (h.print()), то виртуальность не работает, статическое определение по типу об’екта, от которого его вызываем.

• При явном указании класса виртуальность не работает, даже если функция вызвана через указатель, то есть pp->Person::print(); – статическое определение.

В заключение, можно дать настоятельный совет: делайте деструкторы виртуальными!

Пусть где-то в программе у нас написано:

Person *pq = new Employee (“Vova Putin”, 54, ”The Kremlin”,

”The President of Russia”, 0, 0);

/* что-то делаем с работником */

delete pq;

Сначала мы должны вызвать деструктор, а потом освободить память, занимаемую об’ектом. В нашем случае вызовется статический деструктор, то есть по типу указателя. А он удалит не всё, что нам нужно. Зато, если в базовом классе об’явить

virtual ~Person();

динамически вызовется деструктор нужного нам класса и освободит всё, что надо.

Абстрактные классы.

Суперклассический пример. Фигуры.

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

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

class Shape {

public:

virtual double area () = 0; // чисто виртуальная функция 

/* ещё какая-то логика */

};

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

class Rectangle: public Shape {

double h, w;

public:

double area () { return h*w; }

/* ещё какая-то логика */

};

class Circle: public Shape {

double r;

public:

double area () { return 3.14*r*r; }

/* ещё какая-то фигня */

};

В таком случае можно написать:

Shape *p[100]; // массив из указателей на Shape

double total = 0;

В массиве можно сохранять указатели и на круги, и на прямоугольники:

for (int i = 0; i<100; i++) total += p[i]->area();

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

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

Динамическая идентификация типа

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

class Base {

/* некоторый полиморфный класс */

};

class Derived: public Base { /* производный класс */};

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

Base b, *pb; Derived d, *pd;

pd = &d;

pb = pd; // так можем, а наоборот - нет

Присваивание pd = pb в нашем случае было бы логично, так как в указателе на базовый тип записан об’ект производного типа. Для этого служит операция

dynamic_cast<T*> (p);

попытка преобразовать указатель p к типу T*. Либо преобразование работает, либо возвращает NULL. Попытка завершается успешно, если:

• p содержит адрес об’екта типа T

• p содержит адрес об’екта типа, для которого T – однозначный доступный базовый класс.

Мы можем написать:

pd = dynamic_cast<Derived*> (pb); // работает, т.к. pb->Derived

if (pd) /* всё хорошо */; else /* всё плохо */;

pb = &b;

pd = dynamic_cast<Derived*> (pb); // pd == NULL

pd = &d;

pb = dynamic_cast<Base*> (pd); // а так тоже можно

В C++ рекомендуется не делать статических явных преобразований типа. В нашем случае можно было написать pd = (Derived*)pb, но это плохо, так как нет контроля, а при динамическом кастинке тип преобразуется, только если это будет разумно.

Кстати, есть ещё один вариант операции: dynamic_cast<T&> (r);

Если ни одно из двух условий не выполняется, то генерируется исключение bad_cast (только для ссылок!).

Также есть операция typeid (об’ект) или typeid (имя_типа), которая возвращает ссылку на об’ект класса typeinfo. В нём перегружены операции сравнения и определена функция, возвращающая имя типа:

bool operator== (const typeinfo&);

bool operator!= (const typeinfo&);

const char* name ();

А вот так их можно использовать:

if (typeid(*pb) == typeid(Derived))

pd = dynamic_cast<Derived*> (pb);

// уже не нужно проверять pd != NULL

cout<<typeid(*pb).name()<<endl; // визуализация – узнать тип *pb

Есть ещё три оператора, которыми можно не пользоваться, потому что их не было в C. Но при программировании на C++ их лучше писать.