计算每个派生类的类实例

Question

有没有办法让所有派生类计算它们的实例？如何（用 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; }
}

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

当然，理论上可以创建 (some run-type type identifier) => int count 的映射，并使用丑陋、缓慢、基于 (run-time type) 的方法（至少在 C#、Java 中） )。

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

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

非常感谢您的帮助。

编辑：感谢您的好回答，在 C++ 中也可能使用 CRTP（Curiously recurring template pattern），但在 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; }
};

Answer 1

在 .Net 中，可以使用泛型来实现这一点。由于type erasure，以下技术在 Java 中将不起作用。

public static class InstanceCounter<T>
{
    private static int _counter;

    public static int Count { get { return _counter; }}

    public static void Increase()
    {
        _counter++;
    }

    public static void Decrease()
    {
        _counter--;
    }
}

现在在您的类中，无论是基类还是子类，按如下方式使用：

public class SomeClass
{
    public SomeClass()
    {
        InstanceCounter<SomeClass>.Increase();        
    }

    ~SomeClass()
    {
        InstanceCounter<SomeClass>.Decrease();
    }
}

您也不必在每个类中都包含实例计数属性，它仅在 InstanceCounter 类中需要。

int someClassCount = InstanceCounter<SomeClass>.Count;

注意：此示例不需要类来继承实例计数器类。

如果一个人有能力在 .Net 中消除一个超类的限制，那么以下方法也可以：

public class InstanceCounter<T>
{
    private static int _counter;

    public static int Count { get { return _counter; }}

    protected InstanceCounter<T>()
    {
        _counter++;
    }

    ~InstanceCounter<T>()
    {
        _counter--;
    }
}

public class SomeClass : InstanceCounter<SomeClass>
{
}

然后检索计数：

int someClassCount = InstanceCounter<SomeClass>.Count;

或

int someClassCount = SomeClass.Count;

注意2：在cmets中提到，使用终结器（~SomeClass）很慢，只有当实例被GC实际收集时才会减少计数器。为了解决这个问题，必须引入实例的确定性“释放”，例如实现IDisposable。

Answer 2

立即在我脑海中闪现的 C# 方式：

class A : IDisposable
{
    static Dictionary<Type, int> _typeCounts = new Dictionary<Type, int>();
    private bool _disposed = false;

    public static int GetCount<T>() where T:A
    {
        if (!_typeCounts.ContainsKey(typeof(T))) return 0;

        return _typeCounts[typeof(T)];
    }

    public A()
    {
        Increment();
    }

    private void Increment()
    {
        var type = this.GetType();
        if (!_typeCounts.ContainsKey(type)) _typeCounts[type] = 0;
        _typeCounts[type]++;
    }

    private void Decrement()
    {
        var type = this.GetType();
        _typeCounts[type]--;            
    }

    ~A()
    {
        if (!_disposed) Decrement();
    }

    public void Dispose()
    {
        _disposed = true;
        Decrement();
    }
}

class B : A
{

}

以及如何使用它：

        A a1 = new A();
        Console.WriteLine(A.GetCount<A>());
        A a2 = new A();
        Console.WriteLine(A.GetCount<A>());            

        using(B b1 = new B())
        {
            Console.WriteLine(B.GetCount<B>());
        }
        Console.WriteLine(B.GetCount<B>());

输出可能会有所不同。它不是纯 OOP，也不是该线程中的 C++ 或 Java 示例。但是继承类不需要一点代码。

别忘了正确处理你的对象！！

Answer 3

在 Java 中，您可以使用全局 Multiset：

import com.google.common.collect.ConcurrentHashMultiset;

public abstract class InstanceCounted {

    protected InstanceCounted() {
        COUNT_MAP.add(this.getClass());
    }

    protected static final ConcurrentHashMultiset<Class<? extends InstanceCounted>> COUNT_MAP =
        ConcurrentHashMultiset.create();

}

如果您不想依赖 guava，也可以使用 Map<Class, Integer>。

注意：这只跟踪实例创建，而不是垃圾回收，因此计数永远不会减少。如果您愿意降低性能，也可以使用PhantomReferences 跟踪收集：

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;

