C++ c++；设计问题：我可以查询基类以找到满足条件的派生类的数量吗

我有一段这样的代码

class Base
{
public:
Base(bool _active)
{
 active = _active;
}
void Configure();
void Set Active(bool _active);
private: 
bool active;
};
class Derived1 : public Base
{
public:
Derived1(bool active):Base(active){}

};

similarly Derived 2 and Derived 3

现在，如果我调用derived1Object.Configure，我需要检查有多少derived1Object、Derived2Object、derived3Obj处于活动状态。我应该像函数GetNumberOfActive（）那样将其添加到“基类”中吗

如果实施是这样的：

class Imp
{
public:
 void Configure()
 {
  //Code instantiating a particular Derived1/2/3 Object 
  int GetNumberOfActiveDerivedObj();
  baseRef.Configure(int numberOfActiveDerivedClasses);
 }
prive:
Derived1 dObj1(true);
Derived2 dObj2(false);
Derived3 dObj3(true);
};

我应该计算Imp类中活动派生对象的数量吗

---

谢谢一个简单的可能性：

---

NumberOfActive

在

Base

中应该是

static

。每次创建对象时，它都应该递增，并且“活动”为true。

一种简单的可能性：

---

NumberOfActive

在

Base

中应该是

static

。每次创建对象且活动对象为true时，它都应该递增。

在Configure（）方法中，您可以访问派生*对象的工厂，并在Configure（）中获取活动对象的计数方法您可以访问派生*对象的工厂并获取活动对象的计数

您可以将CRTP与静态计数器变量结合使用：

编辑：一些代码

#include <iostream>

template <typename T> struct counter {
    counter() { ++objects_alive; }
    virtual ~counter() { --objects_alive; }
    static int objects_alive;
};
template <typename T> int counter<T>::objects_alive( 0 );


class Base {
public:
    void Configure();
    //more stuff
};

class Derived1 : public Base, counter<Derived1> {
public:
    void Configure() {
        std::cout << "num Derived1 objects: "<< counter<Derived1>::objects_alive << std::endl;
    }
};

class Derived2 : public Base, counter<Derived2> {
public:
    void Configure() {
        std::cout << "num Derived2 objects: " << counter<Derived2>::objects_alive << std::endl;
    }
};

int main (int argc, char* argv[]) {

    Derived1 d10;
    d10.Configure();
    {
        Derived1 d11;
        d11.Configure();
        Derived2 d20;
        d20.Configure();

    }
    Derived1 d12;
    d12.Configure();
    Derived2 d21;
    d21.Configure();


    return 0;
}

---

您可以将CRTP与静态计数器变量结合使用：

编辑：一些代码

#include <iostream>

template <typename T> struct counter {
    counter() { ++objects_alive; }
    virtual ~counter() { --objects_alive; }
    static int objects_alive;
};
template <typename T> int counter<T>::objects_alive( 0 );


class Base {
public:
    void Configure();
    //more stuff
};

class Derived1 : public Base, counter<Derived1> {
public:
    void Configure() {
        std::cout << "num Derived1 objects: "<< counter<Derived1>::objects_alive << std::endl;
    }
};

class Derived2 : public Base, counter<Derived2> {
public:
    void Configure() {
        std::cout << "num Derived2 objects: " << counter<Derived2>::objects_alive << std::endl;
    }
};

int main (int argc, char* argv[]) {

    Derived1 d10;
    d10.Configure();
    {
        Derived1 d11;
        d11.Configure();
        Derived2 d20;
        d20.Configure();

    }
    Derived1 d12;
    d12.Configure();
    Derived2 d21;
    d21.Configure();


    return 0;
}

---

这个想法似乎很合适，但我肯定不会投票支持一家公司。您能添加一个代码示例吗？我不认为需要为计数器添加虚拟析构函数，一个受保护的析构函数就足够了。简单的经验法则是：如果一个基类是要从它的析构函数虚拟化继承的，但该规则有一个后台-对于那些你希望通过指向基类的指针来管理其生存期的类，我看不出这对

计数器

有用。一个受保护的析构函数可以防止人们错误地这么做。这有点过分了，不是吗？在基本构造函数和析构函数中调整一个简单的静态int就可以完成这项工作。当然，这一切都不是线程安全的。这个想法似乎很合适，但我肯定不会投票支持oneliner。您能添加一个代码示例吗？我不认为需要为计数器添加虚拟析构函数，一个受保护的析构函数就足够了。简单的经验法则是：如果一个基类是要从它的析构函数虚拟化继承的，但该规则有一个后台-对于那些你希望通过指向基类的指针来管理其生存期的类，我看不出这对

计数器

有用。一个受保护的析构函数可以防止人们错误地这么做。这有点过分了，不是吗？在基本构造函数和析构函数中调整一个简单的静态int就可以完成这项工作。当然，这些都不是线程安全的。这只会跟踪使用active=true创建的对象，但如果以后更改了active，则不会执行任何操作。此外，您无法区分继承的类对象。这只会跟踪使用active=true创建的对象，但如果以后更改了active，则不会执行任何操作。此外，您无法区分继承的类对象