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

5.8. Познакомьтесь с случаями некорректной работы прямой передачи

Одной из ярких звезд на небосклоне C++11 является прямая передача (perfect forwarding). Можно сказать, идеально прямая. Но, как говорит наука, даже пространство искривляется, так что есть идеальная прямота, а есть реальная. Прямая передача С++11 очень хороша, но достигает истинного совершенства, только если вы готовы игнорировать небольшие искривления. В данном разделе вы познакомитесь с этими маленькими искривлениями.

Перед тем как перейти к их изучению, стоит посмотреть, что мы подразумеваем под “прямой передачей”. Под передачей подразумевается, что одна функция передает своим параметры другой функции. Цель этого действия заключается в том, чтобы одна функция (которой передаются параметры) получила в точности те же объекты, которые переданы другой функции (которая выполняет передачу). Тем самым исключается передача параметров по значению, поскольку при этом выполняется копирование исходно переданных объектов; мы же хотим, чтобы передающая функция была способна работать с изначально переданными объектами. Указатели также исключаются, поскольку мы не хотим заставлять вызывающий код передавать указатели. Когда речь идет о передаче общего назначения, мы работаем с параметрами, представляющими собой ссылки.

Прямая передача означает, что мы передаем не просто объекты, но и их основные характеристики: их типы, являются они lvalue или rvalue, объявлены они как const или volatile. В сочетании с наблюдением о том, что мы будем иметь дело со ссылочными параметрами, это означает, что мы будем использовать универсальные ссылки (см. раздел 5.2), поскольку только параметры, являющиеся универсальными ссылками, хранят информацию о том, какие аргументы — являющиеся lvalue или rvalue — были им переданы.

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

template
void fwd(T&& param)         // Принимает любой аргумент
{
 f(std::forward(param)); // Передача аргумента в f
}

Передающие функции по своей природе являются обобщенными. Шаблон fwd, например, принимает аргумент любого типа, и он передает все, что бы ни получил. Логическим продолжением этой обобщенности являются передающие функции, являющиеся не просто шаблонами, а шаблонами с произвольным количеством аргументов (вариативными шаблонами (variadic templates)). Вариативная разновидность fwd выглядит следующим образом:

template
void fwd(Ts&&... params)         // Принимает любые аргументы
{
 f(std::forward(params)...); // Передача аргументов в f
}

Эту разновидность вы встретите, помимо прочих мест, в функциях размещения стандартных контейнеров (см. раздел 8.2) и в фабричных функциях для интеллектуальных указателей, std::make_shared и std::make_unique (см. раздел 4.4).

Для заданной целевой функции f и нашей передающей функции fwd прямая передача завершается неудачей, если вызов функции f с конкретным аргументом выполняет нечто одно, а вызов fwd с теми же аргументами — нечто иное:

f( expression );   // Если этот вызов выполняет что-то одно,
fwd( expression ); // а этот - нечто иное, прямая передача
                   // функцией fwd функции f неудачна

К такой неудаче могут привести несколько видов аргументов. Знать эти аргументы и то, как с ними работать, весьма важно, так что начнем наш тур по аргументам, которые не могут быть переданы с помощью прямой передачи.

Инициализаторы в фигурных скобках

Предположим, что f объявлена следующим образом:

void f(const std::vector& v);

В этом случае вызов f с инициализаторами в фигурных скобках компилируется:

f({ 1, 2, 3 }); // OK, "{1, 2, 3}" неявно преобразуется
                // в std::vector

Однако передача того же инициализатора в фигурных скобках функции fwd не компилируется:

fwd({ 1, 2, 3 }); // Ошибка! Код не компилируется!

Дело в том, что применение инициализаторов в фигурных скобках — один из случаев, когда прямая передача терпит неудачу.

Все такие случаи отказов имеют одну и ту же причину. В непосредственном вызове f (таком, как f({1,2,3})) компиляторы видят аргументы, переданные в точке вызова, и видят типы параметров, объявленные функцией f. Они сравнивают аргументы в точке вызова с объявлениями параметров на предмет совместимости и при необходимости выполняют неявное преобразование, чтобы вызов был успешным. В приведенном выше примере они генерируют временный объект типа std::vector из {1,2,3}, так что к параметру v функции f привязывается объект типа std::vector.

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

• Компиляторы неспособны вывести тип одного или нескольких параметров fwd