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

bool isLucky(int number); // Исходная функция

bool isLucky(char) = delete; // Отвергаем символы

bool isLucky(bool) = delete; // Отвергаем булевы значения

bool isLucky(double) = delete; // Отвергаем double и float

(Комментарий у перегрузки с double, который гласит, что отвергаются как double, так и float, может вас удивить, но ваше удивление исчезнет, как только вы вспомните, что при выборе между преобразованием floatв intи floatв doubleС++ предпочитает преобразование в double. Вызов isLuckyсо значением типа floatприведет к вызову перегрузки с типом double, а не int. Вернее, постарается привести. Тот факт, что данная перегрузка является удаленной, не позволит скомпилировать такой вызов.)

Хотя удаленные функции использовать нельзя, они являются частью вашей программы. Как таковые они принимаются во внимание при разрешении перегрузки. Вот почему при указанных выше объявлениях нежелательные вызовы isLuckyбудут отклонены:

if (isLucky('a')) … // Ошибка! Вызов удаленной функции

if (isLucky(true)) … // Ошибка!

if (isLucky(3.5f)) … // Ошибка!

Еще один трюк, который могут выполнять удаленные функции (а функции-члены, объявленные как private— нет), заключается в предотвращении использования инстанцирований шаблонов, которые должны быть запрещены. Предположим, например, что нам нужен шаблон, который работает со встроенными указателями (несмотря на совет из главы 4, “Интеллектуальные указатели”, предпочитать интеллектуальные указатели встроенным):

template

void processPointer(T* ptr);

В мире указателей есть два особых случая. Один из них — указатели void*, поскольку их нельзя разыменовывать, увеличивать или уменьшать и т.д. Второй — указатели char*, поскольку они обычно представляют указатели на C-строки, а не на отдельные символы. Эти особые случаи часто требуют особой обработки; будем считать, что в случае шаблона processPointerэта особая обработка заключается в том, чтобы отвергнуть вызовы с такими типами (т.e. должно быть невозможно вызвать processPointerс указателями типа void*или char*).

Это легко сделать. Достаточно удалить эти инстанцирования:

template<>

void processPointer(void*) = delete;

template<>

void processPointer(char*) = delete;

Теперь, если вызов processPointerс указателями void*или char*является некорректным, вероятно, таковым же является и вызов с указателями const void*или const char*, так что эти инстанцирования обычно также следует удалить:

template<>

void processPointer(const void*) = delete;

template<>

void processPointer(const char*) = delete;

И если вы действительно хотите быть последовательными, то вы также удалите перегрузки const volatile void*и const volatile char*, а затем приступите к работе над перегрузками для указателей на другие стандартные типы символов: wchar_t, char16_tи char32_t.

Интересно, что если у вас есть шаблон функции внутри класса и вы попытаетесь отключить некоторые инстанцирования, объявляя их private(в духе классического соглашения С++98), то у вас ничего не получится, потому что невозможно дать специализации шаблона функции-члена другой уровень доступа, отличный от доступа в главном шаблоне. Например, если processPointerпредставляет собой шаблон функции-члена в Widgetи вы хотите отключить вызовы для указателей void*, то вот как будет выглядеть (не компилируемый) подход С++98:

class Widget {

public:

…

template

void processPointer(T* ptr)

{ … }

private:

template<> // Ошибка!

void processPointer(void*);

};

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

class Widget {

public:

…

template

void processPointer(T* ptr) { … }

};

template<> // Все еще public, но удаленная

void Widget::processPointer(void*) = delete;

Истина заключается в том, что практика С++98 объявления функций privateбез их определения в действительности была попыткой добиться того, для чего на самом деле созданы удаленные функции С++11. Будучи всего лишь имитацией, подход С++98 работает не так хорошо, как вещь, которую он имитирует. Он не работает вне классов, не всегда работает внутри классов, а когда работает, то может не работать до компоновки. Так что лучше придерживаться удаленных функций.

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

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

Мир объектно-ориентированного программирования С++ вращается вокруг классов, наследования и виртуальных функций. Среди наиболее фундаментальных идей этого мира — та, что реализации виртуальных функций в производных классах перекрывают (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 через указатель

// на базовый класс; вызывается

// функция производного класса

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

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

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

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