Why use std::bind over lambdas in C++14?

by

Scott Meyers gave a talk about this. This is what I remember:

In C++14 there is nothing useful bind can do that can’t also be done with lambdas.

In C++11 however there are some things that can’t be done with lambdas:

  1. You can’t move the variables while capturing when creating the lambdas. Variables are always captured as lvalues. For bind you can write:

    auto f1 = std::bind(f, 42, _1, std::move(v));

  2. Expressions can’t be captured, only identifiers can. For bind you can write:

    auto f1 = std::bind(f, 42, _1, a + b);

  3. Overloading arguments for function objects. This was already mentioned in the question.

  4. Impossible to perfect-forward arguments

In C++14 all of these possible.

  1. Move example:

    auto f1 = [v = std::move(v)](auto arg) { f(42, arg, std::move(v)); };

  2. Expression example:

    auto f1 = [sum = a + b](auto arg) { f(42, arg, sum); };

  3. See question

  4. Perfect forwarding: You can write

    auto f1 = [=](auto&& arg) { f(42, std::forward<decltype(arg)>(arg)); };

Some disadvantages of bind:

  • Bind binds by name and as a result if you have multiple functions with the same name (overloaded functions) bind doesn’t know which one to use. The following example won’t compile, while lambdas wouldn’t have a problem with it:

    void f(int); void f(char); auto f1 = std::bind(f, _1, 42);
  • When using bind functions are less likely to be inlined

On the other hand lambdas might theoretically generate more template code than bind. Since for each lambda you get a unique type. For bind it is only when you have different argument types and a different function (I guess that in practice however it doesn’t happen very often that you bind several time with the same arguments and function).

What Jonathan Wakely mentioned in his answer is actually one more reason not to use bind. I can’t see why you would want to silently ignore arguments.

More Related Contents:

  1. How to create an std::function from a move-capturing lambda expression?
  2. How does generic lambda work in C++14?
  3. Bind Vs Lambda?
  4. Why are lambda expressions not allowed in an unevaluated operands but allowed in the unevaluated portions of constant expressions?
  5. c++ lambdas how to capture variadic parameter pack from the upper scope
  6. Capturing perfectly-forwarded variable in lambda
  7. Lambda capture as const reference?
  8. How to immediately invoke a C++ lambda?
  9. Why do lambda functions drop deduced return type reference by default?
  10. Purpose of perfect forwarding for Callable argument in invocation expression?
  11. Declaring lambda with int type not working [closed]
  12. Differences between std::make_unique and std::unique_ptr with new
  13. How is std::function implemented?
  14. Overload resolution between object, rvalue reference, const reference
  15. When should I use C++14 automatic return type deduction?
  16. Can lambda functions be templated?
  17. Are compound literals Standard C++?
  18. Understanding the example on lvalue-to-rvalue conversion
  19. Self-initialization of a static constexpr variable, is it well-formed?
  20. Are notes and examples in the core language specification of the C++ Standard non-normative?
  21. Should I copy an std::function or can I always take a reference to it?
  22. Optimization of raw new[]/delete[] vs std::vector
  23. Check traits for all variadic template arguments
  24. Why can’t I capture this by-reference (‘&this’) in lambda?
  25. error::make_unique is not a member of ‘std’
  26. How do static variables in lambda function objects work?
  27. Can I legally reinterpret_cast between layout-compatible standard-layout types?
  28. What’s the standard/official name for universal references?
  29. Reference invalidation after applying reverse_iterator on a custom made iterator
  30. When can we omit the return type in a C++11 lambda?

Leave a Comment