C++ Singleton design pattern

Będąc Singletonem, zazwyczaj nie chcesz, aby został zniszczony.

Zostanie zburzony i dealokowany, gdy program zakończy działanie, co jest normalnym, pożądanym zachowaniem dla Singletona. Jeśli chcesz być w stanie jawnie go wyczyścić, dość łatwo jest dodać statyczną metodę do klasy, która pozwala przywrócić go do stanu czystego i ponownie przy następnym użyciu, ale jest to poza zakresem" klasycznego " Singletona.

Można uniknąć alokacji pamięci. Istnieje wiele wariantów, wszystkie mające problemy w przypadku środowiska wielowątkowego.

Wolę tego typu implementację (właściwie to nie jest poprawnie powiedziane, że wolę, bo unikam singletonów jak najbardziej):

class Singleton
{
private:
   Singleton();

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

Nie posiada dynamicznej alokacji pamięci.

Inna alternatywa niealokująca: Utwórz singleton, powiedzmy klasy C, Jak potrzebujesz:

singleton<C>()

Użycie

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

Ani ta, ani odpowiedź Cătălina nie jest automatycznie bezpieczna dla wątków w bieżącym C++, ale będzie w C++0x.

@odpowiedź Loki Astari jest doskonała.

Są jednak sytuacje, w których istnieje wiele statycznych obiektów, w których musisz być w stanie zagwarantować, że singleton nie zostanie zniszczony, dopóki wszystkie Twoje statyczne obiekty, które używają singleton nie będą już tego potrzebować.

W tym przypadku std::shared_ptr może być użyty do utrzymania singleton przy życiu dla wszystkich użytkowników, nawet gdy na końcu programu wywoływane są statyczne destruktory:

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() {}
};

Jeśli chcesz przydzielić obiekt w stercie, dlaczego nie użyć unikalnego wskaźnika. Pamięć będzie również dealokowana, ponieważ używamy unikalnego wskaźnika.

class S
{
    public:
        static S& getInstance()
        {
            if( m_s.get() == 0 )
            {
              m_s.reset( new S() );
            }
            return *m_s;
        }

    private:
        static std::unique_ptr<S> m_s;

        S();
        S(S const&);            // Don't Implement
        void operator=(S const&); // Don't implement
};

std::unique_ptr<S> S::m_s(0);

Rozwiązanie w zaakceptowanej odpowiedzi ma znaczącą wadę - destruktor dla singletonu jest wywoływany po opuszczeniu funkcji main(). Mogą wystąpić problemy, gdy wewnątrz main zostaną przydzielone pewne obiekty zależne.

Napotkałem ten problem, próbując wprowadzić Singleton w aplikacji Qt. Zdecydowałem, że wszystkie moje okna konfiguracyjne muszą być Singletonami i zastosowałem powyższy wzór. Niestety, główna klasa Qt QApplication została przydzielona na stos w main funkcji, a Qt zabrania tworzenia / niszczenia okien dialogowych, gdy żaden obiekt aplikacji nie jest dostępny.

Dlatego wolę singletony przydzielane na stosie. Podaję jawne metody init() i term() dla wszystkich singletonów i wywołuję je wewnątrz main. Mam wiÄ ™ c peĹ 'nÄ ... kontrolÄ ™ nad kolejnoĹ" ciÄ ... tworzenia/niszczenia singletonăłw, a takĹĽe gwarantujÄ ™ ĹĽe singletony bÄ ™ dÄ ... tworzone, bez wzglÄ ™ du na to czy ktoĹ "wywoĹ' a getInstance() czy nie.

Oto prosta implementacja.

#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;
}

Utworzony jest tylko jeden obiekt i to odniesienie do obiektu jest zwracane za każdym razem po słowach.

SingletonClass instance created!
00915CB8
00915CB8

Tutaj 00915CB8 to miejsce pamięci Singletona, takie samo na czas trwania programu, ale (normalnie!) różne za każdym razem, gdy program jest uruchamiany.

Jest rzeczywiście prawdopodobnie przypisany ze sterty, ale bez źródeł nie ma możliwości poznania.

Typowa implementacja (zaczerpnięta z kodu, który mam już w Emacsie) to:

Singleton * Singleton::getInstance() {
    if (!instance) {
        instance = new Singleton();
    };
    return instance;
};

...i polegaj na tym, że program będzie poza zasięgiem, aby posprzątać później.

Jeśli pracujesz na platformie, na której Sprzątanie musi być wykonywane ręcznie, prawdopodobnie dodałbym ręczną procedurę sprzątania.

Kolejny problem z robieniem tego w ten sposób jest to, że nie jest bezpieczny dla wątków. W środowisko wielowątkowe, dwa wątki mogą przejść przez "Jeśli", zanim któryś z nich będzie miał szansę przydzielić nową instancję (więc oba będą). To nadal nie jest zbyt duża sprawa, jeśli i tak polegasz na zakończeniu programu, aby posprzątać.

