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

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

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

• Захват по умолчанию по ссылке может привести к висячим ссылкам.

• Захват по умолчанию по значению восприимчив к висячим указателям (особенно к this) и приводит к ошибочному предположению о самодостаточности лямбда-выражений.

6.2. Используйте инициализирующий захват для перемещения объектов в замыкания

Иногда ни захват по значению, ни захват по ссылке не является тем, что вы хотите. Если у вас имеется объект, который можно только перемещать (например, std::unique_ptr или std::future) и который вы хотите передать замыканию, С++11 не предлагает вам никакого способа для этого. Если у вас есть объект, который гораздо дешевле переместить, чем копировать (например, большинство контейнеров стандартной библиотеки), и вы хотели бы передать его в замыкание, то гораздо эффективнее переместить его, чем копировать. И вновь С++11 не предоставляет вам способа сделать это.

Но только C++11. С++14 — совершенно другая история. Он предлагает непосредственную поддержку перемещения объектов в замыкания. Если ваш компилятор соответствует стандарту С++14, радуйтесь и читайте дальше. Если же вы работаете с компиляторами С++11, вы тоже должны радоваться и читать дальше — потому что и в С++11 имеются способы приблизиться к перемещающему захвату.

Отсутствие перемещающего захвата было признано недостатком даже при принятии C++11. Казалось бы, простейшим путем было его добавление в С++14, но Комитет по стандартизации пошел иным путем. Он добавил новый механизм, который настолько гибкий, что захват путем перемещения является всего лишь одним из вариантов его работы. Новая возможность называется инициализирующим захватом (init capture). Он может делать почти все, что могут делать захваты в С++11, и еще многое. Единственное, что нельзя выразить с помощью инициализирующего захвата (и от чего, как поясняется

в разделе 6.1, вам надо держаться подальше), — это режим захвата по умолчанию. (Для ситуаций, охватываемых захватами С++11, инициализирующий захват несколько многословнее, так что там, где справляется захват С++11, совершенно разумно использовать именно его.)

Применение инициализирующего захвата делает возможным указать

1. имя члена-данных в классе замыкания, сгенерированном из лямбда-выражения, и

2. выражение инициализации этого члена-данных.

Вот как можно использовать инициализирующий захват для перемещения std::unique_ptr в замыкание:

class Widget{ // Некоторый полезный тип
public:
 …
 bool isValidated() const;
 bool isProcessed() const;
 bool isArchived() const;
private:
 …
};

auto pw =
 std::make_unique();     // Создание Widget;
                                 // std::make_unique
                                 // см. в разделе 4.4
…                                // Настройка *pw
auto func = [pw = std::move(pw)] // Инициализация члена
 { return pw->isValidated()      // в замыкании с помощью
       && pw->isArchived(); };   // std::move(pw)

Выделенный текст представляет собой инициализирующий захват. Слева от знака равенства = находится имя члена-данных в классе замыкания, который вы определяете, а справа — инициализирующее выражение. Интересно, что область видимости слева от “=” отличается от области видимости справа. Область видимости слева — это область видимости класса замыкания. Область видимости справа — та же, что и определяемого лямбда-выражения. В приведенном выше примере имя pw слева от = ссылается на члены-данные в классе замыкания, в то время как имя pw справа ссылается на объект, объявленный выше лямбда-выражения, т.e. на переменную, инициализированную вызовом std::make_unique. Так что “pw = std::move(pw)” означает “создать член-данные pw в замыкании и инициализировать этот член-данные результатом применения std::move к локальной переменной pw”.

Как обычно, код в теле лямбда-выражения находится в области видимости класса замыкания, так что использованные в нем pw относятся к члену-данным класса замыкания.

Комментарий “настройка *pw” в этом примере указывает, что после создания Widget с помощью std::make_unique и до того, как интеллектуальный указатель std::unique_ptr на этот Widget будет захвачен лямбда-выражением, Widget некоторым образом модифицируется. Если такая настройка не нужна, т.e. если объект Widget, созданный с помощью std::make_unique, находится в состоянии, пригодном для захвата лямбда-выражением, локальная переменная pw не нужна, поскольку член-данные класса замыкания может быть непосредственно инициализирован с помощью std::make_unique:

auto func = [pw = std::make_unique()] // Инициализация
 { return pw->isValidated () // члена-данных в замыкании
     && pw->isArchived(); }; // результатом вызова make_unique

Из этого должно быть ясно, что понятие захвата в С++ 14 значительно обобщено по сравнению с С++11, поскольку в С++11 невозможно захватить результат выражения. Поэтому еще одним названием инициализирующего захвата является