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

auto func = [ pw = std::make_unique()] // Инициализация

{ return pw->isValidated () // члена-данных в замыкании

&& pw->isArchived(); }; // результатом вызова make_unique

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

Но что если один или несколько используемых вами компиляторов не поддерживают инициализирующий захват С++14? Как выполнить перемещающий захват в языке, в котором нет поддержки перемещающего захвата?

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

class IsValAndArch (

public:

using DataType = std::unique_ptr;

explicit IsValAndArch(DataType&& ptr) // Применение std::move

: pw(std::move(ptr)) {} // описано в разделе 5.3

bool operator()() const

{ return pw->isValidated() && pw->isArchived(); }

private:

DataType pw;

};

auto func = IsValAndArch(std::make_unique());

Это требует больше работы, чем написание лямбда-выражения, но это не меняет того факта, что если вам нужен класс C++11, поддерживающий перемещающую инициализацию своих членов-данных, то ваше желание отделено от вас лишь некоторым временем за клавиатурой.

Если вы хотите придерживаться лямбда-выражений (с учетом их удобства это, вероятно, так и есть), то перемещающий захват можно эмулировать в C++11 с помощью

1. перемещения захватываемого объекта в функциональный объект с помощью std::bind и

2. передачи лямбда-выражению ссылки на захватываемый объект.

Если вы знакомы с std::bind, код достаточно прост. Если нет, вам придется немного привыкнуть к нему, но игра стоит свеч.

Предположим, вы хотите создать локальный std::vector, разместить в нем соответствующее множество значений, а затем переместить его в замыкание. В С++ 14 это просто:

std::vector data; // Объект, перемещаемый

// в замыкание

… // Наполнение данными

auto func = [data = std::move(data)] // Инициализирующий захват

{ /* Использование данных */ };

Я выделил ключевые части этого кода: тип объекта, который вы хотите перемещать ( std::vector), имя этого объекта ( data) и выражение инициализации для инициализирующего захвата ( std::move(data)). Далее следует эквивалент этого кода на С++11, в котором я выделил те же ключевые части:

std::vector data; // Как и ранее

… // Как и ранее

auto func =

std::bind( // Эмуляция в С++ 11

[]( const std::vector& data) // инициализирующего

{ /* Использование данных */ }, // захвата

std::move(data)

);

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

Bind-объект содержит копии всех аргументов, переданных std::bind. Для каждого lvalue-аргумента соответствующий объект в bind-объекте создается копированием. Для каждого rvalue он создается перемещением. В данном примере второй аргумент представляет собой rvalue (как результат применения std::move; см. раздел 5.1), так что dataперемещается в bind-объект. Это перемещающее создание является сутью эмуляции перемещающего захвата, поскольку перемещение rvalue в bind-объект и есть обходной путь для перемещения rvalue в замыкание С++11.

Когда bind-объект “вызывается” (т.e. выполняется его оператор вызова функции), сохраненные им аргументы, первоначально переданные в std::bind, передаются в вызываемый объект. В данном примере это означает, что когда вызывается bind-объект func, лямбда-выражению, переданному в std::bind, в качестве аргумента передается созданная в funcперемещением копия data.

Это лямбда-выражение то же самое, что и использованное нами в C++14, за исключением добавленного параметра data. Этот параметр представляет собой lvalue-ссылку на копию dataв bind-объекте. (Это не rvalue-ссылка, поскольку, хотя выражение, использованное для инициализации копии data(“ std::move(data)”), является rvalue, сама по себе копия dataпредставляет собой lvalue.) Таким образом, применение dataвнутри лямбда-выражения будет работать с копией dataвнутри bind-объекта, созданной перемещением.

По умолчанию функция-член operator()в классе замыкания, сгенерированном из лямбда-выражения, является const. Это приводит к тому, что все члены-данные в замыкании в теле лямбда-выражения являются константными. Однако созданная перемещением копия dataвнутри bind-объекта не является константной, так что, чтобы предотвратить модификацию этой копии dataвнутри лямбда-выражения, параметр лямбда-выражения объявляется как указатель на const. Если лямбда-выражение было объявлено как mutable, operator()в его классе замыкания не будет объявлен как const, так что целесообразно опустить constв объявлении параметра лямбда-выражения:

auto func =

std::bind( // Эмуляция в C++11

[]( std::vector&data) mutable// инициализирующего

{ /* uses of data */ }, // захвата для лямбда-

std::move(data) // выражения, объяв-

); // ленного mutable

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

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

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

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

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