[bind] How do I....?

Robert Jones

18 Aug 2009 18 Aug '09

9:07 a.m.

Use bind to call a free function on a vector of shared_ptrs? struct A { }; void f(const A&); std::vector v; for_each(v.begin(), v.end(), boost::bind(f, ???? ) ); what goes where ???? is? Thanks, Rob.

Attachments:

attachment.html (text/html — 278 bytes)

Show replies by date

Neil Groves

18 Aug 18 Aug

9:41 a.m.

On Tue, Aug 18, 2009 at 10:07 AM, Robert Jones wrote:

...

Use bind to call a free function on a vector of shared_ptrs?

struct A { }; void f(const A&); std::vector v;

for_each(v.begin(), v.end(), boost::bind(f, ???? ) );

what goes where ???? is?

Two tactics spring to mind. One is to use boost::make_indirect_iterator on v.begin() and v.end() and just pass in f instead of the boost::bind(...). The other is to use RangeEx (shameless plug) thus: using namespace boost::adaptors; boost::for_each(v | indirected, f);

...

Thanks, Rob.

Regards, Neil Groves

...

_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users

Robert Jones

9:53 a.m.

On Tue, Aug 18, 2009 at 10:41 AM, Neil Groves wrote:

...

On Tue, Aug 18, 2009 at 10:07 AM, Robert Jones wrote:

...
Use bind to call a free function on a vector of shared_ptrs?

struct A { }; void f(const A&); std::vector v;

for_each(v.begin(), v.end(), boost::bind(f, ???? ) );

what goes where ???? is?

Two tactics spring to mind.

One is to use boost::make_indirect_iterator on v.begin() and v.end() and just pass in f instead of the boost::bind(...).

Excellent - attack from the opposite direction, I'd not thought of that approach!

...

The other is to use RangeEx (shameless plug) thus:

using namespace boost::adaptors; boost::for_each(v | indirected, f);

Ah, if only I could! Doesn't that just demonstrate why RangeEx is so eagerly awaited. Thanks Neil - Rob.

Björn Karlsson

10:01 a.m.

Hello Neil,

...

Two tactics spring to mind.

One is to use boost::make_indirect_iterator on v.begin() and v.end() and just pass in f instead of the boost::bind(...).

Yes, this makes for quite readable code: for_each(make_indirect_iterator(vec.begin()), make_indirect_iterator(vec.end()), &foo);

...

The other is to use RangeEx (shameless plug) thus:

using namespace boost::adaptors; boost::for_each(v | indirected, f);

Creative! A good example of why it helps to have many power tools! Cheers, Bjorn Karlsson www.skeletonsoftware.net

Björn Karlsson

9:46 a.m.

Hello Rob,

...

Subject: [Boost-users] [bind] How do I....?

Use bind to call a free function on a vector of shared_ptrs?

struct A { }; void f(const A&); std::vector v;

for_each(v.begin(), v.end(), boost::bind(f, ???? ) );

what goes where ???? is?

You have two options if you want to use binders: 1) Use Boost.Bind with nested binds, binding operator* of shared_ptr in the inner bind. for_each(vec.begin(), vec.end(), boost::bind(&foo, boost::bind(&boost::shared_ptr<A>::operator*, _1))); 2) Use Boost.Lambda's bind() and dereference the placeholder directly in the bind expression. for_each(vec.begin(), vec.end(), bind(&foo, *_1)); Here's a complete example demonstrating option 2). #include <vector> #include <algorithm> #include "boost/shared_ptr.hpp" #include "boost/lambda/bind.hpp" #include "boost/lambda/lambda.hpp" class A {}; void foo(const A& a) {} int main(int argc, char** argv) { using boost::lambda::bind; using boost::lambda::_1; std::vector vec; vec.push_back(boost::shared_ptr<A>(new A())); for_each(vec.begin(), vec.end(), bind(&foo, *_1)); return 0; } Cheers, Bjorn Karlsson www.skeletonsoftware.net

Robert Jones

9:58 a.m.

2009/8/18 Björn Karlsson

...

Hello Rob,

...
Subject: [Boost-users] [bind] How do I....?

Use bind to call a free function on a vector of shared_ptrs?

