Item 34: Prefer lambdas to std::bind.

Effective Modern C++ Item 34 的学习和解读。

C++11 的 std::bind 是对 C++98 std:bind1st 和 std::bind2nd 的继承，它在 2005 年以 TR1 文档形式非正式地成为标准库的一部分。因为，许多 C++ 程序员可能有十几年的 std::bind 使用经验，现在告诉他放弃使用 std::bind，多少可能有些不情愿。但是，本 Item 会告诉你使用 lambda 替代 std::bind 将是个更好的选择。

对于 C++11，除了个别边缘 case，lambda 表达式要比 std::bind 更有优势。而对于 C++14，lambda 则可以完全替代 std::bind。

lambda 第一个优势是代码的可读性更强。例如，我们有一个设置声音报警的函数：

// typedef for a point in time (see Item 9 for syntax)
using Time = std::chrono::steady_clock::time_point;
// see Item 10 for "enum class"
enum class Sound { Beep, Siren, Whistle };
// typedef for a length of time
using Duration = std::chrono::steady_clock::duration;
// at time t, make sound s for duration d
void setAlarm(Time t, Sound s, Duration d);

如果我们想在设置声音报警后 1h，关闭报警，并持续 30s。使用 lambda 表达式修正 setAlarm，可以实现如下：

// setSoundL ("L" for "lambda") is a function object allowing a
// sound to be specified for a 30-sec alarm to go off an hour
// after it's set
auto setSoundL =
  [](Sound s)
  {
    // make std::chrono components available w/o qualification
    using namespace std::chrono;
    setAlarm(steady_clock::now() + hours(1), // alarm to go off
             s, // in an hour for
             seconds(30)); // 30 seconds
  };

上述代码逻辑非常清楚。如果使用 C++14 字面值 std::literals 改写上面代码，可以更加简洁：

auto setSoundL =
  [](Sound s)
  {
    using namespace std::chrono;
    using namespace std::literals; // for C++14 suffixes
    setAlarm(steady_clock::now() + 1h, // C++14, but
             s, // same meaning
             30s); // as above
  };

如果使用 std::bind 直接替换 lambda 表达式，可以改写成如下：

using namespace std::chrono; // as above
using namespace std::literals;
using namespace std::placeholders; // needed for use of "_1"
auto setSoundB = // "B" for "bind"
  std::bind(setAlarm,
            steady_clock::now() + 1h, // incorrect! see below
            _1,
            30s);

首先，相较于 lambda 版本，使用 std::bind，函数调用和传参不那么明显。并且这里还有一个占位符 “_1”，使用 setSoundB 时候，你需要查阅 setAlarm 的函数申明，才知道这里的占位符的传参类型。

最重要的是这里的代码逻辑有问题。显然，我们期望的是在调用 setAlarm 时候计算表达式 steady_clock::now() + 1h 的值。但是，使用 std::bind 的时候，表达式 steady_clock::now() + 1h 是传递给 std::bind 而不是 setAlarm，这意味着，在调用 std::bind 的时候，表达式的值就被计算出来，然后保存在绑定对象内部。这就导致和在调用 setAlarm 时候计算表达式的期望不一致。可以再使用一个 std::bind 封装该表达式以延迟到 setAlarm 调用的时候才计算：

auto setSoundB =
  std::bind(setAlarm,
            std::bind(std::plus<>(), steady_clock::now(), 1h),  // C++14
            _1,
            30s);

注意到 std::plus<> 缺省了类型参数，这是 C++14 的新特性，如果是 C++11，则需要指定类型：

auto setSoundB =
  std::bind(setAlarm,
            std::bind(std::plus<steady_clock::time_point>(), // C++11
                      steady_clock::now(),
                      hours(1)),
            _1,
            seconds(30));

如果 setAlarm 增加一个重载版本：

enum class Volume { Normal, Loud, LoudPlusPlus };
void setAlarm(Time t, Sound s, Duration d, Volume v);

