Singleton et héritage

Voila mon probleme:
J'utilise le template:

template <typename T>
class singleton
{
protected:
 // Constructor/Destructor
 singleton( ) {
 }
 // Supprime l instance de la classe si elle a été crée
 ~singleton( ){
  if( m_pInstance != NULL ){
   delete m_pInstance;
   m_pInstance = 0;
  }
 }

public:
 // renvoie une instance de la classe, la crée si elle n existe pas
 static T *GetInstance( void ){
  if( m_pInstance == NULL ){
   m_pInstance = new T;
  }
  return ((T *)m_pInstance);
 }

private:
 static T *m_pInstance;    // instance unique de la classe

};

template <typename T> T *singleton<T>::m_pInstance = NULL;

J'ai 3 classes:
A, B et C

A singleton
B hérite de A
C utilise le singleton A
Mon probleme est le suivant, lorsque j'initialise B cela crée une classe mere A, qui n'est pas prise en compte pour le m_pInstance. Et du coup, lorsque je récupere A dans C, j'obtiens 2 classes A différentes, au lieu d'une.
Comment faire pour éviter cela?

Le constructeur par defaut de A est appelé quand tu crée un objet B. Tu n'a qu'a mettre ici que c'est le singleton

A::A()
{
  if(m_pInstance)
  {
    // deja une instance, tu fais ce que tu veux ici
  }
  else m_pInstance = this;
}

salut,
tu as un probleme de conception. le constructeur de A devrait etre en private (et tu déclares en friend la class singleton<A>).
Par ce que la il y a un biais dans ton singleton, a savoir qu'il n'est pas le seul a pouvoir creer une instance de A ...
Du coup avec un constructeur de A en private, tu aurais vu que tu peux pas initialiser B ...
Et tu te serais demandé l'interet de faire dériver A en une autre classe ?? tu peu pas utiliser A comme classe de base de deux sous classes, parce que tu auras des problemes d'instances ... Reference un pointeur A* vers ton singleton A dans B, comme tu le fais dans C, et t'auras aucun problème.


a+

vecchio56> ce que tu proposes ne résout pas le problème, si ?

Bah si, on aura jamais deux instances avec ca, puisqu'on controle à la création si une instance est deja présente. C'est vrai que dans le code qu'il donne au debut on a accès au constructeur, donc on peut créer autant d'instances qu'on veut

oui mais si tu crées un objet de type B; sa partie A a des chances d'etre différente de A::GetInstance() (il suffit que cette méthode ait déja été appelée avant de creer un objet B)
Si tu fais ca:
A* ptr = A::GetInstance();
B obj;
A* ptrviaB = &obj;

on voit bien que ptrviaB et ptr sont deux pointeurs vers un objet de type A mais qui est différent (d'ailleurs ils ont trivialement une adresse differente)

donc le probleme demeure ... non?

Ou j'ai écrit // deja une instance, tu fais ce que tu veux ici, j'ai supposé qu'on supprimait l'instance qui existe deja (dans ce cas ton ptr n'existe plus a partir du moment ou on crée B), ou qu'on faisait un exception (B ne peut pas être construit).

Merci pour toutes ces reponses.
En effet l'ordre a une importance, mais ca sembe fonctionner en verifiant les ordres d'appel.