Peter Dimov wrote:

When you construct a boost::function from &HandleClass::handle, what actually gets stored is boost::mem_fn(&HandleClass::handle). See

http://www.boost.org/libs/mem_fn/

Even

std::vector< boost::shared_ptr<HandleClass> > listOfHcs;

will work.

Thanks Peter, makes sense after reading that documentation now. I've actually got another question - I'd really prefer to replace ReturnContainer with an output iterator type. So Extract would look like this: template < class InIterator, class OutIterator, > void Extract(const InIterator & itBegin, const InIterator & itEnd, OutIterator & itOut, boost::function1 f) { for (FwdIterator it = itBegin ;it != itEnd; ++it) { *itOut++ = f(*it); } }; And then you'd typically call Extract with an inserter: Extract(listOfHcs.begin(), listOfHcs.end(), back_inserter(needToFill), &HandleClass::handle); But this doesn't compile because the inserters (at least on my platform) don't define value_type. I'd prefer to take an iterator because it gives greater flexibility (can use inserter, front_inserter or back_inserter) and it more closely models the standard algorithms. However, I need to know the return type of the function and I can't see any way to get it without specifying it as a template parameter. Actually, I think I could use the typedefs that are defined in the inserters to retrieve the container, and then the value type, but this then forces the client to use inserters. Am I overlooking something here? Cheers, Matt

Heya Peter, Peter Dimov wrote:

...

But this doesn't compile because the inserters (at least on my platform) don't define value_type.

They aren't required to. You should use std::iterator_traits<It>::value_type.

Ah, makes sense.

...

Am I overlooking something here?

1. Iterators are typically passed by value.

I've noticed that - is there are reason for this? My reason for passing by const reference is mostly academic anyway because copying iterators is typically cheap, I just have a curious nature... :)

2. You don't need to use boost::function in a template. It is typically only used when you want a fixed compile-time signature.

template void Extract(InIt first, InIt last, OutIt out, F f) { for (; first != last; ++first, ++out) { *out = f(*first); } }

Now look at std::transform. :-)

Oh the shame of it! ;) Covered with embarrassment I've dutifully erased my Extract function... :) Kinda funny how sometimes you can't see the wood through the trees...only yesterday I recommended that a colleague use transform for (what I now recognise as) a similar application. I got hung up on the fact that I wanted to use boost::function I guess...

(You'll no longer be able to pass &X::f directly, though, use mem_fn explicitly.)

Got it. For those that are curious here's the improved solution that Peter was alluding to: std::transform(listOfHcs.begin(), listOfHcs.end(), back_inserter(needToFill), boost::mem_fn(&HandleClass::handle)); Thanks Peter - both for your help and your work in boost! :) Cheers, Matt