C++中的单例模式

定义例如以下：

class CSingleton
{
private:
	CSingleton()   //构造函数是私有的
	{
	}
	static CSingleton *m_pInstance;
public:
	static CSingleton * GetInstance()
	{
		if(m_pInstance == NULL)  //推断是否第一次调用
			m_pInstance = new CSingleton();
		return m_pInstance;
	}
};

class CSingleton
{
private:
	CSingleton()
	{
	}
	static CSingleton *m_pInstance;
	class CGarbo   //它的唯一工作就是在析构函数中删除CSingleton的实例
	{
	public:
		~CGarbo()
		{
			if(CSingleton::m_pInstance)
				delete CSingleton::m_pInstance;
		}
	};
	static CGarbo Garbo;  //定义一个静态成员变量，程序结束时，系统会自己主动调用它的析构函数
public:
	static CSingleton * GetInstance()
	{
		if(m_pInstance == NULL)  //推断是否第一次调用
			m_pInstance = new CSingleton();
		return m_pInstance;
	}
};

可是加入一个类的静态对象，总是让人不太惬意，所以有人用例如以下方法来又一次实现单例和解决它对应的问题，代码例如以下：

class CSingleton
{
private:
	CSingleton()   //构造函数是私有的
	{
	}
public:
	static CSingleton & GetInstance()
	{
		static CSingleton instance;   //局部静态变量
		return instance;
	}
};

最后没有办法，我们要禁止类拷贝和类赋值，禁止程序猿用这样的方式来使用单例，当时领导的意思是GetInstance()函数返回一个指针而不是返回一个引用，函数的代码改为例如以下：

class CSingleton
{
private:
	CSingleton()   //构造函数是私有的
	{
	}
public:
	static CSingleton * GetInstance()
	{
		static CSingleton instance;   //局部静态变量
		return &instance;
	}
};

但我总觉的不好，为什么不让编译器不这么干呢。这时我才想起能够显示的声明类拷贝的构造函数，和重载 = 操作符，新的单例类例如以下：

class CSingleton
{
private:
	CSingleton()   //构造函数是私有的
	{
	}
	CSingleton(const CSingleton &);
	CSingleton & operator = (const CSingleton &);
public:
	static CSingleton & GetInstance()
	{
		static CSingleton instance;   //局部静态变量
		return instance;
	}
};

class Lock
{
private:       
	CCriticalSection m_cs;
public:
	Lock(CCriticalSection  cs) : m_cs(cs)
	{
		m_cs.Lock();
	}
	~Lock()
	{
		m_cs.Unlock();
	}
};

class Singleton
{
private:
	Singleton();
	Singleton(const Singleton &);
	Singleton& operator = (const Singleton &);

public:
	static Singleton *Instantialize();
	static Singleton *pInstance;
	static CCriticalSection cs;
};

Singleton* Singleton::pInstance = 0;

Singleton* Singleton::Instantialize()
{
	if(pInstance == NULL)
	{   //double check
		Lock lock(cs);           //用lock实现线程安全，用资源管理类，实现异常安全
		//使用资源管理类，在抛出异常的时候，资源管理类对象会被析构，析构总是发生的不管是由于异常抛出还是语句块结束。
		if(pInstance == NULL)
		{
			pInstance = new Singleton();
		}
	}
	return pInstance;
}