struct A { }; void f(const A&); std::vector v;

for_each(v.begin(), v.end(), boost::bind(f, ???? ) );

what goes where ???? is?

You have two options if you want to use binders:

1) Use Boost.Bind with nested binds, binding operator* of shared_ptr in the inner bind.

for_each(vec.begin(), vec.end(), boost::bind(&foo, boost::bind(&boost::shared_ptr<A>::operator*, _1)));

This was about the best I could think of too, and is, I think, what I'll do.

...

2) Use Boost.Lambda's bind() and dereference the placeholder directly in the bind expression.

for_each(vec.begin(), vec.end(), bind(&foo, *_1));

Much as I like Lambda for virgin code, in my work code base there's a very visible inclusion of Boost.Bind, with placeholders in the global namespace. I've concluded that the pain of clashing placeholders just isn't worth it, so I steer clear of Lambda now. Thanks Bjorn. - Rob.

Michael Caisse

5:10 p.m.

Robert Jones wrote:

...

2009/8/18 Björn Karlsson mailto:Bjorn.Karlsson@readsoft.com>

2) Use Boost.Lambda's bind() and dereference the placeholder directly in the bind expression.

for_each(vec.begin(), vec.end(), bind(&foo, *_1));

Much as I like Lambda for virgin code, in my work code base there's a very visible inclusion of Boost.Bind, with placeholders in the global namespace. I've concluded that the pain of clashing placeholders just isn't worth it, so I steer clear of Lambda now.

Thanks Bjorn.

- Rob.

Rob - Let me suggest Boost.Phoenix. Phoenix is an amazingly powerful library that will handle all of your bind and lambda needs. You also wont suffer from the plagued global namespace fiasco by mixing Boost.Bind and Boost.Lambda. Your example with Phoenix: #include <vector> #include <algorithm> #include #include #include #include struct A {}; void foo( const A& ) {} int main() { using namespace boost::phoenix; using namespace boost::phoenix::arg_names; std::vector< boost::shared_ptr< A > > vec; vec.push_back( boost::shared_ptr< A >( new A ) ); std::for_each( vec.begin(), vec.end(), bind( &foo, *arg1 ) ); return 0; } I hope this helps out. Best Regards - Michael -- ---------------------------------- Michael Caisse Object Modeling Designs www.objectmodelingdesigns.com

OvermindDL1

6:13 p.m.

On Tue, Aug 18, 2009 at 11:10 AM, Michael Caisse wrote:

...

Robert Jones wrote:

...
2009/8/18 Björn Karlsson mailto:Bjorn.Karlsson@readsoft.com>

2) Use Boost.Lambda's bind() and dereference the placeholder directly in the bind expression.

for_each(vec.begin(), vec.end(), bind(&foo, *_1));

Much as I like Lambda for virgin code, in my work code base there's a very visible inclusion of Boost.Bind, with placeholders in the global namespace. I've concluded that the pain of clashing placeholders just isn't worth it, so I steer clear of Lambda now.

Thanks Bjorn.

- Rob.

Rob -

Let me suggest Boost.Phoenix. Phoenix is an amazingly powerful library that will handle all of your bind and lambda needs. You also wont suffer from the plagued global namespace fiasco by mixing Boost.Bind and Boost.Lambda.

Your example with Phoenix:

#include <vector> #include <algorithm> #include #include #include #include

struct A {};

void foo( const A& ) {}

int main() { using namespace boost::phoenix; using namespace boost::phoenix::arg_names;

std::vector< boost::shared_ptr< A > > vec; vec.push_back( boost::shared_ptr< A >( new A ) );

std::for_each( vec.begin(), vec.end(), bind( &foo, *arg1 ) ); return 0; }

I hope this helps out.

This is another vote for Boost.Phoenix2, its bind replaces all possible uses I have ever seen of Boost.Bind or Boost.Lambda::bind and in an easier way.

Robert Jones

7:58 p.m.

On Tue, Aug 18, 2009 at 6:10 PM, Michael Caisse < boost@objectmodelingdesigns.com> wrote:

...

Robert Jones wrote:

...
2009/8/18 Björn Karlsson >