Chodzi o zarządzanie czasem życia obiektu. Załóżmy, że masz więcej niż singletony w swoim oprogramowaniu. I zależą od Loggera Singletona. Załóżmy, że podczas niszczenia aplikacji inny obiekt singleton używa Loggera do zapisywania kroków niszczenia. Musisz zagwarantować, że Logger zostanie wyczyszczony jako ostatni. Dlatego proszę również zapoznać się z tym artykułem: http://www.cs.wustl.edu/ ~ schmidt / PDF / ObjMan. pdf

Nie znalazłem implementacji CRTP wśród odpowiedzi, więc oto ona:

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;
    }
};

Aby użyć po prostu dziedziczyć swoją klasę z tego, jak: class Test : public Singleton<Test>

Czy ktoś wspomniał std::call_once i std::once_flag? Większość innych podejść-w tym blokada podwójnie sprawdzona - jest zepsuta.

Jednym z głównych problemów implementacji wzorców Singletona jest Bezpieczna inicjalizacja. Jedynym bezpiecznym sposobem jest ochrona sekwencji inicjalizacji za pomocą barier synchronizujących. Ale te bariery muszą być bezpiecznie zainicjowane. std::once_flag jest mechanizmem gwarantującym bezpieczną inicjalizację.

#define INS(c) private:void operator=(c const&){};public:static c& I(){static c _instance;return _instance;}

Przykład:

   class CCtrl
    {
    private:
        CCtrl(void);
        virtual ~CCtrl(void);

    public:
        INS(CCtrl);

Oprócz innych dyskusji tutaj, warto zauważyć, że możesz mieć globalne-ness, bez ograniczania użycia do jednej instancji. Na przykład, rozważmy przypadek odniesienia liczenia czegoś...

struct Store{
   std::array<Something, 1024> data;
   size_t get(size_t idx){ /* ... */ }
   void incr_ref(size_t idx){ /* ... */}
   void decr_ref(size_t idx){ /* ... */}
};

template<Store* store_p>
struct ItemRef{
   size_t idx;
   auto get(){ return store_p->get(idx); };
   ItemRef() { store_p->incr_ref(idx); };
   ~ItemRef() { store_p->decr_ref(idx); };
};

Store store1_g;
Store store2_g; // we don't restrict the number of global Store instances

Teraz gdzieś wewnątrz funkcji (np. main) możesz zrobić:

auto ref1_a = ItemRef<&store1_g>(101);
auto ref2_a = ItemRef<&store2_g>(201); 

Refy nie muszą przechowywać WSKAŹNIKA z powrotem do swoich Store, ponieważ informacje te są dostarczane w czasie kompilacji. Nie musisz się też martwić o życie Store, ponieważ kompilator wymaga, aby był globalny. Jeśli rzeczywiście istnieje tylko jedna instancja Store , to nie ma narzutu w tym podejściu; w przypadku więcej niż jednej instancji to kompilator powinien być mądry w kwestii generowania kodu. Jeśli to konieczne, klasa ItemRef może być nawet friend z Store (możesz mieć szablonowych przyjaciół!).

Jeśli Store sama w sobie jest klasą szablonową, wtedy rzeczy stają się messier, ale nadal można użyć tej metody, być może implementując klasę pomocniczą o następującej podpis:

template <typename Store_t, Store_t* store_p>
struct StoreWrapper{ /* stuff to access store_p, e.g. methods returning 
                       instances of ItemRef<Store_t, store_p>. */ };

Użytkownik może teraz utworzyć typ StoreWrapper (i instancję globalną) dla każdej instancji globalnej Store i zawsze uzyskać dostęp do magazynów poprzez ich instancję wrappera (zapominając w ten sposób o krwawych szczegółach parametrów szablonu potrzebnych do użycia Store).

Prosta klasa singleton, to musi być plik klasy nagłówka

#ifndef SC_SINGLETON_CLASS_H
#define SC_SINGLETON_CLASS_H

class SingletonClass
{
    public:
        static SingletonClass* Instance()
        {
           static SingletonClass* instance = new SingletonClass();
           return instance;
        }

        void Relocate(int X, int Y, int Z);

    private:
        SingletonClass();
        ~SingletonClass();
};

#define sSingletonClass SingletonClass::Instance()

#endif

Dostęp do singletonu w ten sposób:

sSingletonClass->Relocate(1, 2, 5);

Myślę, że powinieneś napisać statyczną funkcję, w której twój obiekt statyczny zostanie usunięty. Należy wywołać tę funkcję, gdy masz zamiar zamknąć aplikację. Zapewni to, że nie masz wycieku pamięci.

Artykuł, do którego nawiązano powyżej, opisuje wadę blokowania double checked polegającą na tym, że kompilator może przydzielić pamięć dla obiektu i ustawić wskaźnik na adres przydzielonej pamięci, zanim konstruktor obiektu zostanie wywołany. W c++ jest jednak dość łatwo używać alokatorów do ręcznego przydzielania pamięci, a następnie używać wywołania construct do inicjalizacji pamięci. Używając tego appracha, podwójnie sprawdzony zamek działa dobrze.

A co powiesz na umieszczenie nowego w ten sposób:

class singleton
{
    static singleton *s;
    static unsigned char *buffer[sizeof(singleton)/4 *4] //4 byte align
    static singleton* getinstance()
    {
        if (s == null)
        {
            s = new(buffer) singleton;
        }
        return s;
    }
};