C++-Singleton-Entwurfsmuster

Question 1

Kürzlich bin ich auf eine Realisierung/Implementierung des Singleton-Entwurfsmusters für C++ gestoßen. Es hat so ausgesehen (ich habe es aus dem realen Beispiel übernommen):

// a lot of methods are omitted here
class Singleton
{
   public:
       static Singleton* getInstance( );
       ~Singleton( );
   private:
       Singleton( );
       static Singleton* instance;
};

Aus dieser Deklaration kann ich ableiten, dass das Instanzfeld auf dem Heap initiiert wird. Das heißt, es gibt eine Speicherzuweisung. Was mir völlig unklar ist, ist, wann genau der Speicher freigegeben wird? Oder gibt es einen Fehler und ein Speicherleck? Es scheint ein Problem mit der Implementierung zu geben.

Meine Hauptfrage ist, wie setze ich es richtig um?

Question 2

2008 habe ich eine C++98-Implementierung des Singleton-Entwurfsmusters bereitgestellt, die lazy-evaluiert, garantiert zerstört und technisch nicht Thread-sicher ist:
Kann mir jemand ein Beispiel für Singleton in c++ geben?

Hier ist eine aktualisierte C++11-Implementierung des Singleton-Entwurfsmusters, das verzögert ausgewertet, korrekt zerstört und Thread-sicher ist.

class S
{
    public:
        static S& getInstance()
        {
            static S    instance; // Guaranteed to be destroyed.
                                  // Instantiated on first use.
            return instance;
        }
    private:
        S() {}                    // Constructor? (the {} brackets) are needed here.

        // C++ 03
        // ========
        // Don't forget to declare these two. You want to make sure they
        // are inaccessible(especially from outside), otherwise, you may accidentally get copies of
        // your singleton appearing.
        S(S const&);              // Don't Implement
        void operator=(S const&); // Don't implement

        // C++ 11
        // =======
        // We can use the better technique of deleting the methods
        // we don't want.
    public:
        S(S const&)               = delete;
        void operator=(S const&)  = delete;

        // Note: Scott Meyers mentions in his Effective Modern
        //       C++ book, that deleted functions should generally
        //       be public as it results in better error messages
        //       due to the compilers behavior to check accessibility
        //       before deleted status
};

Siehe diesen Artikel darüber, wann ein Singleton verwendet wird: (nicht oft)
Singleton: Wie sollte es verwendet werden

Siehe diese beiden Artikel über die Initialisierungsreihenfolge und wie man damit umgeht:
Initialisierungsreihenfolge statischer Variablen
Probleme mit der statischen Initialisierungsreihenfolge von C++ finden

Siehe diesen Artikel, der Lebensdauern beschreibt:
Was ist die Lebensdauer einer statischen Variablen in einer C++-Funktion?

Sehen Sie sich diesen Artikel an, in dem einige Threading-Auswirkungen auf Singletons erörtert werden:
Singleton-Instanz, die als statische Variable der GetInstance-Methode deklariert ist, ist sie Thread-sicher?

Lesen Sie diesen Artikel, der erklärt, warum doppelt geprüfte Sperren in C++ nicht funktionieren:
Was sind all die allgemeinen undefinierten Verhaltensweisen, die ein C++-Programmierer kennen sollte?
Dr. Dobbs: C++ und die Gefahren doppelt geprüfter Sperren: Teil I

Question 3

Als Singleton möchten Sie normalerweise nicht, dass es zerstört wird.

Es wird abgebaut und freigegeben, wenn das Programm beendet wird, was das normale, gewünschte Verhalten für einen Singleton ist. Wenn Sie es explizit bereinigen möchten, ist es ziemlich einfach, der Klasse eine statische Methode hinzuzufügen, mit der Sie sie in einen sauberen Zustand zurückversetzen und bei der nächsten Verwendung neu zuweisen können, aber das liegt außerhalb des Bereichs von a “klassischer” Singleton.

