C++11改进单例模式

C++11之前，实现一个通用的泛型单例模式时，会遇到一个问题：这个泛型单例要能够创建所有的类型对象，但是这些类型的构造函数形参可能尽不相同，参数个数和参数类型可能都不相同，这导致我们不容易做一个所有类型都通用的单例。一种方法是通过定义一些创建单例的模板函数来实现。在一般情况下，类型的构造函数形参不超过6个，所以可以通过定义0~6个形参的创建单例的模板函数来实现一个通用的单例模式，代码如下所示：

#include &lt;iostream&gt;
using namespace std;

template&lt;typename T&gt;
class Singleton
{
public:
	///支持0个参数的构造函数
	static T* Instance()
	{
		if (m_pInstance == nullptr)
		{
			m_pInstance = new T();
		}
		return m_pInstance;
	}

	///支持1个参数的构造函数
	template&lt;typename T0&gt;
	static T* Instance(T0 arg0)
	{
		if (m_pInstance == nullptr)
		{
			m_pInstance = new T(arg0);
		}
		return m_pInstance;
	}

	///支持2个参数的构造函数
	template<typename T0, typename T1&gt;
	static T* Instance(T0 arg0, T1 arg1)
	{
		if (m_pInstance == nullptr)
		{
			m_pInstance = new T(arg0, arg1);
		}
		return m_pInstance;
	}

	///支持3个参数的构造函数
	template<typename T0, typename T1, typename T2&gt;
	static T* Instance(T0 arg0, T1 arg1, T2 arg2)
	{
		if (m_pInstance == nullptr)
		{
			m_pInstance = new T(arg0, arg1, arg2);
		}
		return m_pInstance;
	}

	///支持4个参数的构造函数
	template<typename T0, typename T1, typename T2, typename T3&gt;
	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;
	}

	///支持5个参数的构造函数
	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;
	}

	///支持6个参数的构造函数
	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)
		{
			std::logic_error("the instance is not init, please initialize the instance first");
		}

		return m_pInstance;
	}

	///释放单例
	static void DestoryInstance()
	{
		delete m_pInstance;

		m_pInstance = nullptr;
	}

private:
	///不允许复制和赋值
	Singleton(void);
	virtual ~Singleton(void);
	Singleton(const Singleton&amp;);
	Singleton&amp; operator=(const Singleton&amp;);

private:
	static T* m_pInstance;
};

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

class A
{
public:
	A()
	{
		cout << "construct A...." << endl;
	}
};

class B 
{
public:
	B(int x)
	{
		m_x = x;
		cout << "construct B...." << endl;
	}
private:
	int m_x;
};

class C 
{
public:
	C(int x, double db)
	{
		m_x = x;
		m_db = db;
		cout << "construct C...." << endl;
	}
private:
	int m_x;
	int m_db;
};


int main()
{
	///创建A类型的单例
	Singleton<A>::Instance();

	///创建B类型的单例
	Singleton<B>::Instance(1);

	///创建C类型的单例
	Singleton<C>::Instance(1, 2.0);


	Singleton<A>::DestoryInstance();
	Singleton<B>::DestoryInstance();
	Singleton<C>::DestoryInstance();


	return 0;
}

从测试代码中可以看到，这个Singleton<T>可以创建大部分类型，支持不超过6个参数的类型。不过，从实现代码中可以看到，有很多重复的模板定义，这种定义繁琐而又重复，当参数超过6个时，我们不得不再增加模板定义。这种预先定义足够多的模板函数的方法显得重复又不够灵活。

C++11d 可变参数模板正好可以消除这种重复，同时支持完美转发，即避免不必要的内存复制提高性能，又增加了灵活性。C++11实现的一个简洁通用的单例模式如下所示：

#include <iostream>
#include <string>
#include <thread>
#include <mutex>
#include <string.h>
using namespace std;


template<typename T>
class Singleton
{
public:
	template<typename ...Args>
	static T* Instance(Args&amp;&amp; ...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 DestoryInstance()
	{
		delete m_pInstance ;
		m_pInstance = nullptr;
	}

private:
	Singleton(void);
	virtual ~Singleton();
	Singleton(const Singleton&amp;);
	Singleton&amp; operator=(const Singleton&amp;);

private:
	static T* m_pInstance;
};

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


class A
{
public:
	A(const string&amp; )
	{
		cout << "A lvalue" << endl;
	}

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

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

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

class C
{
public:
	C(int x, int y)
	{
		cout << "C construct" << endl;
	}

	void func()
	{
		cout << "class C call func..." << endl;
	}
};

std::once_flag init_flagA;
std::once_flag init_flagB;
std::once_flag init_flagC;

void func1()
{
	///为了保证在多线程环境中某个函数仅被调用一次，比如，需要初始化某个对象，而这个对象只能初始化一次，就可以用std::call_once来保证在多线程环境中只被调用一次
	std::call_once(init_flagA, []() {Singleton<A>::Instance("123");});

	std::call_once(init_flagB, []() {Singleton<B>::Instance(std::move("abc"));});

	std::call_once(init_flagC, []() {Singleton<C>::Instance(1, 2);});
}

void func2()
{
	///为了保证在多线程环境中某个函数仅被调用一次，比如，需要初始化某个对象，而这个对象只能初始化一次，就可以用std::call_once来保证在多线程环境中只被调用一次
	std::call_once(init_flagA, []() {Singleton<A>::Instance("456");});

	std::call_once(init_flagB, []() {Singleton<B>::Instance(std::move("efg"));});

	std::call_once(init_flagC, []() {Singleton<C>::Instance(3, 4);});
}

int main()
{
	thread t1(func1);
	thread t2(func1);

	t1.join();
	t2.join();

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

	getchar();

	Singleton<A>::DestoryInstance();

	Singleton<B>::DestoryInstance();

	Singleton<C>::DestoryInstance();

	return 0;
}