计算每个派生类的类实例

有没有办法让所有派生类计算它们的实例？如何（用 C++、C#、Java 之一编写代码）？

想象一下，我可以访问根类（例如对象），并且每个其他类都是（直接或间接）从该类派生的。我想要的是：

AnyDerivedClass.InstancesCount()

问题是，必须跟踪静态变量中的计数，但不可能将静态变量从基类“注入”到派生类中，这仅适用于成员变量。 也就是说，我必须写这样的东西：

class object 
{ 
 private static int count = 0; 
 protected object() { ++count; }
 protected ~object() { --count; } 
 public static InstancesCount() { return count; } 
};

class derived : object 
{
 private static int count = 0;
 public derived() { ++count; }
 public ~derived() { --count; }
 public static InstancesCount() { return count; }
}

这个功能显然是重复的，我不能把它放在基类中。 请注意，有 2 种计算方法：如果有 7 个类导出 1 的实例和 8 个类导出 2 的实例，则有 (a) 15 个对象实例或 (b) 0 个对象实例。我不在乎是哪一个，因为我两者都不能做（使用相当实用的方法，例如想象 100 个类，其中一半在我无法修改的库中）。

当然，理论上可以创建（某些运行类型类型标识符）=> int count 的映射，并使用丑陋、缓慢、基于（运行时类型）的方法（至少在 C#、Java 中）。

当然，如果我可以修改派生类，我可以使用复制粘贴（糟糕）、宏（是的，我知道）、mixins（不在这些语言中）等。但这仍然很丑陋。

这是特定的问题，但它发生在我身上好几次，我希望能够将静态成员“注入”到派生类中以优雅地解决问题。

非常感谢帮助。

编辑：感谢您的良好回答，在 C++ 中也可以使用 CRTP（奇怪的重复模板模式），但不能在 C#/Java 中使用（没有多重继承）。当然，必须有权访问派生类并添加此基类，因此问题仍然存在（如果没有其他方法，这看起来是最好的）。

编辑2：对于当前的语言来说看起来不可能。每个类的静态部分都不是继承的（这是正确的），但是没有与每个类关联的继承单例，因此此类问题无法如此优雅地解决。 为了说明问题，请查看以下代码：普通成员和静态成员是当前 OOP 语言功能，“单例”（或任何单词）成员是我的建议/愿望：

class Base
{
    static int sMemberBase;
    int memberBase;

    //my wish (note that virtual for methods is allowed!):
    singleton int singletonMemberBase;
};
class Derived : Base
{
    static int sMemberDerived;
    int memberDerived;

    //my wish (note that virtual for methods is allowed!):
    singleton int singletonMemberDerived;
};

//taken apart: (note: XYZStatic classes do not derive)
class Base { int memberBase; }
class BaseStatic { int sMemberBase; } BaseStaticInstance;
class Derived : Base { int memberDerived; }
class DerivedStatic { int sMemberDerived;  } BaseStaticInstance;
//note: Derived::sMemberBase is compile-time changed to Base::sMemberBase

//my wish: (note inheritance!)
class BaseSingleton { int singletonMemberBase; } BaseSingletonInstance;
class DerivedSingleton : BaseSingleton { int singletonMemberDerived; } DerivedSingletonInstance;

如果语言中存在类似的东西，我的问题的解决方案将是简单而优雅的：

//with singleton members, I could write counter like this:
class object
{
    singleton int count;
    object() { ++count; }
    ~object() { --count; }
};

在 C++ 中，您可以使用模板基类来完成此操作。基本上是这样is一个 mixin，因此它仍然需要每个类通过继承 mixin 来进行协作：

// warning: not thread-safe
template <typename T>
class instance_counter {
  public:
    static size_t InstancesCount() { return count(); }
    instance_counter() { count() += 1; }
    instance_counter(const instance_counter&) { count() += 1; }
    // rare case where we don't need to implement the copy assignment operator.
  protected:
    ~instance_counter() { count() -= 1; }
  private:
    static size_t &count {
        static size_t counter = 0;
        return counter;
    }
};

class my_class: public instance_counter<my_class> {};

由于使用模板的每个类都有一个不同的基类，它有一个不同的 count函数，因此静态变量的不同副本counter.

从使用派生类作为模板参数实例化的模板类继承的技巧称为 CRTP。