import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
import com.google.common.collect.Multimaps;

public abstract class InstanceCounted {

    public static int getInstanceCount(Class<? extends InstanceCounted> clazz) {
        reap();
        return INSTANCES.get(clazz).size();
    }

    protected InstanceCounted() {
        reap();
        INSTANCES.put(getClass(), new CountingReference(this));
    }

    static final Multimap<Class<? extends InstanceCounted>, CountingReference> INSTANCES =
        Multimaps.synchronizedSetMultimap(HashMultimap.<Class<? extends InstanceCounted>, CountingReference>create());

    static final ReferenceQueue<InstanceCounted> QUEUE =
        new ReferenceQueue<InstanceCounted>();

    private static void reap() {
        Reference<? extends InstanceCounted> ref;
        while ((ref = QUEUE.poll()) != null) {
            ((CountingReference) ref).clear();
        }
    }

    private static class CountingReference extends PhantomReference<InstanceCounted> {

        public void clear() {
            super.clear();
            INSTANCES.remove(clazz, this);
        }

        CountingReference(InstanceCounted instance) {
            super(instance, QUEUE);
            this.clazz = instance.getClass();
        }

        private final Class<? extends InstanceCounted> clazz;

    }

}

Answer 4

我会使用模板。顺便说一下，这是用 C++ 编写的。

template<typename T> class object {
private:
    static int count;
public:
    object() { count++; }
    object(const object&) { count++; }
    ~object() { count--; }
    static int GetCount() { return count; }
};
template<typename T> int object<T>::count = 0;

RTTI 解决方案：

class object {
    static std::map<std::string, int> counts;
public:
    object() { counts[typeid(*this).name()]++; }
    object(const object&) { counts[typeid(*this).name()]++; }
    ~object() { counts[typeid(*this).name()]--; }
    template<typename T> int GetObjectsOfType() {
        return counts[typeid(T).name()];
    }
    int GetObjectsOfType(std::string type) {
        return counts[type];
    }
};
std::map<std::string, int> object::counts;

RTTI 侵入性较小，允许在运行时选择要查询的类型，但模板的开销要少得多，您可以使用它单独计算每个派生类，而 RTTI 只能单独计算最多派生类。

Answer 5

令我震惊的是，如果您真的希望注入的/任何类真正做一些有用的事情，那么您必须以某种方式将它与原始类耦合，无论是通过继承还是直接耦合与方法调用。否则你只是有两个独立旋转的轮子。

我能想到的唯一替代方法是使用可以为您计算创建的工厂模式 - 但您必须破解一些东西来计算递减，例如明确地将对象交回工厂。

Answer 6

在 Java 中，您可以对 hiracy 的公共超类实现计数功能。

这个基类包含一个 Map - 将类与实例的数量相关联。 如果创建了基类或其子类之一的实例，则调用构造函数。 构造函数增加concreate类的实例数。

import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicInteger;

public class Base {

    /** Threadsave counter */
    private static final ConcurrentMap<Class<? extends Base>, AtomicInteger>
       instancesByClass 
       = new ConcurrentHashMap<Class<? extends Base>, AtomicInteger>(
            10);

    /** The only one constructor of base */
    public Base() {
        Class<? extends Base> concreateClass = this.getClass();
        AtomicInteger oldValue = instancesByClass.putIfAbsent(concreateClass,
                new AtomicInteger(1));
        if (oldValue != null) {
            oldValue.incrementAndGet();
        }
    }

    /* DEMO starts here */
    public static class SubA extends Base{
    }

    public static class SubB extends Base{
    }

    public static class SubSubA extends SubA{
    }


    public static void main(String[] args) {
        printNumbers();
        new SubA();
        new SubA();

        new SubB();

        new SubSubA();

        printNumbers();
    }

    private static void printNumbers() {
        // not thread save!
        for (Entry<Class<? extends Base>, AtomicInteger> item : instancesByClass
                .entrySet()) {
            System.out.println(item.getKey().getName() + "  :  "
                    + item.getValue());
        }
    }
}

Answer 7

在 C++ 中，您可以使用模板基类来实现。基本上它是一个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。