Sigleton模式

意图：保证一个类仅有一个实例，并且提供一个访问它的全局访问点。让类自身负责保存它的唯一实例。

Sigleton.h文件中：

#include <iostream>
#include <memory>
using namespace std;

enum TypeName
{
	__Sigleton,
	__SigletonDerivedClass1,
	__SigletonDerivedClass2
};

class Sigleton
{
public:
	static Sigleton* Instance(enum TypeName name=__Sigleton);
	virtual void doSomething()
	{
		cout<<"Sigleton::doSomething()"<<endl;
	}
protected:
	Sigleton() { }
	Sigleton(const Sigleton&);
	Sigleton& operator=(const Sigleton&);
};

class SigletonDerivedClass1:public Sigleton
{
public:
	void doSomething()
	{
		cout<<"SigletonDerivedClass1::doSomething()"<<endl;
	}
private:
	friend class Sigleton;
	SigletonDerivedClass1() { }
};

class SigletonDerivedClass2:public Sigleton
{
public:
	void doSomething()
	{
		cout<<"SigletonDerivedClass2::doSomething()"<<endl;
	}
private:
	friend class Sigleton;
	SigletonDerivedClass2() { }
};

Sigleton.cpp文件：

#include "Sigleton.h"

Sigleton* Sigleton::Instance(enum TypeName name)
{
	switch(name)
	{
	case __SigletonDerivedClass1:
		{
			static SigletonDerivedClass1 __instance;
			return &__instance;
		}
		break;
	case __SigletonDerivedClass2:
		{
			static SigletonDerivedClass2 __instance;
			return &__instance;
		}
		break;
	}
	
	static Sigleton __instance;

	return &__instance;
}

 

在测试的main函数中这样使用：

Sigleton* s1=Sigleton::Instance(__SigletonDerivedClass1);
s1->doSomething();
Sigleton* s2=Sigleton::Instance(__SigletonDerivedClass1);
s2->doSomething();
if(s1==s2)
    cout<<"sigleton"<<endl;

较四大天王的例子，我做了一些改变，主要在Instance函数中。

这样既不会出现内存泄路，又是线程安全的。而且在调用的时候，会根据不同的参数生成不同的子类的唯一的实例。

起初不太明白单实例设计模式的应用场景，一个系统，应该只有一个文件系统和一个窗口管理器。

论坛也有人提到，他的程序中要从配置文件提取一些配置信息，这样的对象应该只有一个。对于不同的配置信息可以创建不同的派生类。

在《More Effective C++》中，看到这样的一个例子，假设只有一台打印机，系统中则只允许存在一个打印机的对象，此时就要用到此模式。

如果同时有一台普通的打印机，还有一台彩色的打印机，则会用到彩色打印机派生自普通打印机，会用到我的实现代码的情况。

在以后的工作和学习中，慢慢的体会。