【设计模式】单例模式

单例模式要注意以下几点：

它有一个指向唯一实例的静态指针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;
	}
};

以下是一个例子（来自于网络 点击打开链接）

Emperor.h

#pragma once
#include <iostream>
#include <Windows.h>
using std::cout;
using std::endl;
using std::string;
class CEmperor
{
public:
	static CEmperor * GetInstance();
	static void ReleaseInstance();
	void EmperorInfo(void);
	void SetEmperorTag(string tag);
private:
	CEmperor(void);
	virtual ~CEmperor(void);
	CEmperor(const CEmperor&);
	CEmperor& operator=(const CEmperor&);
	static CEmperor *m_pEmperor;
	static HANDLE m_pMutex;
	string m_EmperorTag;
	class CGarbo
	{
	public:
		CGarbo()
		{
			cout << "Create Garbo" << endl;
		}
		~CGarbo()
		{
			cout << "Destroy Garbo" << endl;
			if (NULL != m_pEmperor)
			{
				WaitForSingleObject(m_pMutex, INFINITE);
				if (NULL != m_pEmperor)
				{
					cout << "Remove instance" << endl;
					delete m_pEmperor;
					m_pEmperor = NULL;
				}
				ReleaseMutex(m_pMutex);
			}
			if (NULL != m_pMutex)
			{
				cout << "Delete mutex" << endl;
				CloseHandle(m_pMutex);
				m_pMutex = NULL;
			}
		}
	};
	static CGarbo m_Garbo;
};

Emperor.cpp

//#include "stdafx.h"
#include "Emperor.h"
#include <Windows.h>
#include <iostream>
using std::cout;
using std::endl;
using std::string;
CEmperor* CEmperor::m_pEmperor = NULL;
HANDLE CEmperor::m_pMutex = CreateMutex(NULL, FALSE, NULL);
CEmperor::CGarbo CEmperor::m_Garbo;
CEmperor::CEmperor(void)
{
	cout << "Create CEmperor Instance" << endl;
}
CEmperor::~CEmperor(void)
{
	cout << "Destroy CEmperor Instance and release its resource" << endl;
}
void CEmperor::EmperorInfo(void)
{
	char msgBuffer[50] = { 0 };
	sprintf_s(msgBuffer, 50, "皇帝(%s).", m_EmperorTag.c_str());
	string msg(msgBuffer);
	cout << msg.c_str() << endl;
}
CEmperor* CEmperor::GetInstance()
{
	if (NULL == m_pEmperor)
	{
		WaitForSingleObject(m_pMutex, INFINITE);
		if (NULL == m_pEmperor)
			m_pEmperor = new CEmperor();
		ReleaseMutex(m_pMutex);
	}
	return m_pEmperor;
}
void CEmperor::ReleaseInstance()
{
	if (NULL != m_pEmperor)
	{
		WaitForSingleObject(m_pMutex, INFINITE);
		if (NULL != m_pEmperor)
		{
			delete m_pEmperor;
			m_pEmperor = NULL;
		}
		ReleaseMutex(m_pMutex);
	}
}
void CEmperor::SetEmperorTag(string tag)
{
	m_EmperorTag = tag;
}

Singleton.cpp

//#include "stdafx.h"
#include "Emperor.h"
void DoIt()

{
	CEmperor *pEmperor1 = CEmperor::GetInstance();
	pEmperor1->SetEmperorTag("95");
	pEmperor1->EmperorInfo();

	CEmperor *pEmperor2 = CEmperor::GetInstance();
	pEmperor2->EmperorInfo();

	CEmperor *pEmperor3 = CEmperor::GetInstance();
	pEmperor3->EmperorInfo();

	CEmperor *pEmperor4 = pEmperor3;
	pEmperor4->EmperorInfo();

	CEmperor *pEmperor5 = NULL;
	pEmperor5 = pEmperor4;
	pEmperor5->EmperorInfo();

	CEmperor::ReleaseInstance();

}

int main(int argc, char * argv[])
{
	DoIt();
	system("pause");
	return 0;
}

运行结果：