Стенли Липпман - Язык программирования C++. Пятое издание

struct Base {

int memfcn();

};

struct Derived : Base {

int memfcn(int); // скрывает memfcn() в базовом классе

};

Derived d; Base b;

b.memfcn(); // вызов Base::memfcn()

d.memfcn(10); // вызов Derived::memfcn()

d.memfcn(); // ошибка: memfcn() без аргументов скрывается

d.Base::memfcn(); // ok: вызов Base::memfcn()

Объявление функции memfcn()в классе Derivedскрывает объявление функции memfcn()в классе Base. Не удивительно, что первый вызов через объект bкласса Baseвызывает версию в базовом классе. Точно так же второй вызов (через объект d) вызывает версию класса Derived. Удивительно то, что третий вызов, d.memfcn(), некорректен.

Чтобы распознать этот вызов, компилятор ищет имя memfcnв классе Derived. Этот класс определяет член по имени memfcn, и поиск на этом останавливается. Как только имя будет найдено, компилятор далее не ищет. Версия функции memfcn()в классе Derivedожидает аргумент типа int. Поскольку данный вызов такого аргумента не предоставляет, вызов ошибочен.

Виртуальные функции и область видимости

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

class Base {

public:

virtual int fcn();

};

class D1 : public Base {

public:

// скрывает fcn() в базовом; функция fcn() не виртуальна

// D1 наследует определение из Base::fcn()

int fcn(int); // список параметров fcn() в Base другой

virtual void f2(); // новая виртуальная функция,

// не существующая в Base

};

class D2 : public D1 {

public:

int fcn(int); // невиртуальная функция скрывает D1::fcn(int)

int fcn(); // переопределяет виртуальную функцию fcn() из Base

void f2(); // переопределяет виртуальную функцию f2() из D1

};

Функция fcn()в классе D1не переопределяет виртуальную функцию fcn()из класса Base, поскольку у них разные списки параметров. Вместо этого она скрывает функцию fcn()из базового класса. Фактически у класса D1есть две функции по имени fcn(): класс D1унаследовал виртуальную функцию fcn()от класса Base, а также определяет собственную невиртуальную функцию-член по имени fcn(), получающую параметр типа int.

С учетом классов, описанных выше, рассмотрим несколько разных способов вызова этих функций:

Base bobj; D1 d1obj; D2 d2obj;

Base *bp1 = &bobj, *bp2 = &d1obj, *bp3 = &d2obj;

bp1->fcn(); // виртуальный вызов Base::fcn() во время выполнения

bp2->fcn(); // виртуальный вызов Base::fcn() во время выполнения

bp3->fcn(); // виртуальный вызов D2::fcn() во время выполнения

D1 *d1p = &d1obj; D2 *d2p = &d2obj;

bp2->f2(); // ошибка: Base не имеет члена по имени f2()

d1p->f2(); // виртуальный вызов D1::f2() во время выполнения

d2p->f2(); // виртуальный вызов D2::f2() во время выполнения

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

Это решение будет принято на основании фактического типа объекта, с которым связан указатель. В случае указателя bp2основной объект имеет тип D1. Этот класс не переопределит функцию fcn()без параметров. Таким образом, вызов через указатель bp2распознается (во время выполнения) как версия, определенная в классе Base.

Следующие три вызова осуществляются через указатели с отличными типами. Каждый указатель указывает на один из типов в этой иерархии. Первый вызов некорректен, так как в классе Baseнет функции f2(). Тот факт, что указатель случайно указывает на производный объект, является несущественным.

И наконец, рассмотрим вызовы невиртуальной функции fcn(int):

Base *p1 = &d2obj; D1 *p2 = &d2obj; D2 *p3 = &d2obj;

p1->fcn(42); // ошибка: Base не имеет версии fcn(), получающей int

p2->fcn(42); // статическое связывание, вызов D1::fcn(int)

p3->fcn(42); // статическое связывание, вызов D2::fcn(int)

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

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

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

Вместо переопределения каждой версии базового класса, которую он унаследовал, производный класс может предоставить объявление using(см. раздел 15.5) для перегруженного члена. Объявление usingопределяет только имя; оно не может определить список параметров. Таким образом, объявление usingдля функции-члена базового класса добавляет все перегруженные экземпляры этой функции в область видимости производного класса. Перенеся все имена в свою область видимости, производный класс должен определить только те функции, которые действительно зависят от его типа.

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

Упражнение 15.23. Предположим, что класс D1намеревается переопределить свою унаследованную функцию fcn(). Как исправить этот класс? Предположим, что класс исправлен так, что функция fcn()соответствует определению в классе Base. Как бы распознавались вызовы в этом разделе?