destructor privado para clase singleton

Question

Es obligatorio tener un destructor privado para una clase singleton.

Answer 1

esto podría no ser lo que buscas .. Pero para referencia, lo uso de la siguiente manera:

// .h 
class Foo { 
public: 
    static Foo* getInstance(); 
    static void destroy(); 
private: 
    Foo(); 
    ~Foo(); 

    static Foo* myInstance; 
}; 

// .cpp 
Foo* Foo::myInstance = NULL; 

Foo* Foo::getInstance(){ 
    if (!myInstance){ 
     myInstance = new Foo(); 
    } 
    return myInstance; 
} 
void Foo::destroy(){ 
    delete myInstance; 
    myInstance = NULL; 
} 

Luego, al final de mi programa, yo llamo a destruir en el objeto. Como señala Péter, el sistema recuperará la memoria cuando termine su programa, por lo que no existe un motivo real. El motivo por el que uso un destructor es cuando Ogre se quejó de que no había liberado toda la memoria que asigné. Después de eso, simplemente lo uso como "buena manera", ya que me gusta limpiarlo después de mí mismo.

Answer 2

Todas las clases tienen un destructor. Si no creas uno, el compilador lo hará por ti. Entonces su pregunta puede ser reformulada a: ¿El destructor para una clase singleton tiene que ser privado?

La respuesta simple es no, no tiene que ser así.

Una pregunta más interesante: ¿es una buena idea hacer que el destructor de una clase singleton sea privado?

Sí, en general, es una buena idea. Si lo haces privado, tu código de cliente no llamará al destructor por accidente. Llamar al destructor haría que el singleton fallara para todos los clientes ya que la instancia se volvería inválida.

Answer 3

Si el singleton se implementa como una variable en el ámbito global, que debe tener un público destructor . Solo los miembros públicos son accesibles a nivel mundial.

Si se declara como un miembro estático o estático local dentro de su propia clase, a continuación, el destructor puede ser privado. Se llama al destructor desde dentro del alcance de la clase, donde es accesible, cuando el programa sale. Esa es una forma de hacer que el objeto sea un singleton. ¿Necesitas hacer cumplir fuertemente eso? Si es así, sí. Depende de lo que quieras decir con "obligatorio".

class A{ 
private: 
    ~A() {} 
public: 
    static A &getGlobalA() { 
     static A a2; // <- or here - better technique 
     return a2; // this is initialized upon 1st access 
    };    // and destroyed on program exit 

    static A a; // <- constructor, destructor accessed from here 
}; 

A A::a; // <- but "called" from here in terms of control flow 

Answer 4

Usted puede volver referencia a la instancia singleton.

class Factory : public IFactory 
    { 
    private: 
     /** 
     * This class should not be instantiated through its constructor. Since, it implements 
     * Singleton pattern. 
     */ 
     Factory();  
    public: 
     virtual ~Factory(); 
     /** 
     * Accessor method for singleton instance. 
     * \note use this static method to access to operations of this class. 
     */ 
     static IFactory& instance(){ 
      if(!m_instance.get()){ 
       m_instance.reset(new Factory());  
      } 
      return static_cast<IFactory&>(*m_instance); 
     } 
     /** 
     * \see IFactory::create 
     */ 
     virtual boost::shared_ptr<IConnector> create(); 
    private: 
     /* Singleton instance */ 
     static boost::scoped_ptr<Factory> m_instance; 

    }; 

Answer 5

No, y en general los objetos en C++ no reciben destructores privados. Tenga en cuenta que Singleton significa que solo hay una instancia, por lo tanto, es la construcción, no la destrucción, lo que debe controlarse/evitarse. Por lo general, un producto único tiene un constructor privado, un destructor pública, una variable de instancia estática privada, y un conjunto unitario public static obtener/función de la construcción perezoso, aunque hay variaciones sobre ese patrón.

Answer 6

En mi opinión, el destructor de un signleton debe ser privada. De lo contrario, alguien puede llamar a 'eliminar' para su instancia singleton. Lo sé, normalmente nadie lo hará. Pero si hablamos de diseño de excelencia, debe ser resistente a todos los posibles daños previstos o unitnended.

Con la moderna C++ se permite declarar incluso destructores privadas para los objetos construidos de forma estática. Aquí está mi fragmento de código para Singleton:

class Singleton 
{ 
public: 
    static Singleton& GetInstance(); 

    // Before C++ 11 
private: 
    Singleton() {} 
    ~Singleton() {} 

    Singleton(const Singleton&);   // Without implementation 
    Singleton& operator=(const Singleton&); // Without implementation 

    // Since C++ 11 
private: 
    Singleton() = default; 
    ~Singleton() = default; 

public: 
    Singleton(const Singleton&)   = delete; 
    Singleton& operator=(const Singleton&) = delete; 
}; 

Singleton& Singleton::GetInstance() 
{ 
    static Singleton instance; 
    return instance; 
}