Michele Galante wrote:

...

So I have something like this:

std::vector<boost::shared_ptr<Base> > BaseVector;

void add(boost::shared_ptr<Base>& newOne) { BaseVector.push_back(newOne); }

and I call it like this usually : boost::shared_ptr<Derived> p(new Derived); add(p);

I think the problem is you take a reference to the shared_ptr. Try this way:

void add(boost::shared_ptr<Base> newOne) { BaseVector.push_back(newOne); }

Ah, that seemed to have fixed the problem. Thank you, Joshua.

Konstantin Baumann wrote:

For performance reasons I would like to see something like the following conversion operators in shared_ptr<T>:

template<class T> class shared_ptr { public: ... template<class S> operator shared_ptr<S>&() throw() { BOOST_STATIC_ASSERT(T* is convertible to S*); return reinterpret_cast<shared_ptr<S>&>(*this); }

[...] Right. ;-) There are several things wrong with this code. First, T* convertible to S* does not imply that the memory layout of T* and S* is the same. Specifically, T* and void* may have different representations and sizes. reinterpret_casting a T* to a void*& is not portable. Second, assuming that memory layout is not an issue, there is the classic "nuclear submarine in a car park" type system hole. void f(shared_ptr<void> & p) { p.reset(new float); } int main() { shared_ptr<int> q(new int); // see int, think 'car' f(q); // oops, q now holds a float (nuke sub) } Third, the conversion between T* and S* may change the value of the pointer. In multiple inheritance scenarios (and, depending on the object model, even in some single inheritance cases) an offset is added to T*. With virtual inheritance, it's even more complicated; typically the vtable of the source object of type T is accessed to retrieve the offset to the S virtual base. In short, even though it is no coincidence at all that a shared_ptr<X> is often layout compatible and (somewhat safely) reinterpret_cast'able to shared_ptr<Y>, you need to accept the responsibility for the cast yourself.

--- At Wed, 4 Feb 2004 15:29:50 +0200, Peter Dimov wrote:

Joshua Little wrote: [...]

...

So I have something like this:

std::vector<boost::shared_ptr<Base> > BaseVector;

void add(boost::shared_ptr<Base>& newOne) { BaseVector.push_back(newOne); }

and I call it like this usually : boost::shared_ptr<Derived> p(new Derived); add(p);

I thought that it would work just like using raw pointers (which was working) but I get a compile time error that : no matching function call to add(boost::shared_ptr<Derived>&) canadites are add(boost::shared_ptr<Base>&).. ect.

It should fail with raw pointers, too, unless your compiler is too permissive. The problem is that

void add(boost::shared_ptr<Base>& newOne)

takes a non-const reference to shared_ptr<Base>, so you need a shared_ptr<Base> to call it. Change it to

void add(boost::shared_ptr<Base> const & newOne)

and it should work. And, as a general rule, always use a reference to const when you don't intend to modify the argument.

Peter is quite correct with the change to the argument type. It seems to me the solution could be had another way: boost::shared_ptr<Base> p(new Derived); ---- add(p); Then p is the correct type. The value being added to the vector will be a Base and not a Derived, so you loose nothing by using the shared_ptr as a Base. The only catch would be using Derived "features" between the construction of the shared pointer and the addition to the vector. ...Duane