Эффективный и современный С++. 42 рекомендации по использованию С++11 и С++14 - [35]

Следует запомнить

• Предпочитайте удаленные функции закрытым функциям без определений.

• Удаленной может быть любая функция, включая функции, не являющиеся членами, и инстанцирования шаблонов.

3.6. Объявляйте перекрывающие функции как >override

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

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

class Base {
public:
 virtual void doWork();     // Виртуальная функция
                            // базового класса
};

class Derived: public Base {
public:
 virtual void doWork();      // Перекрывает Base::doWork
                             // Ключевое слово virtual
};                           // здесь не обязательное

std::unique_ptr<Base> upb =  // Указатель на базовый класс
std::make_unique<Derived>(); // указывает на объект
                             // производного класса;
                             // см. std::make_unique
                             // в разделе 4.4

upb->doWork();               // Вызов doWork через указатель
                             // на базовый класс; вызывается
                             // функция производного класса

Для осуществления перекрытия требуется выполнение нескольких условий.

• Функция базового класса должна быть виртуальной.

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

• Типы параметров функций в базовом и производном классах должны быть одинаковыми.

• Константность функций в базовом и производном классах должна совпадать.

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

К этим ограничениям, являющимся частью С++98, С++11 добавляет еще одно.

• Ссылочные квалификаторы функций должны быть идентичными. Ссылочные квалификаторы функции-члена являются одной из менее известных возможностей С++11, так что не удивляйтесь, если вы до сих пор ничего о них не слышали. Они позволяют ограничить использование функции-члена только объектами lvalue или только объектами rvalue. Для использования этих квалификаторов функции-члены не обязаны быть виртуальными.

class Widget {
public:
 …
 void doWork() &;      // Эта версия doWork применима, только
                       // если *this представляет собой lvalue
 void doWork() &&;     // Эта версия doWork применима, только
};                     // если *this представляет собой rvalue

…
Widget makeWidget();   // Фабричная функция (возвращает rvalue)
Widget w;              // Обычный объект (lvalue)
…
w.doWork();            // Вызов Widget::doWork для lvalue
                       // (т.e. Widget::doWork &)
makeWidget().doWork(); // Вызов Widget::doWork для rvalue
                       // (т.e. Widget::doWork &&)

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

Все эти требования к перекрытию означают, что маленькие ошибки могут привести к большим последствиям. Код, содержащий ошибки перекрытия, обычно корректен, но делает совсем те то, что хотел программист. Поэтому в данном случае нельзя полагаться на уведомления компиляторов о том, что вы что-то делаете неверно. Например, приведенный далее код является абсолютно законным и, на первый взгляд, выглядит разумным, но в нем нет перекрытия виртуальной функции — нет ни одной функции производного класса, связанной с функцией базового класса. Сможете ли вы самостоятельно определить, в чем заключается проблема в каждом конкретном случае (т.e. почему каждая функция производного класса не переопределяет функцию базового класса с тем же именем)?

class Base {
public:
 virtual void mf1() const;
 virtual void mf2(int x);
 virtual void mf3() &;
 void mf4() const;
};

class Derived: public Base {
public:
 virtual void mf1();
 virtual void mf2(unsigned int x);
 virtual void mf3() &&;
 void mf4() const;
};

Нужна помощь?

• mf1 объявлена как const в классе Base, но в классе Derived этого модификатора нет.

• mf2 получает аргумент типа int в классе Base, но в классе Derived она получает аргумент типа unsigned int.

• mf3 определена с квалификатором lvalue в классе Base и с квалификатором rvalue в классе Derived.

• mf4 не объявлена в классе