Singleton-Muster für ableitbar Klasse

Question

Im normalen Singletonmuster wird die Singletonklasse effektiv „versiegelt“ (kann nicht abgeleitet werden):

class A 
{ 
private: 
    static A m_instance; // instance of this class, not a subclass 

    // private ctor/dtor, so class can't be derived 
    A(); 
    ~A(); 

public: 
    static A& GetInstance() { return m_instance; } 

    ... 
}; 

Wie würden Sie eine Klasse schreiben, die abgeleitet werden soll, aber deren abgeleitete Klasse sollte nur einmal instanziiert werden?

Answer 1

Wie würden Sie eine Klasse schreiben, die abgeleitet werden soll, deren abgeleitete Klasse jedoch nur einmal instanziiert werden sollte?

können Sie die CRTP verwenden zu erkennen, dass:

template<typename Derived> 
class A 
{ 
protected: // Allow to call the constructor and destructor from a derived class 
    A(); 
    ~A(); 

public: 
    static T& GetInstance() { 
     static T theInstance; // Better way than using a static member variable 
     return theInstance; 
    } 

    ... 
}; 

und verwenden, die

class B : public A<B> { 
    // Specific stuff for derived class 
}; 

---

anmerken, dass auf diese Weise am sinnvollsten ist, wenn die Basisklasse einige liefert gemeinsame Implementierung (neben der GetInstance() Funktion) realisiert, basierend auf einer von der abgeleiteten Klasse bereitgestellten Schnittstelle.

Jedes Mal, wenn ein Aufruf der abgeleiteten Klasse in der Basisklasse benötigt wird Sie sicher ein static_cast<Derived*>(this) es verwenden kann, um Zugriff (keine virtual oder reine virtual Funktionen erforderlich):

template<typename Derived> 
void A<Derived>::doSomething { 
     // Execute the functions from Derived that actually implement the 
     // warranted behavior. 
     static_cast<Derived*>(this)->foo(); 
     static_cast<Derived*>(this)->bar(); 
}