Is the documentation for Boost::Bind matching the std::tr1::bind that got accepted? That is, can I read this to understand it since the docs are better than what comes with the compiler, or are there differences? 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)? 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). --John TradeStation Group, Inc. is a publicly-traded holding company (NASDAQ GS: TRAD) of three operating subsidiaries, TradeStation Securities, Inc. (Member NYSE, FINRA, SIPC and NFA), TradeStation Technologies, Inc., a trading software and subscription company, and TradeStation Europe Limited, a United Kingdom, FSA-authorized introducing brokerage firm. None of these companies provides trading or investment advice, recommendations or endorsements of any kind. The information transmitted is intended only for the person or entity to which it is addressed and may contain confidential and/or privileged material. Any review, retransmission, dissemination or other use of, or taking of any action in reliance upon, this information by persons or entities other than the intended recipient is prohibited. If you received this in error, please contact the sender and delete the material from any computer.
John, On Fri, Jun 4, 2010 at 2:31 PM, John Dlugosz <JDlugosz@tradestation.com> wrote:
Is the documentation for Boost::Bind matching the std::tr1::bind that got accepted? That is, can I read this to understand it since the docs are better than what comes with the compiler, or are there differences?
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.
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 Good luck, Nate
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<void (int,int,int,int)> callback; callback= bind... Will that, in general, adapt the result of bind when assigned? More to the point, what is the purpose of the signature in the function object, if the function's operator() takes anything and throws away extras, besides? I'm basically lost when it comes to what is typed, where, and when. --John TradeStation Group, Inc. is a publicly-traded holding company (NASDAQ GS: TRAD) of three operating subsidiaries, TradeStation Securities, Inc. (Member NYSE, FINRA, SIPC and NFA), TradeStation Technologies, Inc., a trading software and subscription company, and TradeStation Europe Limited, a United Kingdom, FSA-authorized introducing brokerage firm. None of these companies provides trading or investment advice, recommendations or endorsements of any kind. The information transmitted is intended only for the person or entity to which it is addressed and may contain confidential and/or privileged material. Any review, retransmission, dissemination or other use of, or taking of any action in reliance upon, this information by persons or entities other than the intended recipient is prohibited. If you received this in error, please contact the sender and delete the material from any computer.
AMDG John Dlugosz wrote:
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.
I'm not quite sure what you mean. Bind doesn't care about the signature of the first argument. It just tries to call it with whatever arguments it's given. The type checking happens then.
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<void (int,int,int,int)> callback; callback= bind...
Will that, in general, adapt the result of bind when assigned? More to the point, what is the purpose of the signature in the function object, if the function's operator() takes anything and throws away extras, besides? I'm basically lost when it comes to what is typed, where, and when.
function<void(int, int, int, int)> stores any function object that can be called with four ints. The function object returned by bind() is called with those arguments, and may ignore some of them. The signature is necessary for boost::function, because boost::function is monomorphic. The bind function objects are polymorphic and try to adapt to whatever is thrown at them. In Christ, Steven Watanabe
What does AMDG mean? Ah, so the return from bind is not the same kind of thing as class function. Bind knows the signature of what it's remembering, and operator(), itself a template, passes the arguments through and the compiler knows the type of everything. The "work" is done by the specialization of operator(). Meanwhile, the std::function object is declared with a specific signature, has an operator() that's not a template but takes just that, and what it points to inside is known to be that same type. So... the initialization of the function instance picks wants a matching operator() on the bind result object, so it specializes that one, same as it would if calling it with those actual argument types exactly. The "work" is still done by the specialization so chosen.
function<void(int, int, int, int)> stores any function object that can be called with four ints. The function object returned by bind() is called with those arguments, and may ignore some of them. The signature is necessary for boost::function, because boost::function is monomorphic. The bind function objects are polymorphic and try to adapt to whatever is thrown at them.
So, f= bind(whatever); will have f remember the bind result object (whatever that is) and its member operator()(int,int,int,int). And to clarify, f doesn't take extra arguments past those four, that is a property of the bind object. I think I got it now. --John TradeStation Group, Inc. is a publicly-traded holding company (NASDAQ GS: TRAD) of three operating subsidiaries, TradeStation Securities, Inc. (Member NYSE, FINRA, SIPC and NFA), TradeStation Technologies, Inc., a trading software and subscription company, and TradeStation Europe Limited, a United Kingdom, FSA-authorized introducing brokerage firm. None of these companies provides trading or investment advice, recommendations or endorsements of any kind. The information transmitted is intended only for the person or entity to which it is addressed and may contain confidential and/or privileged material. Any review, retransmission, dissemination or other use of, or taking of any action in reliance upon, this information by persons or entities other than the intended recipient is prohibited. If you received this in error, please contact the sender and delete the material from any computer.
On Mon, Jun 7, 2010 at 8:29 PM, John Dlugosz <JDlugosz@tradestation.com>wrote:
What does AMDG mean?
AMDG - see http://en.wikipedia.org/wiki/Ad_maiorem_Dei_gloriam You might notice he signs off "In Christ" too. - Rob.
FWIW, I found (only) that when I checked a dictionary, but assumed it was a false hit. I was expecting some net neologism like BTW, IMHO, IIRC, ... that would qualify or annotate the following text. In Code, --John From: boost-users-bounces@lists.boost.org [mailto:boost-users-bounces@lists.boost.org] On Behalf Of Robert Jones Sent: Monday, June 07, 2010 4:52 PM To: boost-users@lists.boost.org Subject: Re: [Boost-users] Bind questions On Mon, Jun 7, 2010 at 8:29 PM, John Dlugosz <JDlugosz@tradestation.com<mailto:JDlugosz@tradestation.com>> wrote: What does AMDG mean? AMDG - see http://en.wikipedia.org/wiki/Ad_maiorem_Dei_gloriam You might notice he signs off "In Christ" too. - Rob. TradeStation Group, Inc. is a publicly-traded holding company (NASDAQ GS: TRAD) of three operating subsidiaries, TradeStation Securities, Inc. (Member NYSE, FINRA, SIPC and NFA), TradeStation Technologies, Inc., a trading software and subscription company, and TradeStation Europe Limited, a United Kingdom, FSA-authorized introducing brokerage firm. None of these companies provides trading or investment advice, recommendations or endorsements of any kind. The information transmitted is intended only for the person or entity to which it is addressed and may contain confidential and/or privileged material. Any review, retransmission, dissemination or other use of, or taking of any action in reliance upon, this information by persons or entities other than the intended recipient is prohibited. If you received this in error, please contact the sender and delete the material from any computer.
participants (4)
-
John Dlugosz -
Nathan Crookston -
Robert Jones -
Steven Watanabe