contar instancias de clase para cada clase derivada

¿Hay alguna manera de hacer que todas las clases derivadas cuenten sus instancias? ¿Cómo (escribir código en uno de C ++, C #, Java)?

Imagine que tengo acceso a la clase raíz (por ejemplo, objeto), y todas las demás clases se derivan (directa o indirectamente) de esta clase. Lo que quiero es:

AnyDerivedClass.InstancesCount()

El problema es que uno debe realizar un seguimiento del recuento en la variable estática, pero no es posible "inyectar" la variable estática en la clase derivada de la clase base, esto se aplica solo a las variables miembro. Es decir, tengo que escribir algo como:

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

Esta funcionalidad obviamente se repite, y no puedo ponerla en la clase base. Tenga en cuenta que hay 2 formas de calcular: que si hay 7 instancias de la clase derivada1 y 8 instancias de la clase derivada2, hay (a) 15 instancias de objeto o (b) 0 instancias de objeto. No me importa cuál, porque no puedo hacer ninguno de los dos (usando medios razonablemente prácticos, por ejemplo, imagino 100 clases, la mitad de las cuales están en la biblioteca que no puedo modificar).

Por supuesto, en teoría es posible crear un mapa de (algún identificador de tipo de tipo de ejecución) => int count, y usar un enfoque basado en (tipo de tiempo de ejecución) feo, lento (al menos en C #, Java).

Por supuesto, si puedo modificar las clases derivadas, puedo usar copiar-pegar (horrible), macro (sí, lo sé), mixins (no en estos idiomas), etc. Pero eso sigue siendo realmente feo.

Este es un problema específico, pero me sucedió varias veces que me gustaría poder "inyectar" un miembro estático en una clase derivada para resolver el problema con elegancia.

Ayuda muy apreciada.

EDITAR: gracias por una buena respuesta, en C ++ es posiblemente usar CRTP (patrón de plantilla curiosamente recurrente) también, pero no en C # / Java (sin herencia múltiple). Por supuesto, uno debe tener acceso a clases derivadas y agregar esta clase base, por lo que la pregunta permanece (en caso de que no haya otra forma, esto se ve mejor).

EDIT 2: parece imposible con los idiomas actuales. La parte estática de cada clase no está heredando (y eso es correcto), pero no existe un singleton heredado asociado con cada clase, por lo que este tipo de problemas no se pueden resolver con tanta elegancia. Para ilustrar las cosas, mire el siguiente código: los miembros normales y los miembros estáticos son la característica actual de los idiomas OOP, los miembros "singleton" (o cualquier palabra que sea) son mi sugerencia / deseo:

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;

Si algo así estuviera presente en el lenguaje, la solución para mi pregunta sería simple y elegante:

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