设计模式系列（二）——Factory模式 工厂模式

Factory模式 工厂模式

问题场景：

• 我们经常会抽象出一些类的公共接口以形成抽象基类或者接口很容易出现的一个问题N多的子类继承自抽象类。
• 在父类中不知道具体要实例化哪一个具体的子类、

Factory的最重要的两个功能：

• 定义创建对象的接口，封装了对象的创建
• 使具体化类的工作延迟到了子类中

模式选择：

• 在第一个问题中，我们经常就是声明一个创建对象的接口，并封装了对象的创建过程
• 在第二个过程中，我们需要提供一个对象创建对象的接口。并在子类中提供具体实现(因为只有在子类中可以决定到底实例化哪一个类)

完整代码

//Product.h

#ifndef _PRODUCT_H_
#define _PRODUCT_H_

#include
using namespace std;

class Product
{
  public:
  virtual ~Product() =0;
  protected:
  Product();

};

class ConecreateProduct:publicProduct
{
  public:
  ~ConecreateProduct();
  ConecreateProduct();
};
#endif

//Product.cpp
#include "Product.h"

Product::Product()
{

}

Product::~Product()
{

}

ConecreateProduct::ConecreateProduct()
{
  cout<<"ConecreateProduct..."<

//Factory.h

#ifndef _FACTORY_H_
#define _FACTORY_H_

#include "Product.h"
#include
using namespace std;

class Product;

class Factory{
  public:
  virtual ~Factory() = 0;
  virtual Product* CreateProduct()= 0;

  protected:
  Factory();

};

class ConcreateFactory:public Factory{
  public:
  ~ConcreateFactory();
  ConcreateFactory();
  Product* CreateProduct();

};
#endif

#include "Factory.h"

Factory::Factory(){

}

Factory::~Factory(){

}

ConcreateFactory::ConcreateFactory()
{
  cout<<"ConcreateFactory..."<return new ConcreateProduct();
}

//main.cpp

#include "Factory.h"

int main(int argc,char** argv)
{
  Factory* fac = new ConcreateFactory();
  Product* p = fac->CreateProduct();
  return 0;
}

示例代码中给出的是 Factory 模式解决父类中并不知道具体要实例化哪一个具体的子类的问题，至于为创建对象提供接口问题，可以由 Factory 中附加相应的创建操作例如Create***Product()即可。

带来的问题

Factory 模式也带来至少以下两个问题：

• 如果为每一个具体的 ConcreteProduct 类的实例化提供一个函数体，那么我们可能不得不在系统中添加了一个方法来处理这个新建的ConcreteProduct，这样Factory就不可能封闭。

• 在实现中我们可以通过参数化工厂方法，即给 FactoryMethod（）传递一个参数用以决定是创建具体哪一个具体的 Product 。当中的子类创建子类，其方法就是将具体 Product 类作为模板参数，实现起来也很简单。

可以看出， Factory 模式对于对象的创建给予开发人员提供了很好的实现策略，但是Factory 模式仅仅局限于一类类（就是说 Product 是一类，有一个共同的基类），如果我们要为不同类的类提供一个对象创建的接口，那就要用 AbstractFactory 了。