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

auto f = [](auto &&x)

{ return normalize( std::forward (x )); };

Однако между концепцией и реализацией стоит вопрос о том, какой тип передавать в std::forward, т.e. вопрос определения того, что должно находиться там, где я написал “ ???”.

Обычно, применяя прямую передачу, вы находитесь в шаблонной функции, принимающей параметр типа T, так что вам надо просто написать std::forward. В обобщенном лямбда-выражении такой параметр типа Tвам недоступен. Имеется Tв шаблонизированном операторе operator()в классе замыкания, сгенерированном лямбда-выражением, но сослаться на него из лямбда-выражения невозможно, так что это никак не помогает.

В разделе 5.6. поясняется, что если lvalue-apryмeнт передается параметру, являющемуся универсальной ссылкой, то типом этого параметра становится lvalue-ссылка. Если же передается rvalue, параметр становится rvalue-ссылкой. Это означает, что вне лямбда-выражения мы можем определить, является ли переданный аргумент lvalue или rvalue, рассматривая тип параметра x. Ключевое слово decltypeдает нам возможность сделать это (см. раздел 1.3). Если было передано lvalue, decltype(x)даст тип, являющийся lvalue-ссылкой. Если же было передано rvalue, decltype(x)даст тип, являющийся rvalue-ссылкой.

В разделе 5.6 поясняется также, что при вызове std::forwardсоглашения требуют, чтобы для указания lvalue аргументом типа была lvalue-ссылка, а для указания rvalue — тип, не являющийся ссылкой. В нашем лямбда-выражении, если x привязан к lvalue, decltype(x)даст lvalue-ссылку. Это отвечает соглашению. Однако, если xпривязан к rvalue, decltype(x)вместо типа, не являющегося ссылкой, даст rvalue-ссылку. Но взглянем на пример реализации std::forwardв С++14 из раздела 5.6:

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

T&& forward(remove_reference_t& param) // имен std

{

return static_cast(param);

}

Если клиентский код хочет выполнить прямую передачу rvalue типа Widget, он обычно инстанцирует std::forwardтипом Widget(т.e. типом, не являющимся ссылочным), и шаблон std::forwardдает следующую функцию:

Widget&& forward( Widget& param) // Инстанцирование для

{ // std::forward, когда

return static_cast< Widget&&>(param); // T является Widget

}

Но рассмотрим, что произойдет, если код клиента намерен выполнить прямую передачу того же самого rvalue типа Widget, но вместо следования соглашению об определении Tкак не ссылочного типа определит его как rvalue-ссылку, т.e. рассмотрим, что случится, если Tопределен как Widget&&. После начального инстанцирования std::forwardи применения std::remove_reference_t, но до свертывания ссылок (еще раз обратитесь к разделу 5.6) std::forwardбудет выглядеть следующим образом:

Widget&&&& forward( Widget&param) // Инстанцирование

{ // std::forward при

return static_cast< Widget&&&&>(param); // T, равном Widget&&

} // (до сворачивания ссылок)

Применение правила сворачивания ссылок о том, что rvalue-ссылка на rvalue-ссылку становится одинарной rvalue-ссылкой, приводит к следующему инстанцированию:

Widget&& forward(Widget& param) // Инстанцирование

{ // std::forward при

return static_cast(param); // T, равном Widget&&

} // (после сворачивания ссылок)

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

Это чудесная новость, так как decltype(x)дает rvalue-ссылку, когда в качестве аргумента для параметра x нашего лямбда-выражения передается rvalue. Выше мы установили, что, когда в наше лямбда-выражение передается lvalue, decltype(х)дает соответствующий соглашению тип для передачи в std::forward, и теперь мы понимаем, что для rvalue decltype(x)дает тип для передачи std::forward, который не соответствует соглашению, но тем не менее приводит к тому же результату, что и тип, соответствующий соглашению. Так что как для lvalue, так и для rvalue передача decltype(x) в std::forwardдает нам желаемый результат. Следовательно, наше лямбда-выражение с прямой передачей может быть записано следующим образом:

auto f = [](auto&& x)

{ return normalize(std::forward< decltype(x)>(x)); };

Чтобы это лямбда-выражение принимало любое количество параметров, нам, по сути, надо только шесть точек, поскольку лямбда-выражения в С++14 могут быть с переменным числом аргументов: