// interface

template <class _Class_t>
class Singleton
{
// construction/destruction
protected:
    Singleton(void);
    ~Singleton(void);

// copying/assignment - disabled and thus not implemented
private:
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);

// object creator/accessor
public:
    static _Class_t& GetObject(void);

// attributes
private:
    class Locker: public CRITICAL_SECTION
    {
        friend class Singleton<_Class_t>;
        Locker(void);
        ~Locker(void);
        void Enter(void);
        void Leave(void);
    };
    static Locker m_objectLocker;
};

// Singleton<> implementation

template <class _Class_t>
inline Singleton<_Class_t>::Singleton(void)
{
}

template <class _Class_t>
inline Singleton<_Class_t>::~Singleton(void)
{
}

template <class _Class_t>
_Class_t& Singleton<_Class_t>::GetObject(void)
{
    m_objectLocker.Enter();
    static _Class_t* pObject;
    if (pObject == NULL)
    {
        pObject = new _Class_t();
    }
    m_objectLocker.Leave();
    return (*pObject);
}

template <class _Class_t>
typename Singleton<_Class_t>::Locker Singleton<_Class_t>::m_objectLocker;

// Singleton<>::Locker implementation

template <class _Class_t>
inline Singleton<_Class_t>::Locker::Locker(void)
{
    ::InitializeCriticalSection(this);
}

template <class _Class_t>
inline Singleton<_Class_t>::Locker::~Locker(void)
{
    ::DeleteCriticalSection(this);
}

template <class _Class_t>
inline void Singleton<_Class_t>::Locker::Enter(void)
{
    ::EnterCriticalSection(this);
}

template <class _Class_t>
inline void Singleton<_Class_t>::Locker::Leave(void)
{
    ::LeaveCriticalSection(this);
}

class MyOneAndOnly: public Singleton<MyOneAndOnly> { ... };

MyOneAndOnly::GetObject().some_method();

1. Обращение к методам MyOneAndOnly потенциально возможно из конструкторов/деструкторов глобальных объектов (почему pObject и создается в куче). С первыи проблем, как я понимаю не возникнет, так как при первом же общении произойдет вызов new _Class_t. А вот деструкторами все хуже, потому как никаких гарантий, что уже не был разрушен Locker, у меня нет. Это можно как-то преодолеть?
   
   
2. Очевидно, что когда-то нужно вызвать delete pObject — но как это сделать "безопасно" (то есть, с гарантией, что все глобальные объекты уже разрушены)? Копать в сторону atexit()?
   
   
3. Я правильно понимаю, что реализовать singleton для класса, который не имеет конструктора по умолчанию, невозможно?

template<class T> class singleton : public T
{
private:
...
   struct creator
   {
       creator()
       {
          singleton<T>::instance();
       }  
   }
   static creator s_singleton_creator;

public:
   static T& instance()
   {
      static T inst;
      return inst;
   }
};

template<class T> typename singleton<T>::creator singleton<T>::s_singleton_creator;

// The following helper classes are placeholders for a generic "singleton"
// class. The classes below support usage of singletons, including use in
// program startup/shutdown code, AS LONG AS there is only one thread
// running before main() begins, and only one thread running after main()
// exits.

// Furthermore, since the instance() function contains the object, instead
// of the singleton_default class containing a static instance of the
// object, that object is guaranteed to be constructed (at the latest) in
// the first call to instance(). This permits calls to instance() from
// static code, even if that code is called before the file-scope objects
// in this file have been initialized.

DG>>Конечно! У Александреску именно так и написано

SDB>"Great minds think alike..." Но код из Context Singletons — context-specific shared objects in C++ читается значительно приятнее.

Full disclosure: phoenix is based partly on MC++D's code. In particular, i've stolen Andrei's trick of matching atexit(), manual dtor invokation and the placement new operator .

class my_singleton_t {
...
};

extern my_singleton_t my_singleton;

SDB>>    static Locker m_objectLocker; // 1) инициализируется в runtime - обращение
PA>                                      // к GetObject из других единиц трансляции
PA>                                      //  может обломиться
SDB>>        pObject = new _Class_t();// 2) маловероятно, но может бросить исключение,
SDB>>    m_objectLocker.Leave(); // ...и сюда мы не попадаем
SDB>>

try
{
...
}
catch (...)
{
    m_objectLocker.Leave();
    throw;
}

template<class T> class singleton : public T
{
private:
    static int creator()
    {
        singleton<T>::instance();
        return 0;
    }

    static int (__cdecl *pcreator)();

public:
    static T& instance()
    {
        static int use_pcreate = pcreator(); //

        static singleton<T> inst;
        return inst;
    }
};

#pragma data_seg(".CRT$XIC")
template<class T> __declspec(allocate(".CRT$XIC")) int (__cdecl *singleton<T>::pcreator)() = singleton<T>::creator;
#pragma data_seg()

class USTax : public CalcTax {
  public:
    static USTax* getInstance();
  private:
    USTax();
    static USTax* instance;
};
USTax* USTax::instance= 0;

USTax* USTax::getInstance () {
  if (instance== 0) {
    // do sync here
    if (instance== 0) {
        instance= new USTax;
    }
  }
  return instance;
}

template<class T>
struct InterfaceIID;

struct IServiceProvider
{
    template<class T>
    T* GetService()
    {
        return reinterpret_cast<T*>(GetServiceByIID(InterfaceIID<T>::IID()));
    }
protected:
    virtual void* GetServiceByIID(GUID const& giud) = 0;
    virtual ~IServiceProvider(){}
};

template<>
struct InterfaceIID<IServiceProvider>
{
    static GUID const& IID()
    {
        // {0AFA964C-DD0F-43d2-846B-99A3022197A2}
        static const GUID guid = { 0xafa964c, 0xdd0f, 0x43d2, { 0x84, 0x6b, 0x99, 0xa3, 0x2, 0x21, 0x97, 0xa2 } };
        return guid;
    }
};

template <class T, class InstantiationPolicy, class LockType>
T* Singleton<T, InstantiationPolicy, LockType>::instance() {

    // Uses local static storage to avoid static construction
    // sequence issues. (regaring when the lock is created)
    static T* ptr = 0;    
    static LockType lock;

    if(!ptr) {

      Guard<LockType, LockedScope> g(lock);
      if(!ptr)        
        InstantiationPolicy::create(ptr);

    }
    return const_cast<T*>(ptr);
    
  }
};