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

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

Прямая передача означает, что мы передаем не просто объекты, но и их основные характеристики: их типы, являются они 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. В этом случае код не компилируется.

• Компиляторы выводят “неверный” типодного или нескольких параметров fwd. Здесь “неверный” может означать как то, что инстанцирование fwdне компилируется с выведенными типами, так и то, что вызов fс использованием выведенных типов fwdведет себя не так, как непосредственный вызов fс аргументами, переданными в fwd. Одним источником такого отклонения в поведении могла бы быть ситуация, когда у fимеется перегрузка, и из-за “некорректного” вывода типов эта перегрузка f, вызываемая в fwd, отличалась бы от перегруженной функции f, используемой при непосредственном вызове.

В приведенном выше вызове “ fwd({1,2,3})” проблема заключается в том, что передача инициализатора в фигурных скобках параметру шаблона функции, не объявленному как std::initializer_list, заставляет его быть, как предписывает стандарт, “не выводимым контекстом”. На простом человеческом языке это означает, что компиляторам запрещено выводить тип для выражения {1,2,3}в вызове fwd, поскольку параметр fwdне объявлен как std::initializer_list. Не имея возможности вывести тип параметра fwd, компиляторы, понятно, вынуждены отклонять такой вызов.

Интересно, что в разделе 1.2 поясняется, что вывод типа для переменных auto, инициализированных с помощью инициализатора в фигурных скобках, успешен. Такие переменные считаются объектами типа std::initializer_list, и это обеспечивает простой обходной путь для случаев, когда тип передающей функции должен быть выведен как std::initializer_list :объявить локальную переменную как auto, а затем передать ее в передающую функцию:

auto il = { 1, 2, 3 }; // Тип il выводится как

// std::initializer_list

fwd(il); // OK, прямая передача il в f

В разделе 3.2 поясняется, что, когда вы пытаетесь передать в шаблон 0или NULLв качестве нулевого указателя, вывод типа для переданного аргумента дает вместо типа указателя целочисленный тип (обычно int). В результате ни 0, ни NULLне может быть передано с помощью прямой передачи как нулевой указатель. Решение проблемы простое: передавать nullptrвместо 0и NULL. Детальную информацию вы можете найти в разделе 3.2.