Код: Выделить всё

// Singleton.h
class Singleton1
{
  private: 
    Singleton1() { }
    Singleton1( const Singleton1& );  
    Singleton1& operator=( Singleton1& );
  public:
    static Singleton1& getInstance() {
        static Singleton1 instance;
        return instance;
    }    
}; 
  
class Singleton2
{
  private:     
    Singleton2( Singleton1& instance): s1( instance) { }
    Singleton2( const Singleton2& );  
    Singleton2& operator=( Singleton2& );
    Singleton1& s1;
  public:
    static Singleton2& getInstance() {
        static Singleton2 instance( Singleton1::getInstance());
        return instance;
    }    
}; 
  
// main.cpp
#include "Singleton.h"
  
int main()
{
    Singleton2& s = Singleton2::getInstance();  
    return 0;
}

Код: Выделить всё

// Singleton.h
class Singleton;  // опережающее объявление
  
class SingletonDestroyer
{
  private:
    Singleton* p_instance;
  public:    
    ~SingletonDestroyer();
    void initialize( Singleton* p );
};
  
class Singleton
{
  private:
    static Singleton* p_instance;
    static SingletonDestroyer destroyer;
  protected: 
    Singleton() { }
    Singleton( const Singleton& );
    Singleton& operator=( Singleton& );
   ~Singleton() { }
    friend class SingletonDestroyer;
  public:
    static Singleton& getInstance();    
};
  
// Singleton.cpp
#include "Singleton.h"
  
Singleton * Singleton::p_instance = 0;
SingletonDestroyer Singleton::destroyer;
  
SingletonDestroyer::~SingletonDestroyer() {   
    delete p_instance; 
}
void SingletonDestroyer::initialize( Singleton* p ) {
    p_instance = p; 
}
Singleton& Singleton::getInstance() {
    if(!p_instance)     {
        p_instance = new Singleton();
        destroyer.initialize( p_instance);     
    }
    return *p_instance;
}