设计模式--单例模式

解释说明：

在系统中只允许产生这个类的一个实例，

实例说明：很多大臣拜见的皇帝，只有一个。体现在面向对象方面，CEmperor定义一个静态指针，和一个静态函数，私有化构造函数、析构函数、构造函数复制、重载赋值语句。 
注意：线程安全，采用互斥体的方式实现 

优点：

系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

缺点：

当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new，可能会给其他开发人员造成困扰，特别是看不到源码的时候。

适用场合

• 需要频繁的进行创建和销毁的对象；
• 创建对象时耗时过多或耗费资源过多，但又经常用到的对象；
• 工具类对象；
• 频繁访问数据库或文件的对象。

#include <iostream>
#include <Windows.h>
#include <winnt.h>


using namespace std;

class EE
{
private:
	static EE *m_emperor;
	EE()
	{
		cout << "eeeee" << endl;
	}
	~EE(){}

	class cc
	{
	public:
		cc()
		{
			cout << "ccc" << endl;
		}
		~cc(){}
	};
	static cc m_cc;
	//static HANDLE m_mutexx;
};
EE::cc EE::m_cc;
EE* EE::m_emperor = NULL;
//HANDLE EE::m_mutexx = CreateMutex(NULL, FALSE, NULL);
class Emperor
{
public:
	static Emperor* getInstance();
	static void releaseInstance();
	void emperorInfo();
	void setEmperorTag(string tag);

private:
	Emperor()
	{
		cout << "create emperor instance" << endl;
	}
	virtual ~Emperor()
	{
		cout << "destroy emperor instance and release its resources" << endl;
	}

	Emperor(const Emperor&);

	Emperor& operator=(const Emperor&);

	static Emperor *m_emperor;
	static HANDLE m_mutex;
	string m_emperor_tag;	

	//这个Garbo内部类专门用来判断m_emperor和m_mutex
	class Garbo
	{
	public:
		Garbo()
		{
			cout << "carete garbo" << endl;
		}
		~Garbo()
		{
			cout << "destroy garbo" << endl;
			getchar();
			if (NULL != m_emperor)
			{
				//cout << "kong" << endl;
				WaitForSingleObject(m_mutex, INFINITE);
				if (NULL != m_emperor)
				{
					cout << "remove instance" << endl;
					delete m_emperor;
					m_emperor = NULL;
				}
				ReleaseMutex(m_mutex);
			}
			if (NULL != m_mutex)
			{
				cout << "delete mutex" << endl;
				CloseHandle(m_mutex);
				m_mutex = NULL;
			}
		}
	};	
	static Garbo m_garbo;
};

Emperor* Emperor::m_emperor = NULL;
HANDLE Emperor::m_mutex = CreateMutex(NULL, FALSE, NULL);
Emperor::Garbo Emperor::m_garbo;

Emperor* Emperor::getInstance()
{//获得m_emperor
	
	if (NULL == m_emperor)
	{
		WaitForSingleObject(m_mutex, INFINITE);
		if (NULL == m_emperor)
			m_emperor = new Emperor();
		ReleaseMutex(m_mutex);
	}
	
	return m_emperor;
	
}

void Emperor::releaseInstance()
{
	if (NULL != m_emperor)
	{
		WaitForSingleObject(m_mutex, INFINITE);
		if (NULL != m_emperor)
		{
			delete m_emperor;
			m_emperor = NULL;
		}
		ReleaseMutex(m_mutex);
	}
}

void Emperor::setEmperorTag(string tag)
{
	m_emperor_tag = tag;
}
void Emperor::emperorInfo()
{
	char msg_buf[50] = { 0 };
	sprintf_s(msg_buf, 50, "the emperor's name is (%s)", m_emperor_tag.c_str());
	string msg(msg_buf);
	cout << msg.c_str() << endl;
}

int main()
{
	
	Emperor *pEmperor1 = Emperor::getInstance();
	pEmperor1->setEmperorTag("QL");
	pEmperor1->emperorInfo();

	Emperor* pEmperor2 = Emperor::getInstance();
	pEmperor2->setEmperorTag("LLL");
	pEmperor2->emperorInfo();

	Emperor* pEmperor3 = Emperor::getInstance();
	pEmperor3->emperorInfo();

	Emperor::releaseInstance();
	getchar();
	
	return 0;

}