Singleton class - Vraiment confus

Question

J'essaie d'implémenter une classe Singleton en C++ et je suis un peu confus. Ok, disons que j'ai les 2 classes suivantes:

class Animal { 

public: 
    virtual int age() = 0; 
    virtual void breed() = 0; 
}; 


class Cat : public Animal { 
    public: 
Cat(); 
int age(); 
void breed(); 
};     

plus classes impliquées dans ce système .... (chien, etc poissons)

Maintenant, j'ai une classe singleton que je peux utiliser 1 objet:

class Singleton 
{ 
    public: 
    Animal *newAnimal(string theTypeOfAnimal); 
    private: 
    static Animal* pinstance; 
};       

Animal *Singleton::newAnimal(string theTypeOfAnimal) 
{ 
pinstance = new Cat; 

}   

int main() 
{   
Singleton *s; 
return 0; 
}  

MISE À JOUR:

Nouveau code:

#include <iostream> 
using namespace std; 

class Animal { 

public: 
    virtual int age() = 0; 
    virtual void breed() = 0; 
}; 

class Cat : public Animal 
{ 
public: 
     virtual int age() { return 9; } 
     virtual void breed() { } 

}; 
class Singleton 
{ 
public: 
    Animal *newAnimal(string theTypeOfAnimal); 
    private: 
    static Animal* pinstance; 
}; 

Animal* Singleton::pinstance = 0; 


Animal *Singleton::newAnimal(string theTypeOfAnimal) 
{ 
    this->pinstance = new Cat; 
return pinstance; 
} 

int main(int argc, char *argv[]) { 

Singleton s; 

Animal *myAnimal = NULL; 

Animal *myAnimal = s->newAnimal("cat"); 

}

Answer 1

Vous devez définir l'objet de classe statique en dehors de celui-ci:

Animal* Singleton::pinstance = 0; 

Vous devez définir des fonctions dans Cat classe:

class Cat : public Animal 
{ 
public: 
    Cat() {} 
    int age() { return 7; } 
    void breed() {} 
}; 

Answer 2

Vous devez dériver d'un singleton, et non des cibles cals. Singleton est un motif. Vous pouvez l'implémenter en tant que classe de modèle (habituellement) ou de classe de base à partir de (rare). classique singleton a:

• constructeur privé
• privace copie constructeur
• destructor privé non virtuel
• opérateur privé =
• tient pointeur à l'auto objet
• a fonction ami externe à obtenir l'objet

Il peut:

• ont pas mise en œuvre pour cteur, cctor, dtor et oper =, donc essayer de l'appeler de la classe dérivée conduira à une erreur de liaison
• tirent les enfants privés
• initialisation objet paresseux
• ... quoi que ce soit de plus

Il n'y a pas de consensus sur l'implémentation qui est la meilleure et est Singleton bon ou mauvais. À mon avis singleton est plus nocif que utile pour les débutants. Ne l'utilisez pas tant que vous n'en avez pas besoin dans un endroit particulier.

Comme un désert un mauvais modèle Singleton avec des pointeurs intelligents (trouver des erreurs d'horreur!):

#include <memory> 
#include <boost/noncopyable.hpp> 

template <class T> 
class Singleton : public boost::noncopyable 
{ 
public: 
    static std::shared_ptr<T> Get() 
    { 
     if(m_pSelf.get() == 0) 
      return m_pSelf = std::shared_ptr<T>(new T()); 
     else 
      return m_pSelf; 
    } 


protected: 
    Singleton(){} 
    ~Singleton() {} 

private:  
    static std::shared_ptr<T> m_pSelf; 
}; 

template <class T> std::shared_ptr<T> Singleton<T>::m_pSelf; 

Answer 3

Vous devez définir explicitement votre membre statique: Animal *Singleton::pinstance = nullptr;

static Animal* pinstance intérieur de la classe est juste une déclaration , c'est-à-dire qu'aucun espace réel n'est alloué pour la variable. La raison en est que les membres statiques n'appartiennent pas à un objet spécifique et ne sont pas alloués avec l'instance de la classe d'hébergement. Les membres statiques sont partagés le long de toutes les instances de classe et doivent être alloués explicitement.