How is it possible (if it is) to implement shared_ptr without requiring polymorphic classes to have virtual destructor?

Question

Mr. Lidström and I had an argument :)

Mr. Lidström's claim is that a construct shared_ptr<Base> p(new Derived); doesn't require Base to have a virtual destructor:

Armen Tsirunyan: "Really? Will the shared_ptr clean up correctly? Could you please in this case demonstrate how that effect could be implemented?"

Daniel Lidström: "The shared_ptr uses its own destructor to delete the Concrete instance. This is known as RAII within the C++ community. My advice is that you learn all you can about RAII. It will make your C++ coding so much easier when you use RAII in all situations."

Armen Tsirunyan: "I know about RAII, and I also know that eventually the shared_ptr destructor may delete the stored px when pn reaches 0. But if px had static type pointer to Base and dynamic type pointer to Derived, then unless Base has a virtual destructor, this will result in undefined behavior. Correct me if I am wrong."

Daniel Lidström: "The shared_ptr knows the static type is Concrete. It knows this since I passed it in its constructor! Seems a bit like magic, but I can assure you it is by design and extremely nice."

So, judge us. How is it possible (if it is) to implement shared_ptr without requiring polymorphic classes to have virtual destructor?

Carr

You could've linked to the original thread. – Leukas

Another interesting thing is that shared_ptr<void> p(new Derived) will also destroy the Derived object by it's destructor, regardless if it is virtual or not. – Walkthrough

Awesome way of asking a question :) – Oviduct

Even though shared_ptr allows this, it's a really bad idea to design a class as a base without a virtual dtor. Daniel's comments about RAII are misleading—it has nothing to do with this—but the quoted conversation sounds like a simple miscommunication (and incorrect assumption of how shared_ptr works). – Cannell

as far as I remember, this is explained in channel9.msdn.com/shows/Going+Deep/… – Libratory

Not RAII, but rather it type-erases the destructor. You have to be careful, because shared_ptr<T>( (T*)new U() ) where struct U:T won't do the right thing (and this can be done indirectly easily, such as a function that takes a T* and is passed a U*) – Catkin

RTFM: This constructor is a template in order to remember the actual pointer type passed. The destructor will call delete with the same pointer, complete with its original type, even when T does not have a virtual destructor, or is void. – Telegonus

@JonathanWakely: Great quote! As I understand, this question regards the C++ Standard Library (std::shared_ptr), but it draws liberally from Boost. Thus, sellibitze's answer says: Boost does and the upcoming standard also requires this behaviour. – Beera

Wow this question was asked on 10/10/10 at (almost) 10:00. – Tatianatatianas

Answer 1

Yes, it is possible to implement shared_ptr that way. Boost does and the C++11 standard also requires this behaviour. As an added flexibility shared_ptr manages more than just a reference counter. A so-called deleter is usually put into the same memory block that also contains the reference counters. But the fun part is that the type of this deleter is not part of the shared_ptr type. This is called "type erasure" and is basically the same technique used for implementing the "polymorphic functions" boost::function or std::function for hiding the actual functor's type. To make your example work, we need a templated constructor:

template<class T>
class shared_ptr
{
public:
   ...
   template<class Y>
   explicit shared_ptr(Y* p);
   ...
};

So, if you use this with your classes Base and Derived ...

class Base {};
class Derived : public Base {};

int main() {
   shared_ptr<Base> sp (new Derived);
}

... the templated constructor with Y=Derived is used to construct the shared_ptr object. The constructor has thus the chance to create the appropriate deleter object and reference counters and stores a pointer to this control block as a data member. If the reference counter reaches zero, the previously created and Derived-aware deleter will be used to dispose of the object.

The C++11 standard has the following to say about this constructor (20.7.2.2.1):

Requires: p must be convertible to T*. Y shall be a complete type. The expression delete p shall be well formed, shall have well defined behaviour and shall not throw exceptions.

Effects: Constructs a shared_ptr object that owns the pointer p.

…

And for the destructor (20.7.2.2.2):

Effects: If *this is empty or shares ownership with another shared_ptr instance (use_count() > 1), there are no side effects. Otherwise, if *this owns an object p and a deleter d, d(p) is called. Otherwise, if *this owns a pointer p, and delete p is called.

(emphasis using bold font is mine).

Task

the upcoming standard also requires this behaviour: (a) Which standard and (b) can you please provide a reference (to the standard)? – Beera

I just want to add a comment to @Task 's answer since I don't have enough points to add a comment. IMO, it is more Boost does this than the Standard requires. I don't think the Standard requires that from what I am understanding. Talking about @Task 's example shared_ptr<Base> sp (new Derived);, Requires of constructor just ask for delete Derived being well defined and well formed. For the specification of destructor, there is also a p, but I don't think it refers to the p in the specification of constructor. – Solicitor

Answer 2

When shared_ptr is created it stores a deleter object inside itself. This object is called when the shared_ptr is about to free the pointed resource. Since you know how to destroy the resource at the point of construction you can use shared_ptr even with incomplete types. Whoever created the shared_ptr has already stored a correct deleter there.

For example, you can create a custom deleter:

void DeleteDerived(Derived* d) { delete d; }
shared_ptr<Base> p(new Derived, DeleteDerived);

p will call DeleteDerived to destroy the pointed object.

This is what the shared_ptr constructor does automatically, so in practice you don't need to implement that sort of a deleter unless you free by means other than a call to delete.

Absenteeism

+1 for the remark about incomplete types, very handy when using a shared_ptr as an attribute. – Percentage

Answer 3

Simply,

shared_ptr uses special deleter function that is created by constructor that always uses the destructor of the given object and not the destructor of Base, this is a bit of work with template meta programming, but it works.

Something like that

template<typename SomeType>
shared_ptr(SomeType *p)
{
   this->destroyer = destroyer_function<SomeType>(p);
   ...
}

Burtburta

hmm... interesting, I am starting to believe this :) – Carr

@Armen Tsirunyan You should have peeked into the design description of the shared_ptr before starting the discusson. This 'capture of the deleter' is one of the essential features of shared_ptr... – Aun

@paul_71: I agree with you. On the other hand I believe this discussion was useful not only for me, but also for other people that didn't know this fact about the shared_ptr. So I guess it was not a great sin to start this thread anyway :) – Carr

@Armen Of course not. Rather, you did a good job in pointing to this really very very important feature of shared_ptr<T> which is frequently overseen even by experienced c++ developers. – Aun