privé destructeur de classe singleton

Si le singleton est mis en œuvre comme une variable au niveau global, il doit avoir un public destructeur. Seuls les membres publics sont accessibles à portée globale.

Si elle est déclarée en tant que membre statique ou statique locale au sein de sa propre classe, puis le destructeur peut être privé. Le destructeur est appelé à partir de l'intérieur de portée de classe, où il est accessible, lorsque le programme se termine. C'est une manière d'appliquer l'objet d'un singleton. Avez-vous besoin d'fortement de la faire respecter? Si oui, oui. Cela dépend de ce que tu veux dire par "obligatoire."

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

OriginalL'auteur Potatoswatter

À mon avis, le destructeur d'une signleton doit être privé. Sinon somewone est en mesure d'appeler "supprimer" pour votre instance du singleton. Je sais, normalement, personne ne le fera. Mais si nous parlons de l'excellence de la conception, il doit être résistant à tous les possibles prévu ou unitnended dommages.

Avec le C++ moderne, il est permis de déclarer, même privé destructeurs pour la statique des objets construits.
Voici mon extrait de code pour 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;
}

OriginalL'auteur Vadim Sukhorukov

Vous pouvez retourner référence à votre instance du 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;

    };

OriginalL'auteur baris.aydinoz