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

  { /* uses of data */ },               // захвата для лямбда-
  std::move(data)                       // выражения, объяв-
 );                                     // ленного mutable

Поскольку bind-объект хранит копии всех аргументов, переданных std::bind, bind-объект в нашем примере содержит копию замыкания, произведенного из лямбда-выражения, являющегося первым аргументом этого объекта. Следовательно, время жизни замыкания совпадает со временем жизни bind-объекта. Это важно, поскольку это означает, что, пока существует замыкание, существует и bind-объект, содержащий объект, захваченный псевдоперемещением.

Если вы впервые столкнулись с std::bind, вам может понадобиться учебник или справочник по C++11, чтобы все детали этого обсуждения встали на свои места в вашей голове. Вот основные моменты, которые должны быть понятными.

• Невозможно выполнить перемещение объекта в замыкание С++11, но можно выполнить перемещение объекта в bind-объект С++11.

• Эмуляция захвата перемещением в С++11 состоит в перемещении объекта в bind-объект с последующей передачей перемещенного объекта в лямбда-выражение по ссылке.

• Поскольку время жизни bind-объекта совпадает с таковым для замыкания, можно рассматривать объекты в bind-объекте так, как будто они находятся в замыкании.

В качестве второго примера применения std::bind для эмуляции перемещающего захвата рассмотрим пример кода С++ 14, который мы видели ранее и который создает std::unique_ptr в замыкании:

auto func = [pw = std::make_unique()] // Как и ранее,
 { return pw->isValidated()                   // создает pw
       && pw->isArchived(); };                // в замыкании

А вот как выглядит его эмуляция на С++11:

auto func = std::bind(
 [](const std::unique_ptr& pw)
 { return pw->isValidated()
       && pw->isArchived(); },
 std::make_unique()
);

Забавно, что я показываю, как использовать std::bind для обхода ограничений лямбда-выражений в С++11, поскольку в разделе 6.4 я выступаю как сторонник применения лямбда-выражений вместо std::bind. Однако в данном разделе поясняется, что в С++11 имеются ситуации, когда может пригодиться std::bind, и это одна из них. (В С++14 такие возможности, как инициализирующий захват и параметры auto, устраняют такие ситуации.)

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

• Для перемещения объектов в замыкания используется инициализирующий захват С++14.

• В С++11 инициализирующий захват эмулируется с помощью написания классов вручную или применения std::bind.

6.3. Используйте параметры >decltype для >auto&& для передачи с помощью >std::forward

Одной из самых интересных возможностей С++14 являются обобщенные лямбда-выражения — лямбда-выражения, в спецификации параметров которых используется ключевое слово auto. Реализация этой возможности проста: operator() в классе замыкания лямбда-выражения является шаблоном. Например, для лямбда-выражения

auto f = [](auto x){ return normalize(x); };

оператор вызова функции класса замыкания имеет следующий вид:

class SomeCompilerGeneratedClassName {
public:
 template       // См. возвращаемый тип auto
 auto operator()(T х) const // в разделе 1.3
 { return normalize(x); }
 …                          // Прочая функциональность
};                          // класса замыкания

В этом примере единственное, что делает лямбда-выражение с параметром x, — это передает его функции normalize. Если normalize рассматривает значения lvalue не так, как значения rvalue, это лямбда-выражение написано некорректно, поскольку оно всегда передает функции normalize lvalue (параметр x), даже если переданный в лямбда-выражение аргумент представляет собой rvalue.

Корректным способом написания лямбда-выражения является прямая передача x в normalize. Это требует внесения в код двух изменений. Во-первых, x должен быть универсальной ссылкой (см. раздел 5.2), а во-вторых, он должен передаваться в normalize с использованием std::forward (см. раздел 5.3). Концептуально это требует тривиальных изменений:

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,