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

// T выводится как Widget&

Если мы возьмем тип, выведенный для T(т.e. Widget&) и используем его для инстанцирования шаблона, то получим следующее:

void func( Widget& &&param);

Ссылка на ссылку! Но компиляторы не возражают. Из раздела 5.2 мы знаем, что, поскольку универсальная ссылка param инициализируется с помощью lvalue, тип paramдолжен быть lvalue-ссылкой, но как компилятор получит результат взятия выведенного типа T и подстановки его в шаблон, который представляет собой конечную сигнатуру функции?

void func( Widget&param);

Ответ заключается в свертывании ссылок (reference collapsing). Да, вам запрещено объявлять ссылки на ссылки, но компиляторы могут создавать их в определенных контекстах, среди которых — инстанцирование шаблонов. Когда компиляторы генерируют ссылки на ссылки, свертывание ссылок определяет, что будет дальше.

Существуют два вида ссылок (lvalue и rvalue), так что имеются четыре возможные комбинации “ссылка на ссылку” (lvalue на lvalue, lvalue на rvalue, rvalue на lvalue и rvalue на rvalue). Если ссылка на ссылку возникает в контексте, где это разрешено (например, во время инстанцирования шаблона), то ссылки сворачиваются в единственную ссылку согласно следующему правилу:

Если любая из ссылок является lvalue-ссылкой, результат представляет собой lvalue-ссылку. В противном случае (т.e. когда обе ссылки являются rvalue-ссылками) результат представляет собой rvalue-ссылку.

В нашем приведенном выше примере подстановка выведенного типа Widget&в шаблон funcдает rvalue-ссылку на lvalue-ссылку, и правило свертки ссылок гласит, что результатом является lvalue-ccылкa.

Свертывание ссылок является ключевой частью механизма, обеспечивающего работу std::forward. Как пояснялось в разделе 5.3, std::forwardприменяется к параметрам, являющимся универсальными ссылками, так что обычно его применение имеет следующий вид:

template

void f(T&& fParam) {

… // Некоторая работа

someFunc( std::forward(fParam)); // Передача fParam в

} // someFunc

Поскольку fParamпредставляет собой универсальную ссылку, мы знаем, что параметр типа Tбудет кодировать информацию о том, являлся ли переданный fаргумент (т.e. выражение, использованное для инициализации fParam) lvalue или rvalue. Работа std::forwardзаключается в приведении fParam(lvalue) к rvalue тогда и только тогда, когда Tгласит, что переданный в fаргумент был rvalue, т.e. если Tне является ссылочным типом.

Вот как можно реализовать std::forward, чтобы он выполнял описанные действия:

template // В пространстве имен std

T&& forward(typename

remove_reference::type& param) {

return static_cast(param);

}

Этот код не совсем отвечает стандарту (я опустил несколько деталей интерфейса), но отличия не играют роли для понимания того, как ведет себя std::forward.

Предположим, что аргумент, переданный f, является lvalue типа Widget. Тип Tбудет выведен как Widget&, а вызов std::forwardинстанцирует std::forward. Подстановка Widget&в реализацию std::forwardдает следующее:

Widget&&& forward(typename

remove_reference< Widget&>::type& param)

{ return static_cast< Widget&&&>(param); }

Свойство типа std::remove_reference::typeдает Widget(см. раздел 3.3), так что std::forwardпревращается в

Widget& && forward( Widget& param)

{ return static_cast(param); }

К возвращаемому типу и приведению также применяется сворачивание ссылок, и результат представляет собой последнюю версию std::forwardдля вызова:

Widget&forward( Widget&param) // В пространстве

{ return static_cast< Widget&>(param); } // имен std

Как можно видеть, когда в шаблон функции fпередается аргумент lvalue, std::forwardинстанцируется для получения и возврата lvalue-ссылки. Приведение внутри std::forwardне делает ничего, поскольку тип paramуже представляет собой Widget&, так что приведение его к Widget&ни на что не влияет. Таким образом, lvalue-аргумент, переданный std::forward, вернет lvalue-ссылку. По определению lvalue-ссылки являются lvalue, так что передача lvalue в std::forwardприводит к возврату lvalue, как и предполагалось.

Предположим теперь, что передаваемый fаргумент является rvalue типа Widget. В этом случае выведенный тип параметра типа Tшаблона fбудет просто Widget. Вызов std::forwardвнутри f, таким образом, будет представлять собой std::forward. Подстановка Widgetвместо Tв реализации std::forwardдает следующее:

Widget&& forward(typename

remove_reference< Widget>::type& param)

{ return static_cast< Widget&&>(param); }

Применение std::remove_referenceк типу Widget, не являющемуся ссылкой, дает тот же тип, что и переданный ( Widget), так что std::forwardпревращается в

Widget&& forward( Widget& param)

{ return static_cast(param); }

Здесь нет ссылок на ссылки, так что нет и свертывания ссылок, и это последняя инстанцированная версия std::forwardдля этого вызова.

Так как rvalue-ссылки, возвращаемые из функции, определены как rvalue, в этом случае std::forwardпревратит параметр fParam(lvalue) функции fв rvalue. Конечным результатом является то, что rvalue-аргумент, переданный функции f, будет передан функции someFuncкак rvalue, и это именно то, что и должно было произойти.

Наличие в С++14 std::remove_reference_tделает возможным реализовать std::forwardнемного более лаконично:

template // С++14; в

T&& forward( remove_reference_t& param) // пространстве

{ // имен std

return static_cast(param);

}

Свертывание ссылок происходит в четырех контекстах. Первый и наиболее распространенный — инстанцирование шаблонов. Второй — генерация типов для переменных auto. Детали, по сути, те же, что и для шаблонов, поскольку вывод типа для auto-переменных, по сути, совпадает с выводом типов для шаблонов (см. раздел 1.2). Рассмотрим еще раз пример, приводившийся ранее в данном разделе:

template void func(T&& param);

Widget widgetFactory(); // Функция, возвращающая rvalue

Widget w; // Переменная (lvalue)

func(w); // Вызов функции с lvalue; тип T

// представляет собой Widget&

func(widgetFactory()); // Вызов функции с rvalue; тип T

// представляет собой Widget

Это можно имитировать в виде auto. Объявление

auto&&w1 = w;

инициализирует w1с помощью lvalue, выводя, таким образом, для autoтип Widget&. Подстановка Widget&вместо autoв объявление для w1дает код со ссылкой на ссылку

Widget& &&w1 = w;

который после сворачивания ссылок принимает вид

Widget&w1 = w;