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

как 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() &;
 virtual void mf4() const;
};

class Derived: public Base {
public:
 virtual void mf1() const override;
 virtual void mf2(int x) override;
 virtual void mf3() & override;
 void mf4() const override; // Слово virtual не мешает, но
};                          // и не является обязательным

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

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

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

class Warning {   // Потенциально старый класс из С++98
public:
 …
 void override(); // Корректно как в С++98, так и в C++11
                  // (с тем же смыслом)
};

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

Если мы хотим написать функцию, которая принимает только аргументы, являющиеся lvalue, мы объявляем параметр, который представляет собой неконстантную lvalue-ссылку:

void doSomething(Widget& w); // Принимает только lvalue Widget

Если же мы хотим написать функцию, которая принимает только аргументы, являющиеся rvalue, мы объявляем параметр, который представляет собой rvalue-ссылку:

void doSomething(Widget&& w); // Принимает только rvalue Widget

Ссылочные квалификаторы функции-члена позволяют проводить такое же различие для объектов, функции-члены которых вызываются, т.e. *this. Это точный аналог модификатора const в конце объявления функции-члена, который указывает, что объект, для которого вызывается данная функция-член (т.e. *this), является const.

Необходимость в функциях-членах со ссылочными квалификаторами нужна не так уж часто, но может и возникнуть. Предположим, например, что наш класс Widget имеет член-данные std::vector, и мы предлагаем функцию доступа, которая обеспечивает клиентам к нему непосредственный доступ:

class Widget {
public:
 using DataType = std::vector; // См. информацию о
                                       // using в разделе 3.3