时间戳

首页 > 解决方案 > 对象计数器

c++ - 对象计数器

问题描述

我想必须为曾经实例化的每种类类型进行计数器。作为一个起点，有人以这种方法为例：

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 模式，但是当您使用链式继承时这不起作用。

有没有另一种方法来实现这样的计数器？

标签： c++templatesdesign-patterns

解决方案

我只是玩了一下。也许这对你有帮助。它总是打印正确类（而不是基类）的值。

但实际上是一样的^^。

标题：

#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;
}

推荐阅读