How to manage shared object lifetimes with static casts?

Question

I am new to C++ style casts, and need help in understanding how the code below works (this is some dummy code I wrote to understand things).

#include <iostream>
#include <memory>

class A { 
public:
    A() : a(1) {
        std::cout << "Creating A\n";
    }   
    ~A() {
        std::cout << "Destroying A\n";
    }   
    int a;
};

class B : public A { 
public:
    B() : b(2) {
        std::cout << "Creating B\n";
    }   
    ~B() {
        std::cout << "Destroying B\n";
    }   
    int b;
};

int main() {
    std::shared_ptr<B> objectB(new B());
    {   
    std::shared_ptr<A> (static_cast<A*>(objectB.get()));
    std::cout << "End of inner scope\n";
    }   
    std::cout << "End of outer scope\n";
}

It prints

Creating A
Creating B
Destroying A
End of inner scope
End of outer scope
Destroying B
Destroying A

My understanding:

Creating A         -> B's ctor calls base class ctor
Creating B         -> B's ctor
Destroying A       -> ???
End of inner scope
End of outer scope
Destroying B       -> B's dtor
Destroying A       -> B's dtor calls base dtor

Why do I get the first Destroying A and what exactly is happening here?! How can A be destroyed twice?

This is not a full answer, but you have two independent shared pointers pointing to the same thing. So at some point there will be more than one attempt to free the managed object, which is undefined behaviour. Also, try to flush the stdout buffer by using `std::endl` instead of just `\n`. — juanchopanza, Jul 08 '13 at 06:35
I think your point about undefined behavior makes sense, although I am still trying to find a reference to this. I know `endl` might help in flushing, but it doesn't change the order. — Lazer, Jul 08 '13 at 06:41
@Lazer: it *is* UB to delete the same object more than once (maybe searching for *double-delete* will be easier to find?), which is what happens in your code. Also, you should use a virtual destructor in the base class to ensure derived objects get properly cleaned up when deleted through a base class pointer. — syam, Jul 08 '13 at 06:44

score 6 · Accepted Answer · edited Jun 20 '20 at 09:12

6

If you make sure the output is flushed (by using std::endl, for example), you get

Creating A

Creating B

Destroying A

End of inner scope

End of outer scope

Destroying B

Destroying A

the reason for the double delete of A is that you are constructing a shared_ptr from a raw pointer here:

std::shared_ptr<A> (static_cast<A*>(objectB.get()));

This shared_ptr is completely independent of the first one, and has its own reference count. So when the scope ends, it attempts to delete the A pointer it holds. If you had done this instead:

std::shared_ptr<A>{objectB};

then you wouldn't have encountered the problem. Note there is no need for a static_cast here.

Note that A should have a virtual destructor. shared_ptr has a clever destruction mechanism which means that this is not crucial in this example, but in general, if you are going to delete objects polymorphically, the base class must have a virtual destructor.

edited Jun 20 '20 at 09:12

Community

1
1

answered Jul 08 '13 at 06:46

juanchopanza

223,364
34
402
480

Also, because you don't have virtual destructors on `A` or `B`, the wrong type of destructor gets called. – Joe Z Jul 08 '13 at 06:49
@JoeZ Right, although `shared_ptr` is a bit special about this. I added a note about it. – juanchopanza Jul 08 '13 at 06:51
What does the `{}` syntax mean? Does it call the constructor in some special way? – Lazer Jul 08 '13 at 07:00
@Lazer No, in this case it just calls the constructor. There is nothing special about it, except that it can never be parsed as a function declaration, unlike the `()` equivalents. Look up "C++11 uniform initialization". – juanchopanza Jul 08 '13 at 07:03
Thanks, one last thing, if I don't need `objectB`, is it safe to do `std::shared_ptr objectA(new B());`? – Lazer Jul 08 '13 at 07:05
@Lazer yes, it is safe. But give `A` a virtual destructor. – juanchopanza Jul 08 '13 at 07:22

bames53 · Answer 2 · 2013-07-08T15:53:04.330

Just in case it wasn't clear from juanchopanza's answer, this line

std::shared_ptr<A> (static_cast<A*>(objectB.get()));

is incorrect and leads to undefined behavior.

The shared pointer you construct here just takes the pointer you give it. It has no idea that the object pointed to by that pointer is already owned by another smart pointer. Furthermore it doesn't know that the pointer points to a sub-object and that the pointer will need to be cast back to B* in order to be deleted, because the static_cast hides that information from it.

To cast smart pointers you need a cast that understands and is integrated with smart pointers. C++ has std::static_pointer_cast and std::dynamic_pointer_cast for this purpose.

int main() {
  std::shared_ptr<B> objectB(new B());
  {   
    std::shared_ptr<A> x = std::static_pointer_cast<A>(objectB);
    std::cout << "End of inner scope\n";
  }   
  std::cout << "End of outer scope\n";
}

With this code the output of your program shows correct behavior:

make A
make B
End of inner scope
End of outer scope
~B
~A

Of course in this particular case you don't need an explicit cast, because std::shared_ptr can figure out legal up-casts and do them implicitly. You need std::static_pointer_cast to do down-casts though:

int main() {
  std::shared_ptr<A> objectA(new B());
  {   
    std::shared_ptr<B> x = std::static_pointer_cast<B>(objectA);
    std::cout << "End of inner scope\n";
  }   
  std::cout << "End of outer scope\n";
}

Thanks, one last thing, if I don't need objectB, is it safe to do std::shared_ptr<A> objectA(new B());?

Yes, this does happen to be safe. The shared_ptr<A> constructor receives a B* and knows enough to store the fact that when deletion occurs it will need to convert the A* that it holds to B*. This ensures that the object gets deleted correctly.

However, if you really want your types A and B to behave polymorphically then you should probably just make them polymorphic types by adding virtual destructors, and then you don't have to worry about how smart std::shared_ptr is about this.

How to manage shared object lifetimes with static casts?

2 Answers2