Home » C++ » Difference between C++11 std::bind and boost::bind

Difference between C++11 std::bind and boost::bind

Posted by: admin November 29, 2017 Leave a comment

Questions:

Is there any difference between the two? Or am I safe to replace every occurrence of boost::bind by std::bind in my code and thereby remove the dependence on Boost?

Answers:
  • boost::bind has overloaded relational operators, std::bind does not.

  • boost::bind supports non-default calling conventions, std::bind is not guaranteed to (standard library implementations may offer this as an extension).

  • boost::bind provides a direct mechanism to allow one to prevent eager evaluation of nested bind expressions (boost::protect), std::bind does not. (That said, one can use boost::protect with std::bind if they want, or trivially reimplement it on their own.)

  • std::bind provides a direct mechanism to allow one to treat any user defined functor as a nested bind expression in order to force eager evaluation (std::is_bind_expression: [func.bind.isbind]/1, [func.bind.bind]/10), boost::bind does not.

Questions:
Answers:

Besides the several differences cited on the other answers, here are two other differences:

  • boost::bind seems to deal with overloaded function names in some situations, whereas std::bind does not deal with them in the same way. See c++11 faq

(using gcc 4.7.2, boost lib version 1_54)

void foo(){}
void foo(int i){}

auto badstd1 = std::bind(foo);  
//compile error: no matching function for call to bind(<unresolved overloaded function type>)
auto badstd2 = std::bind(foo, 1); 
//compile error: no matching function for call to bind(<unresolved overloaded function type>)
auto std1 = std::bind(static_cast<void(*)()>(foo)); //compiles ok
auto std2 = std::bind(static_cast<void(*)(int)>(foo), 1); //compiles ok
auto boost1 = boost::bind(foo, 1); //compiles ok
auto boost2 = boost::bind(foo); //compiles ok

So if you simply replaced all boost::bind with std::bind, your build could break.

  • std::bind can seamlessly bind to c++11 lambda types, whereas boost::bind as of boost 1.54 seems to require input from the user (unless return_type is defined). See boost doc

(using gcc 4.7.2, boost lib version 1_54)

auto fun = [](int i) { return i;};
auto stdbound = std::bind(fun, std::placeholders::_1);
stdbound(1);

auto boostboundNaive = boost::bind(fun, _1);  //compile error.
// error: no type named ‘result_type’ ...
auto boostbound1 = boost::bind<int>(fun, _1); //ok
boostbound1(1);
auto boostbound2 = boost::bind(boost::type<int>(), fun, _1); //ok
boostbound2(1);

So, if you simply replaced all std::bind with boost::bind, your build could also break.

Questions:
Answers:

Besides the listed above, boost::bind has an important extension point: get_pointer() function that allows integrating boost::bind with any smart pointer, eg. ATL::CComPtr etc.
http://www.boost.org/doc/libs/1_49_0/libs/bind/mem_fn.html#get_pointer

As a result, with boost::bind you can also bind a weak_ptr:
http://lists.boost.org/Archives/boost/2012/01/189529.php

Questions:
Answers:

I don’t have the full answer but std::bind will use variadic templates rather than parameter lists.

The placeholders are in std::placeholders as in std::placeholders::_1rather than the global namespace.

I alias the namespace to stdph with

namespace stdph=std::placeholders;

Apart from that I have had no problems updating to C++11