 <p>According to <a href="http://www.boost.org/doc/libs/1_45_0/libs/smart_ptr/shared_ptr.htm">the documentation of Boost <code>shared_ptr</code></a>, the <code>shared_ptr</code> constructor is marked <code>explicit</code>, meaning that there's no implicit conversion from <code>T*</code>s to <code>shared_ptr&lt;T&gt;</code>. 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 <code>shared_ptr</code>s of the new container. You can fix this by either using a <code>back_inserter</code> and <code>transform</code>, or by just doing the iteration by hand to wrap each pointer and insert it one at a time.</p> <p>It turns out that there's a good reason that you don't want this conversion to work implicitly. Consider:</p> <pre><code>void DoSomething(shared_ptr&lt;T&gt; ptr) { /* ... */ } T* ptr = new T(); DoSomething(ptr); </code></pre> <p>If the implicit conversion were allowed here, then the call to <code>DoSomething</code> would be legal. However, this would cause a new <code>shared_ptr</code> to start referencing the resource held by <code>ptr</code>. This is problematic, because when this <code>shared_ptr</code> goes out of scope when <code>DoSomething</code> returns, it will see that it's the only <code>shared_ptr</code> to the resource and will deallocate it. In other words, calling <code>DoSomething</code> with a raw pointer would implicitly delete the pointer!</p>