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

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

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

К этим ограничениям, являющимся частью С++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не объявлена в классе Baseкак virtual.

Вы можете подумать “На практике все это вызовет предупреждения компилятора, так что мне не о чем беспокоиться”: Может быть, это и так. А может быть, и не так. В двух из проверенных мною компиляторах код был принят без единой жалобы — в режиме, когда все предупреждения были включены. (Другие компиляторы выдавали предупреждения о некоторых из проблем, но не обо всех одновременно.)

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

class Derived: public Base {

public:

virtual void mf1() override;

virtual void mf2(unsigned int x) override;

virtual void mf3() && override;

virtual void mf4() const override;

};

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

Код с использованием override, который будет успешно скомпилирован, выглядит следующим образом (в предположении, что нашей целью является перекрытие функциями в классе Derivedвсех виртуальных функций в классе Base):

class Base {

public:

virtual void mf1() const;

virtual void mf2(int x);

virtual void mf3() &

virtualvoid mf4() const;

};

class Derived: public Base {

public:

virtual void mf1() constoverride;

virtual void mf2( intx) override;

virtual void mf3() &override;

void mf4() const override; // Слово virtual не мешает, но

}; // и не является обязательным

Обратите внимание, что в этом примере часть работы состояла в том, чтобы объявить mf4в классе Baseкак виртуальную функцию. Большинство ошибок, связанных с перекрытием, совершаются в производном классе, но можно сделать такую ошибку и в базовом классе.

Стратегия использования ключевого слова overrideво всех перекрытиях производного класса способна на большее, чем просто позволить компиляторам сообщать, когда функции, которые должны быть перекрытиями, ничего не перекрывают. Они также могут помочь вам оценить последствия предполагаемого изменения сигнатуры виртуальной функции в базовом классе. Если производные классы везде используют override, вы можете просто изменить сигнатуру и перекомпилировать систему. Вы увидите, какие повреждения нанесли своей системе (т.e. сколько классов перестали компилироваться), и после этого сможете принять решение, стоит ли изменение сигнатуры таких хлопот. Без overrideвы должны были бы надеяться на наличие достаточно всеобъемлющих тестов, поскольку, как мы видели, виртуальные функции, которые предназначены перекрывать функции базового класса, но не делают этого, не приводят ни к какой диагностике со стороны компилятора.

В С++ всегда имелись ключевые слова, но С++11 вводит два контекстных ключевых слова (contextual keywords) — overrideи final [4] Применение ключевого слова final к виртуальной функции препятствует перекрытию этой функции в производном классе. Ключевое слово final также может быть применено к классу; в этом случае класс становится неприменимым в качестве базового. . Эти ключевые слова являются зарезервированными, но только в некоторых контекстах. В случае overrideоно имеет зарезервированное значение только тогда, когда находится в конце объявления функции-члена. Это значит, что если у вас есть старый код, который уже использовал имя override, его не надо изменять при переходе к С++11: