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

изменяется между вызовами std::bind и compressRateB, хранение w по ссылке будет отражать это изменение, в то время как сохранение по значению — нет.

Ответ заключается в том, что оно хранится по значению[20], но единственный способ узнать это — просто запомнить: в вызове std::bind нет никаких признаков этого. Сравните этот подход с лямбда-выражением, в котором захват w по значению или по ссылке выполняется явно:

auto compressRateL = // Захват w по значению;
 [w](CompLevel lev)  // lev передается по значению
 { return compress(w, lev); };

Не менее явно в лямбда-выражения передаются и параметры. Здесь очевидно, что параметр lev передается по значению. Таким образом,

compressRateL(CompLevel::High); // arg передается по значению

Но как аргумент передается в объект, получающийся с помощью std::bind?

compressRateB(CompLevel::High); // Как передается arg?

И вновь единственный способ знать, как работает std::bind, — это запомнить. (Ответ заключается в том, что все аргументы, передаваемые bind-объектам, передаются по ссылке, поскольку оператор вызова функции для таких объектов использует прямую передачу.)

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

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

• Полиморфные функциональные объекты. Поскольку оператор вызова функции bind-объекта использует прямую передачу, он может принимать аргументы любого типа (с учетом ограничений на прямую передачу, описанных в разделе 5.8). Это может быть полезным, когда вы хотите связать объект с шаблонным оператором вызова функции. Например, для класса

class PolyWidget {
public:
 template
 void operator()(const T& param);
 …
};

std::bind может связать PolyWidget следующим образом:

PolyWidget pw;

auto boundPW = std::bind(pw, _1);

После этого boundPW может быть вызван с разными типами аргументов:

boundPW(1930);      // Передача int в PolyWidget::operator()
boundPW(nullptr);   // Передача nullptr в PolyWidget::operator()
boundPW("Rosebud"); // Передача строкового литерала

Выполнить это с помощью лямбда-выражений С++11 невозможно. Однако в С++14 этого легко достичь с помощью лямбда-выражения с параметром auto:

auto boundPW = [pw](const auto& param) // С++14
               { pw(param); };

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

Когда bind был неофициально добавлен в С++ в 2005 году, это было существенным усовершенствованием по сравнению с его предшественником 1998 года. Однако добавление поддержки лямбда-выражений в C++11 привело к устареванию std::bind, а с момента появления С++14 для него, по сути, не осталось применений.

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

• Лямбда-выражения более удобочитаемы, более выразительны и могут быть более эффективными по сравнению с std::bind.

• Только в C++11 std::bind может пригодиться для реализации перемещающего захвата или для связывания объектов с шаблонными операторами вызова функции.

Глава 7 Параллельные вычисления

Одним из наибольших триумфов С++ 11 является включение параллелизма в язык программирования и библиотеку. Программисты, знакомые с другими потоковыми API (например, pthreads или Windows threads), иногда удивляются сравнительно спартанскому набору возможностей, предлагаемому С++, но это связано с тем, что по большей части поддержка параллельности в С++ имеет вид ограничений для разработчиков компиляторов. Получаемые в результате языковые гарантии означают, что впервые в истории С++ программисты могут писать многопоточные приложения со стандартным поведением на всех платформах. Это создает прочный фундамент, на котором могут быть построены выразительные библиотеки, а элементы параллелизма в стандартной библиотеке (задачи, фьючерсы, потоки, мьютексы, переменные условий, атомарные объекты и прочие) являются лишь началом того, что обязательно станет более богатым набором инструментов для разработки параллельного программного обеспечения на С++.

В последующих разделах нужно иметь в виду, что стандартная библиотека содержит два шаблона для фьючерсов: std::future и std::shared_future. Во многих случаях различия между ними не важны, так что я часто говорю просто о фьючерсах, подразумевая при этом обе разновидности.

7.1. Предпочитайте программирование на основе задач программированию на основе потоков

Если вы хотите выполнить функцию doAsyncWork асинхронно, у вас есть два основных варианта. Вы можете создать std::thread и запустить с его помощью doAsyncWork, тем самым прибегнув к подходу на основе потоков:

int doAsyncWork();