bigpo.ru
добавить свой файл
  1 ... 2 3 4 5 ... 7 8
Андрей

<Березин

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; // чисто виртуальная функция J

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

};

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

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 (pb); // работает, т.к. pb->Derived



<< предыдущая страница   следующая страница >>