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

Что вы говорите? “Хватит трепа, переходи к делу”? Да хоть сию секунду! Вот почти корректная версия обновленной функции logAndAdd:

template
void logAndAdd(T&& name)
{
 logAndAddImpl(std::forward(name),
               std::is_integral()); // Не совсем корректно
}

Эта функция передает свой параметр в logAndAddImpl и при этом передает также аргумент, указывающий, является ли тип параметра (T) целочисленным. Как минимум это то, что она должна делать. То же самое она делает и для целочисленных аргументов, являющихся rvalue. Но, как поясняется в разделе 5.6, если lvalue-аргумент передается универсальной ссылке name, то выведенный тип для T будет lvalue-ссылкой. Так что если в функцию logAndAdd передается lvalue типа int, то тип T будет выведен как int&. Но это не целочисленный тип — ссылка таковым не является. Это означает, что std::is_integral будет иметь ложное значение для любого lvalue-аргумента, даже если этот аргумент на самом деле является целочисленным значением.

Понимание данной проблемы равносильно ее решению, поскольку в стандартной библиотеке имеется такое средство, как std::remove_reference (см. раздел 3.3), которое делает то, о чем говорит его имя и в чем мы так нуждаемся: удаляет любые квалификаторы ссылок из типа. Так что верный способ написания logAndAdd имеет следующий вид:

template
void logAndAdd(T&& name) {
 logAndAddImpl(
  std::forward(name), std::is_integral<
   typename std::remove_reference::type
  >()
 );
}

Это в определенной мере трюк. (Кстати, в С++14 можно сэкономить несколько нажатий клавиш, воспользовавшись вместо выделенного текста std::remove_reference_t. Подробнее об этом рассказывается в разделе 3.3.)

После принятия этих мер мы можем перенести наше внимание к вызываемой функции, logAndAddImpl. Имеются две перегрузки, первая из которых применима к любому нецелочисленному типу (т.e. ко всем типам, для которых значение std::is_integral::type> ложно):

// Нецелочисленный аргумент добавляется
// в глобальную структуру данных: template
void logAndAddImpl(T&& name, std::false_type) {
 auto now = std::chrono::system_clock::now();
 log(now, "logAndAdd");
 names.emplace(std::forward(name));
}

Этот код прост, если вы понимаете механику, лежащую в основе выделенного параметра. Концептуально logAndAdd передает в функцию logAndAddImpl булево значение, указывающее, передан ли функции logAndAdd целочисленный тип, но значения true и false являются значениями времени выполнения, а нам для выбора верной версии logAndAddImpl необходимо разрешение перегрузки, т.e. явление времени компиляции. Это означает, что нам нужен тип, соответствующий значению true, и другой тип, соответствующий значению false. Такая необходимость — настолько распространенное явление, что стандартная библиотека предоставляет то, что нам нужно, под именами std::true_type и std::false_type. Аргумент, передаваемый в logAndAddImpl функцией logAndAdd, является объектом типа, унаследованного от std::true_type, если T — целочисленный тип, и от std::false_type, если T таковым не является. Конечный результат заключается в том, что эта перегрузка logAndAddImpl является реальным кандидатом для вызова в logAndAdd, только если T не является целочисленным типом.

Вторая перегрузка охватывает противоположный случай, когда T представляет собой целочисленный тип. В этом случае logAndAddImpl просто ищет имя, соответствующее целочисленному индексу, и передает это имя функции logAndAdd:

std::string nameFromIdx(int idx); // Как в разделе 5.4

// Целочисленный аргумент: поиск имени и
// вызов с этим именем функции logAndAdd:
void logAndAddImpl(int idx,, std::true_type) {
 logAndAdd(nameFromIdx(idx));
}

Наличие функции logAndAddImpl для поиска по индексу соответствующего имени и передача его функции logAndAdd (откуда оно будет передано с помощью std::forward другой перегрузке функции logAndAddImpl) позволяет избежать размещения кода для записи в журнале в обеих перегрузках logAndAddImpl.

В таком решении типы std::true_type и std::false_type являются “дескрипторами”, единственная цель которых — обеспечить разрешение перегрузки требующимся нам способом. Обратите внимание, что нам даже не нужны эти параметры. Они не служат никакой цели во время выполнения, и мы фактически надеемся, что компиляторы распознают, что параметры дескрипторов не используются, и соответствующим образом оптимизируют выполнимый образ программы. (Некоторые компиляторы так и поступают, по крайней мере иногда.) Вызов перегруженных функций реализации в logAndAdd “диспетчеризует” передачу работы правильной перегрузке путем создания нужного объекта дескриптора. Отсюда и название этого метода проектирования: диспетчеризация дескрипторов. Это стандартный строительный блок шаблонного метапрограммирования, и чем больше вы будете просматривать код внутри современных библиотек С++, тем чаще вы будете с ним сталкиваться.

Для наших целей важно не столько то, как работает диспетчеризация дескрипторов, сколько как она позволяет комбинировать универсальные ссылки и перегрузку без проблем, описанных в разделе 5.4. Функция диспетчеризации —