几种创建型的设计模式概析【上】——Factory模式， AbstractFactory模式，Singleton模式【C++实现】

Factory模式只适用于多个具有共同抽象基类的情况，在这种情况下，创建一个用基类的指针指向的子类对象是很吃力的，因为我们需要知道这个子类的名字，而对于大型项目来说，一个父类的子类是何其之多，而且通常情况下，每个程序员只负责其中某一个或某几个类的设计，对于子类的命名当然每个人都各有其好，如此以来，要创建一个新子类的工作是何其麻烦，可能要翻好多代码去领会它们做了什么，然后才能知道需要创建哪个子类。Factory模式就很好的解决了这个问题，它做要达到的目的就是将所有的子类的创建工作都封装到另外一个专门负责创建的类中，对外只预留接口，其UML描述如下所示：

 

Factory类的另一个给力特性是将创建工作推迟到了子类中，其本身只作为对外预留接口的抽象类，如此更好的实现了封装和多态。

以下是上图的C++源码示现：

 

#include <iostream> using namespace std; class Product { public: virtual ~Product()=0; protected: Product(); }; class ConcreteProduct:public Product { public: ~ConcreteProduct(); ConcreteProduct(); }; Product::Product() { } Product::~Product() { } ConcreteProduct::ConcreteProduct() { } ConcreteProduct::~ConcreteProduct() { } class Factory { public: virtual ~Factory()=0; virtual Product* CreateProduct()=0; protected: Factory(); }; class ConcreteFactory:public Factory { public: ConcreteFactory(); ~ConcreteFactory(); Product* CreateProduct(); }; Factory::Factory() { } Factory::~Factory() { } ConcreteFactory::ConcreteFactory() { cout<<"a new concrete facory has been build!"<<endl; } ConcreteFactory::~ConcreteFactory() { cout<<"a concrete factory has been destory!"<<endl; } Product* ConcreteFactory::CreateProduct() { cout<<"a product has been produced!"<<endl; return new ConcreteProduct(); } int main() { Factory *fac=new ConcreteFactory(); //create a concrete factory Product *pro=fac->CreateProduct(); //use the factroy which has been build to create instance of product! delete fac; delete pro; return 0; }  

 

AbstractFactory模式和Factory模式有所类似，但和Factory模式不完全相同，事实上，AbstractFactory模式的实现是利用的Factory模式。与Factory模式不同的是：AbstractFactory模式并不只负责和维护同一个基类下的子类的对象的生成，而是负责一组有依赖关系的类的实例的创建。以下是AbstractFactory模式的UML试图（图中ProductA1和ProductB1总是需要同时创建，ProductA2和ProductB2总是需要同时创建，于是可将其封装到2个特定的创建工程中）：

 

 

以下是上图的C++代码实现：

#include <iostream> using namespace std; class AbstractProductA { public: virtual ~AbstractProductA()=0; protected: AbstractProductA(); }; class ProductA1:public AbstractProductA { public: ProductA1(); ~ProductA1(); }; class ProductA2:public AbstractProductA { public: ProductA2(); ~ProductA2(); }; AbstractProductA::~AbstractProductA() { } AbstractProductA::AbstractProductA() { } ProductA1::~ProductA1() { cout<<"a ProductA1 has been destroyed!"<<endl; } ProductA1::ProductA1() { cout<<"a ProductA1 has been build!"<<endl; } ProductA2::~ProductA2() { cout<<"a ProductA2 has been destroyed!"<<endl; } ProductA2::ProductA2() { cout<<"a ProductA2 has been build!"<<endl; } class AbstractProductB { public: virtual ~AbstractProductB()=0; protected: AbstractProductB(); }; class ProductB1:public AbstractProductB { public: ProductB1(); ~ProductB1(); }; class ProductB2:public AbstractProductB { public: ProductB2(); ~ProductB2(); }; AbstractProductB::AbstractProductB() { } AbstractProductB::~AbstractProductB() { } ProductB1::ProductB1() { cout<<"a ProductB1 has been build!"<<endl; } ProductB1::~ProductB1() { cout<<"a ProductB1 has been destoryed!"<<endl; } ProductB2::ProductB2() { cout<<"a ProductB2 has been build!"<<endl; } ProductB2::~ProductB2() { cout<<"a ProductB2 has been destoryed!"<<endl; } class AbstractFactory { public: virtual AbstractProductA* CreateProductA()=0; virtual AbstractProductB* CreateProductB()=0; virtual ~AbstractFactory(); protected: AbstractFactory(); }; class Factory1:public AbstractFactory { public: AbstractProductA* CreateProductA(); AbstractProductB* CreateProductB(); Factory1(); ~Factory1(); }; class Factory2:public AbstractFactory { public: AbstractProductA* CreateProductA(); AbstractProductB* CreateProductB(); Factory2(); ~Factory2(); }; AbstractFactory::AbstractFactory() { } AbstractFactory::~AbstractFactory() { } AbstractProductA* Factory1::CreateProductA() { return new ProductA1; } AbstractProductB* Factory1::CreateProductB() { return new ProductB1; } Factory1::~Factory1() { } Factory1::Factory1() { } AbstractProductA* Factory2::CreateProductA() { return new ProductA2; } AbstractProductB* Factory2::CreateProductB() { return new ProductB2; } Factory2::~Factory2() { } Factory2::Factory2() { } int main() { AbstractFactory *fac1=new Factory1(); AbstractProductA *proA1=fac1->CreateProductA(); AbstractProductB *proB1=fac1->CreateProductB(); AbstractFactory *fac2=new Factory2(); AbstractProductA *proA2=fac2->CreateProductA(); AbstractProductB *proB2=fac2->CreateProductB(); delete fac1; delete fac2; delete proA1; delete proB1; delete proA2; delete proB2; return 0; }

 

由此我们可以看到，当我们需要创建一组相互依赖的对象（ProductA1,ProductB1)的时候，我们只需要维护一个创建对象（Factory1）即可，可大大简化维护的成本和工作。

 

Singleton模式较为简单，也很常用。记得以前一道面试题中问到：如何创建唯一的对象或变量？我当时理解为这个变量或对象只能创建一次，然后不能再次创建；事实上是自己对题目理解错了，试题本身在考察在面向对象思想中全局变量的处理能力，因为平时非面向对象程序中，我们习惯于把很多文件都用到的变量或对象设置成为全局变量或全局对象，而在面向对象程序设计中，对模块间的高耦合，低内聚要求是非常高的，不能再像非面向对象程序设计中那样为所欲为的设置全局对象或变量，因为这样会提高系统的维护难度和成本。比较标准的做法是将所有的全局对象或变量封装到一个具体的类中，当然，这些对象或变量必须是静态型的。下图是Singleton模型的的UML图示：

下面是上图的C++代码实现：

#include <iostream> using namespace std; class Singleton { static Singleton *_instance; public: static Singleton* Instance(); Singleton(); ~Singleton(); }; Singleton *Singleton::Instance() { if(_instance==NULL) { cout<<"Sington..."<<endl; return new Singleton(); } return _instance; } Singleton::Singleton() { } Singleton::~Singleton() { if(_instance==NULL) { return ; } delete _instance; } Singleton* Singleton::_instance = 0; int main() { Singleton *sgt=Singleton::Instance(); return 0; }