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

};

Если ваша реакция на код “std::forward” внутри лямбда-выражения — “Что за @#$%?!!”, то, вероятно, вы просто еще не читали раздел 6.3. Не беспокойтесь о нем. Главное для нас сейчас в этом лямбда-выражении — объявленные как auto&& параметры. func является универсальной ссылкой, которая может быть связана с любым вызываемым объектом, как lvalue, так и rvalue. params представляет собой нуль или несколько универсальных ссылок (т.e. набор параметров, являющихся универсальными ссылками), которые могут быть связаны с любым количеством объектов произвольных типов. В результате, благодаря универсальным ссылкам auto, лямбда-выражение timeFuncInvocation в состоянии записать время работы почти любого выполнения функции. (Чтобы разобраться в разнице между “любого” и “почти любого”, обратитесь к разделу 5.8.)

Имейте в виду, что весь этот раздел — основы универсальных ссылок — является лож… простите, абстракцией. Лежащая в основе истина, известная как свертывание ссылок (reference collapsing), является темой раздела 5.6. Но истина не делает абстракцию менее полезной. Понимание различий между rvalue-ссылками и универсальными ссылками поможет вам читать исходные тексты более точно (“Этот T&& связывается только с rvalue или с чем угодно?”), а также избегать неоднозначностей при общении с коллегами (“Здесь я использовал универсальную ссылку, а не rvalue-ссылку…”). Оно также поможет вам в понимании смысла разделов 5.3 и 5.4, которые опираются на указанное различие. Так что примите эту абстракцию, погрузитесь в нее… Так же как законы Ньютона (технически не совсем корректные) обычно куда полезнее и проще общей теории относительности Эйнштейна (“истины”), так и понятие универсальных ссылок обычно предпочтительнее для работы, чем детальная информация о свертывании ссылок.

Следует запомнить

• Если параметр шаблона функции имеет тип T&& для выводимого типа T или если объект объявлен с использованием auto&&, то параметр или объект является универсальной ссылкой.

• Если вид объявления типа не является в точности type&& или если вывод типа не имеет места, то type&& означает rvalue-ссылку.

• Универсальные ссылки соответствуют rvalue-ссылкам, если они инициализируются значениями rvalue. Они соответствуют lvalue-ссылкам, если они инициализируются значениями lvalue.

5.3. Используйте >std::move для rvalue-ссылок, а >std::forward — для универсальных ссылок

Rvalue-ссылки связываются только с объектами, являющимися кандидатами для перемещения. Если у вас есть параметр, представляющий собой rvalue-ссылку, вы знаете, что связанный с ним объект может быть перемещен:

class Widget {
 Widget(Widget&& rhs); // rhs, определенно, ссылается на
 …                     // объект, который можно перемещать
};

В этом случае вы захотите передавать подобные объекты другим функциям таким образом, чтобы разрешить им использовать преимущества “правосторонности”. Способ, которым это можно сделать, — привести параметры, связываемые с такими объектами, к rvalue. Как поясняется в разделе 5.1, std::move не просто это делает, это та задача, для которой создана эта функция:

class Widget {
public:
 Widget(Widget&& rhs) // rhs является rvalue-ссылкой
 : name(std::move(rhs.name)),
 p(std::move(rhs.p))
 { … }
 …
private:
 std::string name;
 std::shared_ptr p;
};

С другой стороны, универсальная ссылка (см. раздел 5.2) может быть связана с объектом, который разрешено перемещать. Универсальные ссылки должны быть приведены к rvalue только тогда, когда они были инициализированы с помощью rvalue. В разделе 5.1 разъясняется, что именно это и делает функция std::forward:

class Widget f
public:
 template
 void setName(T&& newName)           // newName является
 { name = std::forward(newName);} // универсальной ссылкой
};

Короче говоря, rvalue-ссылки при их передаче в другие функции должны быть безусловно приведены к rvalue (с помощью std::move), так как они всегда связываются с rvalue, а универсальные ссылки должны приводиться к rvalue при их передаче условно (с помощью std::forward), поскольку они только иногда связываются с rvalue.

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

class Widget {
public:
 template
 void setName(T&& newName)      // Универсальная ссылка.
 { name = std::move(newName); } // Компилируется, но это
 …                              // очень плохое решение!
private:
 std::string name;
 std::shared_ptr p;
};

std::string getWidgetName(); // Фабричная функция
Widget w;
auto n = getWidgetName();    // n - локальная переменная
w.setName(n);                // Перемещение n в w!
                             // Значение n теперь неизвестно

Здесь локальная переменная