Transform vector of boost::shared_ptr using boost::bind and boost::static_pointer_cast

Question

I have a std::vector of Boost shared pointers to objects, and would like to get a vector of shared pointers to the same objects casted down to a more specific type:

//using boost::shared_ptr, std::vector;
vector<shared_ptr<A> > originalVec;
vector<shared_ptr<B> > targetVec( originalVec.size() ); // B extends A

For a single element shared_ptr<A> elem, it is possible to cast it using boost::static_pointer_cast<B>(elem), whose syntax is reproduced below (from Boost shared_ptr doc):

template<class T, class U>
shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r); // never throws

I don't know how to use it with std::transform. Mi tries include:

//using boost::bind, boost::static_pointer_cast
transform( originalVec.begin(), originalVec.end(), targetVec.begin(), bind( static_pointer_cast<B>, _1) )
transform( originalVec.begin(), originalVec.end(), targetVec.begin(), bind( static_pointer_cast<B,A>, _1) )

Getting in both cases a "no matching function for call to bind(<unresolved overloaded function type>, boost::arg<1>& )"

Any ideas?

EDIT: The problem could be related with an ambiguity, since a similar function template is defined for intrusive pointer class, with syntax:

template<class T, class U>
intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & r); // never throws

The question, in this case, is how to specify the type of the first argument so that the compiler knows which method to select.

Jonathan Wakely · Accepted Answer · 2013-07-10T23:10:51.510

3

You can usually tell the compiler which overload you want by specifying the type of the function pointer you want e.g.

typedef shared_ptr<B>(*func_type)(const shared_ptr<A>&);

transform( originalVec.begin(), originalVec.end(), targetVec.begin(), bind( (func_type)static_pointer_cast<B,A>, _1) );

But in cases where you get this sort of error from an overloaded function that can't be disambiguated, my preferred solution is often to provide a custom functor that does the call, so that overload resolution is done by the compiler, and you don't have to select an overload e.g.

struct Downcast {
  shared_ptr<B> operator()(const shared_ptr<A>& p) const
  { return shared_pointer_cast<B>(p); }
};

transform( originalVec.begin(), originalVec.end(), targetVec.begin(), Downcast() );

edited Jul 10 '13 at 23:10

answered Jul 10 '13 at 23:04

Jonathan Wakely

166,810
27
341
521

Here we are in the second case: the ambiguity cannot be resolved. I was using transform to avoid writing a loop... and in that sense, having to create a functor spoils the conciseness and simplicity I had in mind (even more code than the loop!!). It's a pity we don't have lambda expressions in C++98 :P Thank you for your help! – dunadar Jul 11 '13 at 00:35
Ooook, no other satisfactory solutions, so I accept yours. Finally used a simple "for" loop. Aaaah C++, you merciless b**ch. – dunadar Jul 11 '13 at 09:26

score 0 · Answer 2 · answered Jul 10 '13 at 22:36

I'm not sure why you got that error with your second try, because that one should've worked.

However, there is a possibility you'll overrun the bounds of targetVec if it is empty because simply passing an iterator to transform is not enough, you need to push_back the result of the cast into targetVec. This can be done easily by passing a back_insert_iterator to transform.

int main()
{
    std::vector<boost::shared_ptr<A>> original;
    std::vector<boost::shared_ptr<B>> target;

    original.push_back( boost::make_shared<B>() );

    boost::transform( original,
                      std::back_inserter( target ),
                      boost::bind( boost::static_pointer_cast<B, A>, _1 ) );

    // OR
    std::transform( original.begin(), 
                    original.end(),
                    std::back_inserter( target ),
                    boost::bind( boost::static_pointer_cast<B, A>, _1 ) );
}

Yes, I'm particularly annoyed with the second try not working. Thank you for your suggestion, but it is not the case: I just forgot to say that the second array has enough space reserved --declared as vector > targetVec( originalVec.size() ); — dunadar, Jul 11 '13 at 00:23

Transform vector of boost::shared_ptr using boost::bind and boost::static_pointer_cast

2 Answers2