template <typename T> class Singleton
{
	static T * ms_Singleton;

public :
	Singleton(void)
	{
		assert(!ms_Singleton);

		int offset = (int)(T *)1 - (int)(Singleton <T> *)(T*)1;
		ms_Singleton = (T*)((int)this + offset);
	}

	~Singleton()
	{
		asset(ms_Singleton);
		ms_Singleton = nullptr;
	}

	static T & GetSingleton()
	{
		return (*ms_Singleton);
	}

	static T * GetSingletonPtr()
	{
		return (ms_Singleton);
	}
};

template <typename T> T* Singleton<T>::ms_Singleton = 0;

class Manager : public Singleton <Manager>
{
	public :
		void Print()
		{
			std::cout << "Manager Instance called" << std::endl;
		}
};

int main()
{
	Manager *m = Manager::GetSingletonPtr();
	m->Print();
}

template<typename T>class Singleton{public:    static T& Get()    {        // This bit is the magic.  The standard guarenttees that static        // local variables will be initialized the first time that the        // function is called.  This means that order of construction is         // guarentteed and automagically occurs the first time Get() is        // called for the type T, regardless of where it's called from        // (eg. calling it from a global's or another singleton's        // constructor is perfectly safe).        static T instance;        return instance;    }private:    Singleton() {}};class MyClass{public:    void DoStuff() {}private:    // You only need this bit if you want to ensure    // the class is only used as a singleton    friend class Singleton<MyClass>;    MyClass() {}};void func(){    Singleton<MyClass>::Get().DoStuff();}