2) Use Boost.Lambda's bind() and dereference the placeholder directly in the bind expression.

for_each(vec.begin(), vec.end(), bind(&foo, *_1));

Much as I like Lambda for virgin code, in my work code base there's a very visible inclusion of Boost.Bind, with placeholders in the global namespace. I've concluded that the pain of clashing placeholders just isn't worth it, so I steer clear of Lambda now.

Thanks Bjorn.

- Rob.

Rob -

Let me suggest Boost.Phoenix. Phoenix is an amazingly powerful library that will handle all of your bind and lambda needs. You also wont suffer from the plagued global namespace fiasco by mixing Boost.Bind and Boost.Lambda.

Ah, yes, Phoenix...... I'm never sure of the status of Phoenix - it's not listed as a first class library in the documentation, but buried inside the Spirit docs, and I understand that's about to change. So will all the #include paths change, or indeed some aspects of the functionality? Thanks Micheal - Rob.

OvermindDL1

19 Aug 19 Aug

4:11 a.m.

On Tue, Aug 18, 2009 at 1:58 PM, Robert Jones wrote:

...

On Tue, Aug 18, 2009 at 6:10 PM, Michael Caisse wrote:

...
Robert Jones wrote:

...
2009/8/18 Björn Karlsson mailto:Bjorn.Karlsson@readsoft.com>

2) Use Boost.Lambda's bind() and dereference the placeholder directly in the bind expression.

for_each(vec.begin(), vec.end(), bind(&foo, *_1));

Much as I like Lambda for virgin code, in my work code base there's a very visible inclusion of Boost.Bind, with placeholders in the global namespace. I've concluded that the pain of clashing placeholders just isn't worth it, so I steer clear of Lambda now.

Thanks Bjorn.

- Rob.

Rob -

Let me suggest Boost.Phoenix. Phoenix is an amazingly powerful library that will handle all of your bind and lambda needs. You also wont suffer from the plagued global namespace fiasco by mixing Boost.Bind and Boost.Lambda.

Ah, yes, Phoenix......

I'm never sure of the status of Phoenix - it's not listed as a first class library in the documentation, but buried inside the Spirit docs, and I understand that's about to change. So will all the #include paths change, or indeed some aspects of the functionality?

It should not I would think. Phoenix2 (phoenix in spirit, the old phoenix is phoenix1, ignore it) is heavily used by the very latest Spirit2.1 codebase, and spirit tends to always include forwarding headers as things move around anyway.

Michael Caisse

4:18 a.m.

Robert Jones wrote:

...

On Tue, Aug 18, 2009 at 6:10 PM, Michael Caisse mailto:boost@objectmodelingdesigns.com> wrote:

Let me suggest Boost.Phoenix. Phoenix is an amazingly powerful library that will handle all of your bind and lambda needs. You also wont suffer from the plagued global namespace fiasco by mixing Boost.Bind and Boost.Lambda.

Ah, yes, Phoenix......

I'm never sure of the status of Phoenix - it's not listed as a first class library in the documentation, but buried inside the Spirit docs, and I understand that's about to change. So will all the #include paths change, or indeed some aspects of the functionality?

Thanks Micheal

- Rob. Phoenix is an integral part of Spirit 2.1. While it is a "detail" of sorts you will notice in the libs/spirit directory that Phoenix has first class treatment. I suspect the best answers to your questions are in Hartmut's summary of the Phoenix review:

http://lists.boost.org/boost-announce/2008/10/0205.php Others may have better insider knowledge. I can attest to the quality of the library and docs as well as the stability. I started using the library because of Spirit 2.1; however, I now use it for all of my lambda/bind needs. Michael -- ---------------------------------- Michael Caisse Object Modeling Designs www.objectmodelingdesigns.com

5570

Age (days ago)

5571

Last active (days ago)

List overview

Download

10 comments

5 participants

participants (5)

Björn Karlsson
Michael Caisse
Neil Groves
OvermindDL1
Robert Jones

[bind] How do I....?

Robert Jones

Neil Groves

Robert Jones

Björn Karlsson

Björn Karlsson

Robert Jones

Michael Caisse

OvermindDL1

Robert Jones

OvermindDL1

Michael Caisse

tags

participants (5)