The biggest difference I know of between boost::bind and std::tr1::bind is that the placeholders (_1, _2, ...) are moved from essentially being global scope to being in std::tr1::placeholders. There may be other differences, but I don't think they'd affect the usage you describe below.
OK, thanks.
Consider a member function C::foo. If I want to bind the object this parameter but leave the rest unchanged, would bind(&C::foo,x) automatically give me bind(&C::foo,x,_1,_2,_3)?
It would not. At least with boost::bind the former doesn't work. Forgetting a placeholder has always been a good way for me to get an internal compiler error on VC8.
What if I want to call x->foo(5,_3) and not use the first two parameters or the 4th, to make something that is passed to a callback function that wants 4 arguments? That is, the callback F is invoked F(a,b,c,d) and I want to make a function instance that can be assigned to F, and ends up calling x->foo(5,c).
To be clear, are you referring to something like the following? #include <iostream>
#include "boost/bind.hpp"
struct C { void foo(int a, int b) const { std::cout << a << ';' << b << std::endl; }
};
int main() { C c; boost::bind(&C::foo, c, 5, _3)(1, 2, 3, 4);
return 0; }
Works for me: $ ./a.exe 5;3
Ah yes, I remember reading that extra parameters called are simply ignored, and the rationale that this is generally good for callbacks.
And, you clarify that the extra arguments are dropped, as opposed to filling in extra args for the binded target. I was wondering if you could pass the "incoming" signature separate from having it deduced from the first argument to bind. As it exists now, "bind" supplies all arguments to the bound call, some of which may be placeholders. You don't leave off trailing placeholders. Right? There is no "bind first n" function.
Now your example shows extra arguments ignored when calling the function object returned by bind, but the desired type was never given.
function