《设计模式》笔记：Singleton设计难点

　　Singleton看上去是一个十分简单的设计模式。但事实上，要深究的话，你会发现Singleton也不好设计。

　　最简单的Singleton模式莫过于用静态类成员函数和静态类成员变量来实现了。但这样做有两个缺点：

　　　　1）后期难以改变设计；

　　　　2）不管需不需要，由于是静态成员，必须要初始化。

　　一般书籍上给出的设计方法是（lazy initialization）的做法 ：

//================================================================
//Singleton
class Singleton{
private:
	Singleton(){};
	Singleton(const Singleton&){};
	Singleton& operator=(Singleton&){};
public:
	static Singleton* Instance();
	static Singleton* Instance(string &);
	virtual void name(){cout<<"father Singleton"<<endl;};
private:
	static Singleton * _instance;
};

Singleton *Singleton::_instance=0;

Singleton *Singleton::Instance(){
	if(_instance==0){
		_instance=new Singleton;
	}
	return _instance;
}

　　但是，这样的设计有个缺陷，static方法不能继承，所以不能是虚拟函数，从而Instance不能用多态来生成不同的类类型。这样的Singleton这只是一个类层次（level）上的单件，不能成为一个类层次体系（inheritance hierachy）上的单件。这是用类成员函数实现单件的必然缺点。

　　如果我们需要一个类层次体系（inheritance hierachy）上的单件，那么有什么改进方法吗？有两个方法：
　　1.重载父类中Instance函数，做类型判断，可以传入一个ID或字符串作为判断依据，生成对应的单件类型。代码如下：

Singleton *Singleton::Instance(string& name){
	//There should be some item-type comparison here.
	if(_instance==0){
		if(name=="A")
			_instance=new SingletonChildA;
		else if(name=="B")
			_instance=new SingletonChildB;
		else
			_instance=new Singleton;
	}
	return _instance;
}

　　子类定义（为了实现继承，要将父类Singlton中的构造函数改为protected！）：

class SingletonChildA:public Singleton
{
public:
	void virtual name(){cout<<"A"<<endl;}
};
class SingletonChildB:public Singleton
{
public:
	void virtual name(){cout<<"B"<<endl;}
};

　　然而，这样做有一个致命的缺点，就是子类的构造函数要为public！因为父类要调用子类的构造函数。

　　2.给每个子类添加一个Instance方法，同父类的Instance方法一样，生成对应的子类类型。

　　这样做可以保证子类的构造函数为私有。但我们要生成单件实例时，我们必须要指明特定的类型。即SingletonX::Instance()。比起Singleton::Instance(string &)的做法，缺乏可拓展性。Singleton::Instance(string &)保证了接口的统一。更优化和可拓展的的方法还可以不用条件语句进行类型判断，而是建立一个单件注册表。通过查表来进行类型判断。

　　可见，方法1优于方法2。可是子类的构造函数要为public是硬伤。可以将父类的Instance(String &)注册为子类的友元函数（或直接将父类声明为子类友元）来解决这个问题。虽然这严重违背了封装性，但似乎是唯一可行的办法。