做個工程上能用的單例模式，不僅要支援多執行緒，也要支援多引數傳遞，也要支援餓漢和懶漢兩種模式，用了下c++11的call_once, lamda表示式，可變引數模板和forward的轉發，程式碼如下：

#include <iostream>
#include <mutex>
using namespace std;
template<class T>
class Singleton
{
public:
	template<class... Params>
	static void init(Params&&... params)
	{
		if(ins == NULL)
			ins=new T(std::forward<Params>(params)...);
	}
	static T* get()
	{
		if(ins == NULL)
		{
			cout<<"please init first."<<endl;
			return ins;
		}
		return ins;
	}

	template<class... Params>
	static T* getAndInit(Params&&... params)
	{
		static std::once_flag oc;//用於call_once的區域性靜態變數
   		std::call_once(oc, [&]{ins = new T(std::forward<Params>(params)...);});
    	        return ins;
	}
	static void destroy()
	{
		delete ins;
		ins=NULL;
	}
private:
	Singleton();
	virtual ~Singleton();
	Singleton(const Singleton& s);
	Singleton& operator=(const Singleton& s);
	static T* ins;
};
template<class T> T* Singleton<T>::ins=NULL;

 

其中init和get分離的是餓漢模式，在多執行緒程式中，潛在出現競爭的是new的地方，將init放到一個安全的地方，比如主程序的初始化部分，可以避免競爭。

getAndInit是典型的懶漢模式，即在get的時候檢查初始化，傳統的處理方法是double check+記憶體柵欄，不過既然c++11提供了call_once這麼適合單例的操作，不用就可惜了，call_once的實際工作用的是lamda表示式。

template<class... Params> 比傳統的template多了3個點，實現了可變引數模板，forward直接把可變的引數完美轉發了。

Singleton的private部分是為了禁止構造，析構，拷貝構造和賦值，多說一句virtual修飾析構，是為了呼叫派生類和基類的解構函式，應對了動態繫結，預防了記憶體洩漏。

在函式外的ins賦值為NULL的部分，完成對ins的定義，這裡需要在template之後明確的指定型別為T*。

附一個測試例子，註釋掉的部分是測試餓漢的部分。

struct A
{
	int a;
	A(int val)
	{
		a=val;
		cout<<"A is construct"<<endl;
	}
};
int main()
{
	// Singleton<A>::init(21);
	// A* test1=Singleton<A>::get();
	// cout<<test1<<endl;
	// A* test2=Singleton<A>::get();
	A* test1=Singleton<A>::getAndInit(32);
	A* test2=Singleton<A>::getAndInit(34);
	cout<<test1<<endl;
	cout<<test2<<endl;
	cout<<test2->a<<endl;
	Singleton<A>::destroy();
	return 0;
}
 

編譯的方法是:

g++ test.cc -o test -std=c++11 -pthread