template<typename T>

class Singleton{

public:

	static T* Instance(){

		if (m_pInstance == nullptr)

			m_pInstance = new T();

		return m_pInstance;

	}

	template<typename T0>

	static T* Instance(T0 arg0){

		if (m_pInstance == nullptr)

			m_pInstance = new T(arg0);

		return m_pInstance;

	}

	template<typename T0,typename T1>

	static T* Instance(T0 arg0, T1 arg1){

		if (m_pInstance == nullptr)

			m_pInstance = new T(arg0, arg1);

		return m_pInstance;

	}

	template<typename T0, typename T1,typename T2>

	static T* Instance(T0 arg0, T1 arg1,T2 arg2){

		if (m_pInstance == nullptr)

			m_pInstance = new T(arg0, arg1,arg2);

		return m_pInstance;

	}

	template<typename T0, typename T1, typename T2,typename T3>

	static T* Instance(T0 arg0, T1 arg1, T2 arg2,T3 arg3){

		if (m_pInstance == nullptr)

			m_pInstance = new T(arg0, arg1, arg2,arg3);

		return m_pInstance;

	}

	template<typename T0, typename T1, typename T2, typename T3,typename T4>

	static T* Instance(T0 arg0, T1 arg1, T2 arg2, T3 arg3,T4 arg4){

		if (m_pInstance == nullptr)

			m_pInstance = new T(arg0, arg1, arg2, arg3,arg4);

		return m_pInstance;

	}

	template<typename T0, typename T1, typename T2, typename T3, typename T4,typename T5>

	static T* Instance(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4,T5 arg5){

		if (m_pInstance == nullptr)

			m_pInstance = new T(arg0, arg1, arg2, arg3, arg4,arg5);

		return m_pInstance;

	}

	static T* GetInstance()

	{

		if (m_pInstance == nullptr)

			throw std::logic_error("the instance is not init,please init the instance first");

		return m_pInstance;

	}

	static void DestroyInstance(){

		delete m_pInstance;

		m_pInstance = nullptr;

	}

private:

	Singleton(void);

	virtual ~Singleton(void);

	Singleton(const Singleton&);

	Singleton& operator = (const Singleton);

	static T* m_pInstance;

};

template<class T> T* Singleton<T>::m_pInstance = nullptr;

//============================================

struct A{

	A(){}

};

struct B{

	B(int x){}

};

struct C{

	C(int x, double y){}

};

int _tmain(int argc, _TCHAR* argv[])

{

	Singleton<A>::Instance();

	Singleton<A>::Instance();

	Singleton<B>::Instance(1);

	Singleton<C>::Instance(1,3.14);

	Singleton<A>::DestroyInstance();

	Singleton<B>::DestroyInstance();

	Singleton<C>::DestroyInstance();

	return 0;

}

template<typename T>

class Singleton{

public:

	template <typename... Args>

	static T* Instance(Args&&... args){

		if (m_pInstance == nullptr)

			m_pInstance = new T(std::forward<Args>(args)...);

		return m_pInstance;

	}

	static T* GetInstance(){

		if (m_pInstance == nullptr)

			throw std::logic_error("the instance is not init,please initialize the instance first");

		return m_pInstance;

	}

	static void DestroyInstance()

	{

		delete m_pInstance;

		m_pInstance = nullptr;

	}

private:

	Singleton(void);

	virtual ~Singleton(void);

	Singleton(const Singleton&);

	Singleton& operator=(const Singleton&);

private:

	static T* m_pInstance;

};

template<class T>T* Singleton<T>::m_pInstance = nullptr;

#include <iostream>

#include <string>

using namespace std;

struct A{

	A(const string&){ cout << "lvalue" << endl; }

	A(string&&x){ cout << "rvalue" << endl; }

};

struct B{

	B(const string&){ cout << "lvalue" << endl; }

	B(string&& x){ cout << "rvalue" << endl; }

};

struct C{

	C(int x, double y){}

	void Fun(){ cout << "Test" << endl; }

}; 

int _tmain(int argc, _TCHAR* argv[])

{

	string str = "bb";

	Singleton<A>::Instance(str);

	Singleton<B>::Instance(std::move(str));

	Singleton<C>::Instance(1,3.14);

	Singleton<C>::GetInstance()->Fun();

	Singleton<A>::DestroyInstance();

	Singleton<B>::DestroyInstance();

	Singleton<C>::DestroyInstance();

	return 0;

}