Existe alguma maneira de fazer todas as classes derivadas contarem suas instâncias? Como (escrever código em um dos C ++, C #, Java)?

Imagine que eu tenho acesso à classe raiz (por exemplo, objeto) e todas as outras classes são (direta ou indiretamente) derivadas dessa classe. O que eu quero é:

AnyDerivedClass.InstancesCount()

O problema é que é necessário acompanhar a contagem na variável estática, mas não é possível "injetar" a variável estática na classe derivada da classe base, isso é válido apenas para variáveis-membro. Ou seja, eu tenho que escrever 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; }
}

Essa funcionalidade é obviamente repetida e não posso colocá-la na classe base. Observe que existem duas maneiras de calcular: se existem 7 instâncias da classe derivada1 e 8 instâncias da classe derivada2, existem (a) 15 instâncias do objeto ou (b) 0 instâncias do objeto. Eu não me importo com qual delas, porque não posso fazer nenhuma (usando meios razoavelmente práticos, por exemplo, imagine 100 classes, metade das quais estão na biblioteca que não posso modificar).

Obviamente, em teoria, é possível criar um mapa de (algum identificador do tipo de execução) => int count e usar uma abordagem feia, lenta, (tipo de tempo de execução) (pelo menos em C #, Java).

Obviamente, se eu posso modificar classes derivadas, posso usar copiar e colar (horrível), macro (sim, eu sei), mixins (não nessas línguas) etc. Mas isso ainda é muito feio.

Esse é um problema específico, mas aconteceu várias vezes que eu gostaria de poder "injetar" um membro estático na classe derivada para resolver o problema de maneira elegante.

Ajuda muito apreciada.

EDIT: obrigado pela boa resposta, em C ++ é possível usar CRTP (padrão de modelo curiosamente recorrente) também, mas não em C # / Java (sem herança múltipla). Obviamente, é preciso ter acesso a classes derivadas e adicionar essa classe base, para que a questão permaneça (caso não exista outra maneira, isso parecerá melhor).

EDIT 2: parece impossível com os idiomas atuais. A parte estática de todas as classes não é herdada (e isso mesmo), mas não há singleton herdado associado a todas as classes; portanto, esses tipos de problemas não podem ser resolvidos de maneira tão elegante. Para ilustrar as coisas, observe o seguinte código: membros normais e membros estáticos são os idiomas atuais do OOP, os membros "singleton" (ou qualquer palavra que seja) são minha sugestão / desejo:

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;

Se algo assim estivesse presente na linguagem, a solução para minha pergunta seria simples e elegante:

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