3

Is there a concise, generic way to convert a std container (such as vector) of regular/dumb pointers:

vector< T* >

to, for instance, boost::shared_ptr?:

vector< boost::shared_ptr<T> >

I thought I could pull it off using vector's range constructor:

vector< T* > vec_a; ... vector< boost::shared_ptr<T> > vec_b( vec_a.begin(), vec_a.end() );

but that refused to compile (Visual Studio 2008).

EDIT: Test code:

void test() { vector< int* > vec_a; vector< boost::shared_ptr<int> > vec_b( vec_a.begin(), vec_a.end() ); }

Compilation errors:

1>c:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include\memory(131) : error C2664: 'std::allocator<_Ty>::construct' : cannot convert parameter 2 from 'int *' to 'const boost::shared_ptr<T> &' 1> with 1> [ 1> _Ty=boost::shared_ptr<int> 1> ] 1> and 1> [ 1> T=int 1> ] 1> Reason: cannot convert from 'int *' to 'const boost::shared_ptr<T>' 1> with 1> [ 1> T=int 1> ] 1> Constructor for class 'boost::shared_ptr<T>' is declared 'explicit' 1> with 1> [ 1> T=int 1> ] 1> c:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include\memory(822) : see reference to function template instantiation '_FwdIt std::_Uninit_copy<int**,_FwdIt,_Alloc>(_InIt,_InIt,_FwdIt,_Alloc &,std::_Nonscalar_ptr_iterator_tag,std::_Range_checked_iterator_tag)' being compiled 1> with 1> [ 1> _FwdIt=boost::shared_ptr<int> *, 1> _Alloc=std::allocator<boost::shared_ptr<int>>, 1> _InIt=int ** 1> ] 1> c:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include\vector(1141) : see reference to function template instantiation '_FwdIt stdext::unchecked_uninitialized_copy<_Iter,boost::shared_ptr<T>*,std::allocator<_Ty>>(_InIt,_InIt,_FwdIt,_Alloc &)' being compiled 1> with 1> [ 1> _FwdIt=boost::shared_ptr<int> *, 1> _Iter=std::_Vector_iterator<int *,std::allocator<int *>>, 1> T=int, 1> _Ty=boost::shared_ptr<int>, 1> _InIt=std::_Vector_iterator<int *,std::allocator<int *>>, 1> _Alloc=std::allocator<boost::shared_ptr<int>> 1> ] 1> c:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include\vector(956) : see reference to function template instantiation 'boost::shared_ptr<T> *std::vector<_Ty>::_Ucopy<_Iter>(_Iter,_Iter,boost::shared_ptr<T> *)' being compiled 1> with 1> [ 1> T=int, 1> _Ty=boost::shared_ptr<int>, 1> _Iter=std::_Vector_iterator<int *,std::allocator<int *>> 1> ] 1> c:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include\vector(889) : see reference to function template instantiation 'void std::vector<_Ty>::_Insert<_Iter>(std::_Vector_const_iterator<_Ty,_Alloc>,_Iter,_Iter,std::forward_iterator_tag)' being compiled 1> with 1> [ 1> _Ty=boost::shared_ptr<int>, 1> _Iter=std::_Vector_iterator<int *,std::allocator<int *>>, 1> _Alloc=std::allocator<boost::shared_ptr<int>> 1> ] 1> c:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include\vector(537) : see reference to function template instantiation 'void std::vector<_Ty>::insert<_Iter>(std::_Vector_const_iterator<_Ty,_Alloc>,_Iter,_Iter)' being compiled 1> with 1> [ 1> _Ty=boost::shared_ptr<int>, 1> _Iter=std::_Vector_iterator<int *,std::allocator<int *>>, 1> _Alloc=std::allocator<boost::shared_ptr<int>> 1> ] 1> c:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include\vector(514) : see reference to function template instantiation 'void std::vector<_Ty>::_Construct<_Iter>(_Iter,_Iter,std::input_iterator_tag)' being compiled 1> with 1> [ 1> _Ty=boost::shared_ptr<int>, 1> _Iter=std::_Vector_iterator<int *,std::allocator<int *>> 1> ] 1> .\test.cpp(8364) : see reference to function template instantiation 'std::vector<_Ty>::vector<std::_Vector_iterator<int,_Alloc>>(_Iter,_Iter)' being compiled 1> with 1> [ 1> _Ty=boost::shared_ptr<int>, 1> _Alloc=std::allocator<int *>, 1> _Iter=std::_Vector_iterator<int *,std::allocator<int *>> 1> ]
Improve this question
4
  • What error were you getting in VS2008? Commented Jan 24, 2011 at 21:45
  • 2
    @templatetypedef: boost::shared_ptr does not allow implicit construction from raw pointer (because that might hide a change of semantics), so the compiler will consider the types unrelated. Commented Jan 24, 2011 at 21:48
  • @templatetypedef: Added my test stub and errors Commented Jan 24, 2011 at 21:52
  • 1
    Consider using ::std::tr1::shared_ptr if you can. It's nice to avoid dependencies on third party libraries, even ones as spectacular as boost. Commented Jan 24, 2011 at 22:07

