std::bind a bound function

by

std::bind expressions, like their boost::bind predecessors, support a type of composition operation. Your expression for w is roughly equivalent to 

auto w=std::bind(some_fun,  std::bind(&foo::bar<int>, x, std::placeholders::_1) );

Nesting binds in this manner is interpreted as

  1. Calculate the value of x.bar<int>(y) where y is the first parameter passed into the resulting functor.
  2. Pass that result into some_fun.

But x.bar<int>(y) returns void, not any function type. That’s why this doesn’t compile.

As K-ballo points out, with boost::bind, you can fix this problem with boost::protect. As Kerrek SB and ildjarn point out, one way around this issue is: don’t use auto for f. You don’t want f to have the type of a bind expression. If f has some other type, then std::bind won’t attempt to apply the function composition rules. You might, for instance, give f the type std::function<void(int)>:

std::function<void(int)> f = std::bind(&foo::bar<int>, x, std::placeholders::_1);
auto w = std::bind(some_fun, f);

Since f doesn’t literally have the type of a bind expression, std::is_bind_expression<>::value will be false on f‘s type, and so the std::bind expression in the second line will just pass the value on verbatim, rather than attempting to apply the function composition rules.

More Related Contents:

  1. Declaring lambda with int type not working [closed]
  2. Optimization code for a debug function (c++11 with templates) [closed]
  3. Using generic std::function objects with member functions in one class
  4. How to convert a lambda to an std::function using templates
  5. Meaning of = delete after function declaration
  6. Should I use std::function or a function pointer in C++?
  7. Bind Vs Lambda?
  8. Why is std::function not equality comparable?
  9. Is it possible to std::move objects out of functions? (C++11)
  10. Inferring the call signature of a lambda or arbitrary callable for “make_function”
  11. Get function pointer from std::function when using std::bind
  12. Function returning a lambda expression
  13. C++ Function Callbacks: Cannot convert from a member function to a function signature
  14. Why the initializer of std::function has to be CopyConstructible?
  15. Does std::bind work with move-only types in general, and std::unique_ptr in particular?
  16. Why can’t C++11 move a noncopyable functor to a std::function?
  17. Dots in printf in C++
  18. What does the namespace std add? (C++) [closed]
  19. Difference in make_shared and normal shared_ptr in C++
  20. What does auto&& tell us?
  21. Why should I avoid std::enable_if in function signatures
  22. C++ auto keyword. Why is it magic?
  23. How to store variadic template arguments?
  24. How do I use unique_ptr for pimpl?
  25. Significance of parentheses in decltype((c))?
  26. Why is modifying a string through a retrieved pointer to its data not allowed?
  27. What is the default hash function used in C++ std::unordered_map?
  28. Dynamic aligned memory allocation in C++11
  29. std::unique_ptr with derived class
  30. Dependent name resolution & namespace std / Standard Library

Leave a Comment