Производные классы, наследование

Виртуальные методы

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

class Item
{
public:
     virtual String Name(void) const;
     . . .
};
class Book : public Item
{
public:
     virtual String Name(void) const;
     . . .
};
class Magazine : public Item
{
public:
     virtual String Name(void) const;
     . . .
};

Реализация метода Name для базового класса тривиальна: поскольку название известно только производному классу, мы будем возвращать пустую строку.

String
Item::Name(void) const
{
     return "";
}

Для книги название состоит из фамилии автора, названия книги, издательства и года издания:

String
Book::Name(void) const
{
     return author + title + publisher + 
            String(year);
}

У журнала полное название состоит из названия журнала, года и номера:

String
Magazine::Name(void) const
{
     return title + String(year) + 
            String(number);
}

Методы Name определены как виртуальные с помощью описателя virtual, стоящего перед определением метода. Виртуальные методы реализуют идею полиморфизма в языке Си++. Если в программе используется указатель на базовый класс   Item и с его помощью вызывается метод Name:

Item* ptr;
. . .
String name = ptr->Name();

то по виду вызова метода невозможно определить, какая из трех приведенных выше реализаций Name будет выполнена. Все зависит от того, на какой конкретный объект указывает указатель ptr.

Item* ptr;
. . .
if (type == "Book")
     ptr = new Book;
else if (type == "Magazine")
     ptr = new Magazine;
. . .
String name = ptr->Name();

В данном фрагменте программы, если переменная type, обозначающая тип библиотечной единицы, была равна " Book ", то будет вызван метод Name класса Book. Если же она была равна " Magazine ", то будет вызван метод класса Magazine.

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

Приведем еще один пример виртуального метода. Предположим, в графическом редакторе при нажатии определенной клавиши нужно перерисовать текущую форму на экране. Форма может быть квадратом, кругом, эллипсом и т.д. Мы введем базовый класс для всех форм Shape. Конкретные фигуры, с которыми работает редактор, будут представлены классами Square (квадрат), Circle (круг), Ellipse (эллипс), производными от класса Shape. Класс Shape определяет виртуальный метод   Draw для отображения формы на экране.

class Shape
{
public:
     Shape();
     virtual void Draw(void);
};
//
// квадрат
//
class Square : public Shape
{
public:
     Square();
     virtual void Draw(void);
private:
     double length;   // длина стороны
};
//
// круг
//
class Circle : public Shape
{
public:
     Circle();
     virtual void Draw(void);
private:
     short radius;
};
. . .

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

Repaint(Shape* shape)
{
     shape->Draw();
}

Виртуальные методы и переопределение методов

Что бы изменилось, если бы метод Name не был описан как виртуальный? В таком случае решение о том, какой именно метод будет выполняться, принимается статически, во время компиляции программы. В примере с методом Name, поскольку мы работаем с указателем на базовый класс, был бы вызван метод Name класса Item. При определении метода как virtual решение о том, какой именно метод будет выполняться, принимается во время выполнения.

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

func(Item item)
{
     item.Name(); // вызывается метод Item::Name()
}
func1(Item& item)
{
     item.Name(); // вызывается метод в соответствии
                          // с типом того объекта, на который
                          // ссылается item
}

Преобразование базового и производного классов

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

Circle* pC;
. . .
Shape* pShape = pC;

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

Item* iPtr;
. . .
Book* bPtr = (Book*)iPtr;

небезопасно. Такое преобразование можно выполнять только тогда, когда точно известно, что iPtr указывает на объект класса Book.

Внутреннее и защищенное наследование

До сих пор мы использовали только внешнее наследование. Однако в языке Си++ имеется также внутреннее и защищенное наследование. Если перед именем базового класса ставится ключевое слово private, то наследование называется внутренним.

class B : private A
{
. . .
};

В случае внутреннего наследования внешняя и защищенная части базового класса становятся внутренней частью производного класса. Внутренняя часть базового класса остается для производного класса недоступной.

Если перед именем базового класса поставить ключевое слово protected, то будет использоваться защищенное наследование. При нем внешняя и защищенная части базового класса становятся защищенной частью производного класса. Внутренняя часть базового класса остается недоступной для производного класса.

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

Если в классе A был определен какой-то метод:

class A 
{
public:
     int foo();
};

то запись

B b;
b.foo();

недопустима, так же, как и наследуемый от B

class C
{
     int m() {
          foo();
     }
};

если класс B внутренне наследует A. Если же класс B использовал защищенное наследование, то первая запись b.foo() также была бы неправильной, но зато вторая была бы верна.