5 Answers 5

Reset to default
9

You could use std::transform:

 template <typename T> boost::shared_ptr<T> to_shared_ptr(T * p) { return boost::shared_ptr<T>(p); } vec_b.resize(vec_a.size()); std::transform(vec_a.begin(), vec_a.ebd(), vec_b.begin(), to_shared_ptr);

However, the recommended practice is to assign raw pointers to smart pointers immediately after creation. Having the raw pointers put in a container, then copying them to another another container looks dangerous. YOu need to make sure noone else ever frees these raw pointers. You could emphasize that by vec_a.clear() immediately after the transfer - but that's far from a guarantee.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

I'm working with a legacy API that wants to append to a vector<T*> passed in by reference. I was hoping to make my usage of it slightly safer.
You also need to make sure nobody uses the raw pointers after the smart pointer has freed the memory, just to add to the fun.
@genpfault: I presumed you have a legitimate reason. If the legacy API says "you have to delete them when you are done with them, and I'll never look at them again", you should be fine.
@peterchen: Yep, those are the exact semantics I'm working with.
If you want to use vec_b.begin() as the output iterator, then you need to make space in vec_b first, via the constructor or with resize() not reserve(). If you want to just reserve() (or do nothing), then you need back_inserter(vec_b) as the output iterator.
7

Combine ::std::back_inserter with ::std::transform and a little function that will perform the conversion. If you also use reserve, this should be reasonably efficient. Once all the templates are expanded you will essentially get this code:

template <class T> static inline ::std::tr1::shared_ptr<T> to_shared_ptr(T *val) { return ::std::tr1::shared_ptr<T>(val); } void test() { ::std::vector< int* > vec_a; ::std::vector< ::std::tr1::shared_ptr<int> > vec_b; vec_b.reserve(vec_a.size()); ::std::transform(vec_a.begin(), vec_a.end(), ::std::back_inserter(vec_b), to_shared_ptr<int>); vec_a.clear(); }
Improve this answer

1 Comment

ITYM return ::std::tr1::shared_ptr<T>(val);
7

According to the documentation of Boost shared_ptr, the shared_ptr constructor is marked explicit, meaning that there's no implicit conversion from T*s to shared_ptr<T>. Consequently, when you're trying to insert the iterator range defining your old container into the new container, the compiler complains because there's no way of implicitly converting from the raw pointers of the old containers into the shared_ptrs of the new container. You can fix this by either using a back_inserter and transform, or by just doing the iteration by hand to wrap each pointer and insert it one at a time.

It turns out that there's a good reason that you don't want this conversion to work implicitly. Consider:

void DoSomething(shared_ptr<T> ptr) { /* ... */ } T* ptr = new T(); DoSomething(ptr);

If the implicit conversion were allowed here, then the call to DoSomething would be legal. However, this would cause a new shared_ptr to start referencing the resource held by ptr. This is problematic, because when this shared_ptr goes out of scope when DoSomething returns, it will see that it's the only shared_ptr to the resource and will deallocate it. In other words, calling DoSomething with a raw pointer would implicitly delete the pointer!

Improve this answer

Comments

3

Just because you said for instance, boost::shared_ptr - if the semantics fit you, there is boost::ptr_vector which stores a vector of pointers and is responsible for freeing them when the vector goes out of scope. This container has a transfer method that you could use for taking ownership of the pointers cointained in the vector you get.

Improve this answer

Comments

1

Just use the range constructor like so:

vector<int*> nums = { new int(1), new int(5), new int(10) }; vector<shared_ptr<int>> smart_nums(nums.begin(), nums.end());

Conceptually it is equivalent to:

for (int num : nums) smart_nums.emplace_back(num);

Now with the range constructor, the following is possible:

class Num_container { public: Num_container(vector<int*> nums) : smart_nums(nums.begin(), nums.end()) { } private: vector<shared_ptr<int>> smart_nums; };

This makes dealing with containers of polymorphic types much easier!

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.