先前 lambda 版本代码依然可以正常工作。但是，std::bind 将会产生编译报错。因为编译器无法确认传递哪个版本的 setAlarm。需要将 setAlarm 转换为合适的函数指针：

using SetAlarm3ParamType = void(*)(Time t, Sound s, Duration d);
auto setSoundB =                                        // now
  std::bind(static_cast<SetAlarm3ParamType>(setAlarm),  // okay
            std::bind(std::plus<>(),
                      steady_clock::now(),
                      1h),
            _1,
            30s);

但是，这又引入了 std::bind 和 lambda 二者的不同。setSoundL 使用正常的函数调用来调用 setAlarm，编译器可以选择使用内联。

setSoundL(Sound::Siren); // body of setAlarm may
                         // well be inlined here

但是 std::bind 不可以，setSoundB 使用函数指针调用调用 setAlarm，这是运行期的行为，无法被内联。

setSoundB(Sound::Siren); // body of setAlarm is less
                         // likely to be inlined here

这就是使用 lambda 的第二个优势：代码的性能可能会更好。

使用 lambda 的第三个优势是代码更容易理解。看下面的例子：

enum class CompLevel { Low, Normal, High }; // compression level
Widget compress(const Widget& w, // make compressed
                CompLevel lev);  // copy of w

假设我们想创建一个函数对象，用来指定特定 Widget 的压缩等级。使用 std::bind 创建函数对象：

Widget w;
using namespace std::placeholders;
auto compressRateB = std::bind(compress, w, _1);

传递 w 给 std::bind，那么 w 如何存放在 compressRateB 内部的呢？是传值还是传引用？如果 w 在调用 std::bind 和 compressRateB 之间发生改变，传引用的方式将导致结果的不同。

std::bind 默认是拷贝它的参数到绑定对象内，用户可以使用 std::ref 指定传引用：

auto compressRateB = std::bind(compress, std::ref(w), _1);

这就需要你了解 std::bind 实现机制。但对于 lambda 的实现版本，w 是值捕获还是引用捕获非常明显：

auto compressRateL =            // w is captured by
  [w](CompLevel lev)            // value; lev is
  { return compress(w, lev); }; // passed by value

同样明显的是参数如何传递给 lambda 的。这里，很明显 lev 是值传递：

compressRateL(CompLevel::High); // arg is passed
                                // by value

但是，std::bind 的绑定对象的调用，参数是如何传递的？

compressRateB(CompLevel::High); // how is arg
                                // passed?

答案是引用传递，这就需要你了解 std::bind 的工作机制：std::bind 绑定对象的函数调用使用了完美转发机制。

通过上述比较我们可以看到，相较于使用 std::bind，使用 lambda 表达式的代码可读性更强、更容易理解、性能可能更好。对于 C++14，你没有理由不选择使用 lambda。对于 C++11，只有两种场景，std::bind 可以弥补 lambda 的不足：

第一：移动捕获。C++14 的初始化捕获模式支持移动捕获。C++11 的 lambda 不支持移动捕获，可以使用 std::bind 模拟来间接实现，参见 Item32 。

第二：多态函数对象。C++14 支持 auto 参数类型，也即通用 lambda，参见 Item33 。但是 C++11 不支持通用 lambda。而 std::bind 绑定对象的函数调用使用完美转发实现，可以接收任何类型的参数。如下例子：

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

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

boundPW(1930);       // pass int to
                     // PolyWidget::operator()
boundPW(nullptr);    // pass nullptr to
                     // PolyWidget::operator()
boundPW("Rosebud");  // pass string literal to
                     // PolyWidget::operator()

C++11 做不到，C++14 则很容易：

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

最后总结下：

• 相较于 std::bind，lambda 代码可读性更强、更容易理解、性能可能更好。
• C++11 的 std::bind 在实现移动捕获、模板函数对象方面可以弥补 lambda 的不足。