std::function and std::bind: what are they, and when should they be used?

by

std::bind is for partial function application.

That is, suppose you have a function object f which takes 3 arguments:

f(a,b,c);

You want a new function object which only takes two arguments, defined as:

g(a,b) := f(a, 4, b);

g is a “partial application” of the function f: the middle argument has already been specified, and there are two left to go.

You can use std::bind to get g:

auto g = bind(f, _1, 4, _2);

This is more concise than actually writing a functor class to do it.

There are further examples in the article you link to. You generally use it when you need to pass a functor to some algorithm. You have a function or functor that almost does the job you want, but is more configurable (i.e. has more parameters) than the algorithm uses. So you bind arguments to some of the parameters, and leave the rest for the algorithm to fill in:

// raise every value in vec to the power of 7
std::transform(vec.begin(), vec.end(), some_output, std::bind(std::pow, _1, 7));

Here, pow takes two parameters and can raise to any power, but all we care about is raising to the power of 7.

As an occasional use that isn’t partial function application, bind can also re-order the arguments to a function:

auto memcpy_with_the_parameters_in_the_right_flipping_order = bind(memcpy, _2, _1, _3);

I don’t recommend using it just because you don’t like the API, but it has potential practical uses for example because:

not2(bind(less<T>, _2, _1));

is a less-than-or-equal function (assuming a total order, blah blah). This example normally isn’t necessary since there already is a std::less_equal (it uses the <= operator rather than <, so if they aren’t consistent then you might need this, and you might also need to visit the author of the class with a cluestick). It’s the sort of transformation that comes up if you’re using a functional style of programming, though.

More Related Contents:

  1. std::function vs template
  2. Isn’t the template argument (the signature) of std::function part of its type?
  3. How std::bind works with member functions
  4. Vector of std::function with different signatures
  5. How to directly bind a member function to an std::function in Visual Studio 11?
  6. Comparing std::functions for equality?
  7. std::function fails to distinguish overloaded functions
  8. Why do objects returned from bind ignore extra arguments?
  9. how to avoid static member function when using gsl with c++
  10. Using `std::function` to call non-void function
  11. Difference between C++11 std::bind and boost::bind
  12. What is the purpose of std::function and how to use it?
  13. Using ‘void’ template arguments in C++
  14. Is there a reference_wrapper for rvalue references?
  15. Using paragraphs 8.5.3p4 and p5 in the C++11 Standard, how do I prove that the snippet below doesn’t compile?
  16. How do I terminate a thread in C++11?
  17. Why does this C++ snippet compile (non-void function does not return a value) [duplicate]
  18. What is the type of lambda when deduced with “auto” in C++11?
  19. How to specialize std::hash::operator() for user-defined type in unordered containers?
  20. How to initialize std::array elegantly if T is not default constructible?
  21. Why does auto x{3} deduce an initializer_list?
  22. How do I initialize a member array with an initializer_list?
  23. Template tuple – calling a function on each element
  24. Variadic templates
  25. What is the class keyword before a function argument?
  26. Move out element of std priority_queue in C++11
  27. When must you pass io_context to boost::asio::spawn? (C++)
  28. reinterpret_cast between char* and std::uint8_t* – safe?
  29. How does =delete on destructor prevent stack allocation?
  30. C++11 ‘native_handle’ is not a member of ‘std::this_thread’

Leave a Comment