Question 4

Sie könnten die Speicherzuweisung vermeiden. Es gibt viele Varianten, die alle Probleme in einer Multithreading-Umgebung haben.

Ich bevorzuge diese Art der Implementierung (eigentlich wird nicht richtig gesagt, dass ich bevorzuge, weil ich Singletons so weit wie möglich vermeide):

class Singleton
{
private:
   Singleton();

public:
   static Singleton& instance()
   {
      static Singleton INSTANCE;
      return INSTANCE;
   }
};

Es hat keine dynamische Speicherzuweisung.

Question 5

@Loki Astaris Antwort ist ausgezeichnet.

Es gibt jedoch Zeiten mit mehreren statischen Objekten, in denen Sie sicherstellen müssen, dass die Einzelling werden nicht zerstört, bis alle Ihre statischen Objekte, die die verwenden, zerstört werden Einzelling brauche es nicht mehr.

In diesem Fall std::shared_ptr kann verwendet werden, um die zu halten Einzelling lebendig für alle Benutzer, auch wenn die statischen Destruktoren am Ende des Programms aufgerufen werden:

class Singleton
{
public:
    Singleton(Singleton const&) = delete;
    Singleton& operator=(Singleton const&) = delete;

    static std::shared_ptr<Singleton> instance()
    {
        static std::shared_ptr<Singleton> s{new Singleton};
        return s;
    }

private:
    Singleton() {}
};

Question 6

Eine weitere nicht zuordnende Alternative: Erstellen Sie ein Singleton, beispielsweise eine Klasse Cwie Sie es brauchen:

singleton<C>()

verwenden

template <class X>
X& singleton()
{
    static X x;
    return x;
}

Weder diese noch Cătălins Antwort sind in aktuellem C++ automatisch Thread-sicher, werden es aber in C++0x sein.

Question 7

Ich habe unter den Antworten keine CRTP-Implementierung gefunden, also hier ist sie:

template<typename HeirT>
class Singleton
{
public:
    Singleton() = delete;

    Singleton(const Singleton &) = delete;

    Singleton &operator=(const Singleton &) = delete;

    static HeirT &instance()
    {
        static HeirT instance;
        return instance;
    }
};

Um es zu verwenden, erben Sie einfach Ihre Klasse davon, wie: class Test : public Singleton<Test>

Question 8

Hier ist eine einfache Implementierung.

#include <Windows.h>
#include <iostream>

using namespace std;


class SingletonClass {

public:
    static SingletonClass* getInstance() {

    return (!m_instanceSingleton) ?
        m_instanceSingleton = new SingletonClass : 
        m_instanceSingleton;
    }

private:
    // private constructor and destructor
    SingletonClass() { cout << "SingletonClass instance created!\n"; }
    ~SingletonClass() {}

    // private copy constructor and assignment operator
    SingletonClass(const SingletonClass&);
    SingletonClass& operator=(const SingletonClass&);

    static SingletonClass *m_instanceSingleton;
};

SingletonClass* SingletonClass::m_instanceSingleton = nullptr;



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

    SingletonClass *singleton;
    singleton = singleton->getInstance();
    cout << singleton << endl;

    // Another object gets the reference of the first object!
    SingletonClass *anotherSingleton;
    anotherSingleton = anotherSingleton->getInstance();
    cout << anotherSingleton << endl;

    Sleep(5000);

    return 0;
}

Es wird nur ein Objekt erstellt und diese Objektreferenz wird jedes Mal danach zurückgegeben.

SingletonClass instance created!
00915CB8
00915CB8

Hier ist 00915CB8 der Speicherort des Singleton-Objekts, der für die Dauer des Programms gleich ist, aber (normalerweise!) Jedes Mal, wenn das Programm ausgeführt wird, anders ist.

NB Dies ist kein Thread-Safe. Sie müssen Thread-Sicherheit gewährleisten.