Счетчики объектов

Question

Я хотел бы иметь счетчики для каждого типа класса, который когда-либо создавался. В качестве отправной точки кто-то предложил этот подход в качестве примера:

class Person
{
public:
    Person() {
        objects.push_back(this);
    }
    virtual ~Person() {
        objects.erase(this);
    }

static void print_types()
{
    for (auto pers : container)
    {
        std::cout << typeid(*pers).name() << "\n";
    }
}
private:
    static std::set<const Person*> objects;
};

class Employee : public Person
{
};


class Employee2 : public Employee
{
};

Каждый раз, когда создается один из классов, я отслеживаю объекты и могу использовать print_types (), чтобы узнать, сколько из какого типа я создал до сих пор. Обратите внимание, что Employee2 наследуется от Employee, а не от Person (мне нужно, чтобы это работало для цепного наследования)

Я бы хотел расширить это, чтобы у меня было два счетчика для каждого типа: созданный и живой. Проблема в том, что вы не можете легко управлять счетчиками из конструктора / деструктора базового класса Person, потому что typeid (* this) будет возвращать тип базового класса при вызове из конструктора / деструктора.

Другим предложением было использование шаблона CRTP, но это не работает, когда вы используете цепочечное наследование.

Есть ли другой способ реализовать такие счетчики?

Answer 1

Я просто немного поиграл.Может быть, это поможет вам.Он всегда печатает значение правильного класса (не базового класса).

Но это практически то же самое ^^.

Заголовок:

#include <set>
#include <string>

class observeable;
class observer
{
public:
  observer() = delete;
  static void print();
  static std::set< observeable* > items;
};

class observeable
{
public:
  observeable();
  virtual ~observeable();
  virtual std::string get_typeid();
};

Источник:

std::set< observeable* > observer::items;

void observer::print()
{
  std::cout << "Called" << std::endl;
  for( auto item : items )
    std::cout << item->get_typeid() << std::endl;
}

observeable::observeable()
{
  observer::items.insert( this );
}

observeable::~observeable()
{
  observer::items.erase( this );
}

std::string observeable::get_typeid()
{
  return std::string( typeid(*this).name() );
}

Основной:

#include <memory>

class A : observeable
{};

class B : A
{};

class C : observeable 
{};

int main()
{
  A a;
  B b;
  observer::print(); // A B present

  {
    C d;
  }
  observer::print(); // no C present

  auto d_heap = std::shared_ptr<C>( new C() );
  observer::print(); // C present
  return 0;
}