C++ 设计模式：单例

template<typename T>
class Singleton
{
public:
	template<typename ...Args>
	static std::shared_ptr<T> GetInstance(Args&&... args)
	{
		if (nullptr == m_pSington)
		{
			std::lock_guard<std::mutex> gLock(_mutex);
			if (nullptr == m_pSington)
			{
				m_pSington = std::make_shared<T>(std::forward<Args>(args)...);
				static del_obj obj;
			}
		}
		return m_pSington;
	}
protected:
	Singleton() = default;
	~Singleton() = default;
private:
	Singleton(const Singleton& obj) = delete;
	Singleton& operator= (const Singleton& obj) = delete;


private:
	class del_obj
	{
	public:
		virtual ~del_obj()
		{
			if (nullptr != m_pSington)
			{
				m_pSington.reset();
				m_pSington = nullptr;
			}
		}
	};
private:
	static std::shared_ptr<T> m_pSington;
	static std::mutex _mutex;

	friend  T;
};

template<typename T>
std::shared_ptr<T> Singleton<T>::m_pSington = nullptr;

template<typename T>
std::mutex Singleton<T>::_mutex;



class MyClass {
public:

	MyClass(const string& strData) : m_strData(strData) {
		cout << m_strData.data() << endl;
	};
	~MyClass() {
		cout << "destory" << endl;
	};


private:
	string m_strData;
};


void testsingleton()
{
	auto pClass = Singleton<MyClass>::GetInstance("create");
	auto pCl = Singleton<MyClass>::GetInstance("create");
	

	std::cout << pClass << std::endl;
	std::cout << pCl << std::endl;
}