template <typename T>
class SingletoneS
{
  static T * CreateSingletone()
  {
    if (::InterlockedIncrement(&m_Lock) == 1)
    {
        _instance = new T();
    }
    else 
        WaitForSingleObject(m_lSignal,INFINITE);
    Instance = ReturnInstance;
    SetEvent(m_lSignal);
    return Instance();
  }
  static T * ReturnInstance()
  {
    return _instance;
  }
  static T * _instance;
  static volatile LONG m_Lock;
  static HANDLE m_lSignal;
public:
  static void Reset()
  {
     T * temp = _instance;
     _instance = NULL;
     ResetEvent(m_lSignal);
     Instance = CreateSingletone;
     delete temp;
  }
  static T * (__cdecl * Instance)(void) ; 
};
template <typename T> T * SingletoneS<T>::_instance = NULL;
template <typename T> volatile LONG SingletoneS<T>::m_Lock = 0;
template <typename T> T * (__cdecl * SingletoneS<T>::Instance)(void) = SingletoneS<T>::CreateSingletone;
template <typename T> HANDLE SingletoneS<T>::m_lSignal = CreateEvent(NULL,NULL,false,NULL);

template <typename T> T * Singletone()
{
  return SingletoneS<T>::Instance();
}

#define DefineSingletone(Class) \
private:\
    friend class SingletoneS<Class>; \
    Class();

template<class T, template <typename T> class CreationPolicy = CreateUsingNew> 
class Singleton 
{
    typedef typename T ObjectType;
public:
    static T& Instance();
protected:
    Singleton(){}
private:
    static Singleton<T,CreationPolicy>* _instance;
};

template <class T,template <typename T> class CreationPolicy>
Singleton<T,CreationPolicy>* Singleton<T,CreationPolicy>::_instance;

template<class T, template <class> class CreationPolicy = CreateUsingNew> class Singleton 
{
    typedef T ObjectType;
public:
    static T& Instance();
protected:
Singleton(){}
private:
    static Singleton* _instance;
};

Singleton* Singleton::_instance=0; //error: expected constructor, destructor, or type conversion before '*' token

template<class T, template <class> class C>Singleton* Singleton<T, C>::_instance=0;

template<class T, template<class>class C>
Singleton<T,C>* Singleton<T,C>::_instance = 0;

template <class T> struct CreateUsingNew
{
    static T* Create()
    { return new T; }
    
    static void Destroy(T* p)
    { delete p; }
};

template <class T> struct CreateStatic
{
    union MaxAlign
    {
        char t_[sizeof(T)];
        short int shortInt_;
        int int_;
        long int longInt_;
        float float_;
        double double_;
        long double longDouble_;
        struct Test;
        int Test::* pMember_;
        int (Test::*pMemberFn_)(int);
    };
    static T* Create()
    {
        static MaxAlign staticMemory_;
        return new(&staticMemory_) T; //error: no matching function for call to 'operator new(long unsigned int, CreateStatic<A>::MaxAlign*)'
    }
    
    static void Destroy(T* p)
    {
        p->~T();
    }
};

template <class T> struct CreateStatic
{
    static T* Create()
    {
        static T instance;
        t = &instance;
        return t;
    }
    
    static void Destroy(T* p)
    {
        assert(p == t);
        t->~T();
    }
private:
    static T* t = 0;
};

А>template <class T> struct CreateStatic
А>{
А>    static T* Create()
А>    {
А>        static T instance;
А>        t = &instance;
А>        return t;
А>    }
    
А>    static void Destroy(T* p)
А>    {
А>        assert(p == t);
        t->>~T();
А>    }
А>private:
А>    static T* t = 0;
А>};
А>

template <class T> struct CreateStatic
{
    static T* Create()
    {
        static T instance;
        t = &instance;
        return t;
    }
    
    static void Destroy(T* p)
    {
        assert(p == t);
        t->~T();
    }
private:
    static T* t;
};

template<class T>T* CreateStatic<T>::t=0;

//2009 A.Gordienko Implementation of Singleton for iPhone OS. 
#ifndef SINGLETON_H
#define SINGLETON_H

template <class T> struct CreateUsingNew
{
    static T* Create()
    { return new T; }
    
    static void Destroy(T* p)
    { delete p; }
};

template <class T> struct CreateStatic
{
    static T* Create()
    {
        static T instance;
        t = &instance;
        return t;
    }
    
    static void Destroy(T* p)
    {
        assert(p == t);
        t->~T();
    }
private:
    static T* t;
};

template<class T>T* CreateStatic<T>::t=0;

template<class T, template <class> class CreationPolicy = CreateUsingNew> class Singleton 
{
    typedef T ObjectType;
public:
    static T& Instance();
private:
    Singleton(){}
    static void DestroySingleton();
    static T* _instance;
};


template<class T, template <class> class CreationPolicy>
inline T& Singleton<T, CreationPolicy>::Instance()
{
    if (!_instance)
    {
        _instance = CreationPolicy<T>::Create();
        if(_instance)
            atexit(Singleton<T,CreationPolicy>::DestroySingleton);        
    }
    return *_instance;
}

template<class T, template <class> class CreationPolicy>
inline void Singleton<T, CreationPolicy>::DestroySingleton()
{
    if(_instance)
    {
        CreationPolicy<T>::Destroy(_instance);
    }    
}

template <class T,template <typename T> class CreationPolicy>T* Singleton<T,CreationPolicy>::_instance=0;
#endif

class CSingletonBase {
public:
    bool IsReady() const { return isReady; }
protected:
    CSingletonBase() : isReady( true ) {}
    ~CSingletonBase() { isReady = false; }
private:
    bool isReady;
};

template<typename T> CStaticData : CSingletonBase {
    T Data;
public:
    CStaticData() {}
    template<typename Arg1>
    CStaticData( const Arg1& initWith1 ) : Data( initWith1 ) {}
    // Можно досыпать шаблонных конструкторов по вкусу

    T& Get() { assert( IsReady() ); return Data; }
    const T& Get() const  { assert( IsReady() ); return Data; }
};

template <class T> struct CreateStatic
{
    static T* Create()
    {
        static T instance;
        return &instance;
    }
    
    static void Destroy(T* p)
    {
        assert(p == &instance);
    }
};

E>3) Так как синглетон ленивый, возможны всякие странные эффекты. Суть которых состоит в том, что мы можем создать синглетон слишком поздно (типа уже на этапе разрушения статических объектов), либо, наоборот, слишком рано, из-за чего к нему кто-то обратиться уже после разрушения объекта...

#include "Singleton.h"
class A
{
    friend struct CreateStatic<A>;
    A(){}
    A(const A&a)
    {}
    A& operator=(const A&a){return *this;}
public:
    int f()
    {
        int h=999;
        return h;
    }    
};
typedef Singleton<A,CreateStatic> SinglA;

...
SinglA::Instance().f();
...