C++ shared pointers of parent-children classes

Question

I have a scenario in which I need to collect all the objects of a type in a collection, but I also need a collection of some of its inherited types. Example:

class Particle: public someClass
{
    ...
    public:
        static std::vector<std::shared_ptr<Particle>> particleCollection;
}

class ChargedParticle: public Particle
{
    ...
    public:
    static std::vector<std::shared_ptr<ChargedParticle>> chargedParticleCollection;
}

However when I want to destroy these objects, I actually call the destructor twice for every ChargedPartice:

Particle::particleCollection.clear(); // Okay
ChargedParticle::chargedParticleCollection.clear(); // Error: particles are already deleted

How can I both have a collection of the child objects stored in its static container and have smart pointers pointing on them by one of their parent classes?

I want to be able to create objects from the parent class too, and have the parent's static smart pointer vector be the owner of these objects.

My idea is that I somehow define a custom deleter for the parent class smart pointers that only calls the destructor, when the object is not an element of the child class' collection. Is this possible?

Answer 1

Every ChargedParticle is at the same time is a Particle so calling Particle::particleCollection.clear(); would be enough to remove all allocated objects.

To use shared pointer in your case you need to have base class (either someClass or Particle) to be inherited from std:: enable_shared_from_this thus shared pointer created from it will share the same counter. In your example these are two different instances of shared pointer that know nothing about each other.

And I don't see any reason for virtual destructor to not be enough for your needs.

Answer 2

If you use it properly, there's no problem, class's name is not the same with your class name, but I don't think it matters:

#include <iostream>
#include <type_traits>
#include <tuple>
#include <vector>
#include <memory>
struct Base
{
    Base() { std::cout << "  Base::Base()\n"; }
    // Note: non-virtual destructor is OK here
    ~Base() { std::cout << "  Base::~Base()\n"; }
};

struct Derived: public Base
{
    Derived() { std::cout << "  Derived::Derived()\n"; }
    ~Derived() { std::cout << "  Derived::~Derived()\n"; }
};

int main() {  
    std::vector<std::shared_ptr<Base>> base_vector;
    std::vector<std::shared_ptr<Derived>> derived_vector;
    auto d = std::make_shared<Derived>();
    derived_vector.push_back(d);
    base_vector.push_back(d);
    // 2 function call below does not matter
    base_vector.clear();
    derived_vector.clear();

}

Demo is expanded from example in Cpp Reference

You can't create a self-registering class with std::shared_ptr because you need to inherit from std::enable_shared_from_this, but you can't call shared_from_this() in the constructor because:

It is permitted to call shared_from_this only on a previously shared object, i.e. on an object managed by std::shared_ptr. Otherwise the behavior is undefined (until C++17)std::bad_weak_ptr is thrown (by the shared_ptr constructor from a default-constructed weak_this) (since C++17).