设计模式（C++版）之(factory)工厂模式

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，（将界面与逻辑分离）达到提高灵活性的目的。

************************************************
工厂模式在《Java与模式》中分为三类：
1）简单工厂模式（Simple Factory）：不利于产生系列产品；
2）工厂方法模式（Factory Method）：又称为多形性工厂；
3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品；
             这三种模式从上到下逐步抽象，并且更具一般性。
             GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。
**********************
一、简单工厂模式(Simple Factory Pattern)：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态(static)方法，因此简单工厂模式又被称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。
命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。
在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化, 如同一个交通警察站在来往的车辆流中,决定放行那一个方向的车辆向那一个方向流动一样。

简单工厂模式结构图：

       在简单工厂模式结构图中包含如下几个角色：

       ● Factory（工厂角色）：工厂角色即工厂类，它是简单工厂模式的核心，负责实现创建所有产品实例的内部逻辑；工厂类可以被外界直接调用，创建所需的产品对象；在工厂类中提供了静态的工厂方法factoryMethod()，它的返回类型为抽象产品类型Product。

       ● Product（抽象产品角色）：它是工厂类所创建的所有对象的父类，封装了各种产品对象的公有方法，它的引入将提高系统的灵活性，使得在工厂类中只需定义一个通用的工厂方法，因为所有创建的具体产品对象都是其子类对象。

       ● ConcreteProduct（具体产品角色）：它是简单工厂模式的创建目标，所有被创建的对象都充当这个角色的某个具体类的实例。每一个具体产品角色都继承了抽象产品角色，需要实现在抽象产品中声明的抽象方法。

       在简单工厂模式中，客户端通过工厂类来创建一个产品类的实例，而无须直接使用new关键字来创建对象，它是工厂模式家族中最简单的一员。

       在使用简单工厂模式时，首先需要对产品类进行重构，不能设计一个包罗万象的产品类，而需根据实际情况设计一个产品层次结构，将所有产品类公共的代码移至抽象产品类，并在抽象产品类中声明一些抽象方法，以供不同的具体产品类来实现

***************************
代码：
#include <iostream>
#include <string>
using namespace std;

// 抽象类
class Product
{
public:
    virtual void showName() = 0;
};

//产品A
class ConcreteProductA: public Product
{
public:
   ConcreteProductA():name("ConcreteProductA"){}
   void showName()
   {
       cout<<name<<endl;
   }

private:
    string name;
};

//产品B
class ConcreteProductB: public Product
{
public:
   ConcreteProductB():name("ConcreteProductB"){}
   void showName()
   {
       cout<<name<<endl;
   }

private:
    string name;
};
//

class Factory
{
public:
    Product* createProduct(char type)
    {
       Product* pt = NULL;//父类指针
       switch(type)
       {
           case 'A':
                pt =  new ConcreteProductA();
                pt->showName();//多态，调用的是类ConcreteProductA的showName()
                break;
            case 'B':
                pt = new ConcreteProductB();
                pt->showName();//多态，调用的是类ConcreteProductB的showName()
                break;
            default:
                return NULL;
       }
    }

private:
    //Product* pt;
};

//主函数
int main()
{
    Factory *fp = new Factory();
    fp->createProduct('A');
    fp->createProduct('B');
    return 0;
}


***************************
二、工厂方法模式(Factory Method Pattern)：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。工厂方法模式又简称为工厂模式(Factory Pattern)，又可称作虚拟构造器模式(Virtual Constructor Pattern)或多态工厂模式(Polymorphic Factory Pattern)。工厂方法模式是一种类创建型模式。

工厂方法模式提供一个抽象工厂接口来声明抽象工厂方法，而由其子类来具体实现工厂方法，创建具体的产品对象。。工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。

工厂方法模式结构图：

       在工厂方法模式结构图中包含如下几个角色：

       ● Product（抽象产品）：它是定义产品的接口，是工厂方法模式所创建对象的超类型，也就是产品对象的公共父类。

       ● ConcreteProduct（具体产品）：它实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，具体工厂和具体产品之间一一对应。

       ● Factory（抽象工厂）：在抽象工厂类中，声明了工厂方法(Factory Method)，用于返回一个产品。抽象工厂是工厂方法模式的核心，所有创建对象的工厂类都必须实现该接口。

       ● ConcreteFactory（具体工厂）：它是抽象工厂类的子类，实现了抽象工厂中定义的工厂方法，并可由客户端调用，返回一个具体产品类的实例。

       与简单工厂模式相比，工厂方法模式最重要的区别是引入了抽象工厂角色，抽象工厂可以是接口，也可以是抽象类或者具体类。

       工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品（即暴发户的汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代 码。可以看出工厂角色的结构也是符合开闭原则的！
*************************
代码实现：
#include <iostream>
#include <string>
using namespace std;

//
class Product
{
public:
    virtual void showName() = 0;
};
//
class ConcreteProductA: public Product
{
public:
   ConcreteProductA():name("ConcreteProductA"){}
   void showName()
   {
       cout<<name<<endl;
   }
private:
    string name;
};
//
class ConcreteProductB: public Product
{
public:
   ConcreteProductB():name("ConcreteProductB"){}
   void showName()
   {
       cout<<name<<endl;
   }
private:
    string name;
};
//

class Factory
{
public:
    virtual Product* createProduct() = 0;
private:
    //Product* pt;
};

class FactoryA: public Factory
{
public:
    Product* createProduct()
    {
        Product* pt = NULL;
        pt = new ConcreteProductA();
        pt->showName();
        return pt;
    }
private:

};

class FactoryB: public Factory
{
public:
    Product* createProduct()
    {
        Product* pt = NULL;
        pt = new ConcreteProductB();
        pt->showName();
        return pt;
    }
private:

};
//***************************
int main()
{
    FactoryA *fap = new FactoryA();
    fap->createProduct();
    /////////
    FactoryB *fbp = new FactoryB();
    fbp->createProduct();

    return 0;
}


*************************
三、抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，它是一种对象创建型模式。
提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，它是一种对象创建型模式。在抽象工厂中声明了多个工厂方法，用于创建不同类型的产品，抽象工厂可以是接口，也可以是抽象类或者具体类。
在抽象工厂模式中，抽象产品 (AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。

抽象工厂模式结构图：

       在抽象工厂模式结构图中包含如下几个角色：

       ● AbstractFactory（抽象工厂）：它声明了一组用于创建一族产品的方法，每一个方法对应一种产品。

       ● ConcreteFactory（具体工厂）：它实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。

       ● AbstractProduct（抽象产品）：它为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。

       ● ConcreteProduct（具体产品）：它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。

**************************************

代码实现：

#include <iostream>
using namespace std;

//////////////////////////////////////////////////////////////////////////
//product A
class AbstractProductA
{
public:
    AbstractProductA(){}
    virtual ~AbstractProductA(){}
};


class ConceteProductA1: public AbstractProductA
{
public:
    ConceteProductA1(){cout<<"ConceteProductA1..."<<endl;}
    ~ConceteProductA1(){}
};


class ConceteProductA2: public AbstractProductA
{
public:
    ConceteProductA2(){cout<<"ConceteProductA2..."<<endl;}
    ~ConceteProductA2(){}
};


//////////////////////////////////////////////////////////////////////////
//product B
class AbstractProductB
{
public:
    AbstractProductB(){}
    virtual ~AbstractProductB(){}
};


class ConceteProductB1: public AbstractProductB
{
public:
    ConceteProductB1(){cout<<"ConceteProductB1..."<<endl;}
    ~ConceteProductB1(){}
};


class ConceteProductB2: public AbstractProductB
{
public:
    ConceteProductB2(){cout<<"ConceteProductB2..."<<endl;}
    ~ConceteProductB2(){}
};


//////////////////////////////////////////////////////////////////////////
// factory
class Factory
{
public:
    Factory(){}
    virtual ~Factory(){}
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};


class ConcreteFactory1: public Factory
{
public:
    ConcreteFactory1(){}
    ~ConcreteFactory1(){}
    
    AbstractProductA* createProductA()
    {
        return new ConceteProductA1();
    }


    AbstractProductB* createProductB()
    {
        return new ConceteProductB1();
    }
};


class ConcreteFactory2: public Factory
{
public:
    ConcreteFactory2(){}
    ~ConcreteFactory2(){}


    AbstractProductA* createProductA()
    {
        return new ConceteProductA2();
    }


    AbstractProductB* createProductB()
    {
        return new ConceteProductB2();
    }
};
//////////////////////////////////////////////////////////////////////////


int main()
{
    Factory* fp1 = new ConcreteFactory1();
    fp1->createProductA();
    fp1->createProductB();


    Factory* fp2 = new ConcreteFactory2();
    fp2->createProductA();
    fp2->createProductB();


    return 0;
}

****************************
注：
简单工厂和工厂方法模式的比较
工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。 
反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。
****************************************************

下面一个个介绍，首先介绍简单工厂模式，它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。有点抽象，举个例子就明白了。有一家生产处理器核的厂家，它只有一个工厂，能够生产两种型号的处理器核。客户需要什么样的处理器核，一定要显示地告诉生产工厂。下面给出一种实现方案。

enum CTYPE {COREA, COREB};   class SingleCore  {  public:      virtual void Show() = 0;};  //单核A  class SingleCoreA: public SingleCore  {  public:      void Show() { cout<<"SingleCore A"<<endl; }  };  //单核B  class SingleCoreB: public SingleCore  {  public:      void Show() { cout<<"SingleCore B"<<endl; }  };  //唯一的工厂，可以生产两种型号的处理器核，在内部判断  class Factory  {  public:       SingleCore* CreateSingleCore(enum CTYPE ctype)      {          if(ctype == COREA) //工厂内部判断              return new SingleCoreA(); //生产核A          else if(ctype == COREB)              return new SingleCoreB(); //生产核B          else              return NULL;      }  };  

这样设计的主要缺点之前也提到过，就是要增加新的核类型时，就需要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。于是，工厂方法模式出现了。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

       听起来很抽象，还是以刚才的例子解释。这家生产处理器核的产家赚了不少钱，于是决定再开设一个工厂专门用来生产B型号的单核，而原来的工厂专门用来生产A型号的单核。这时，客户要做的是找好工厂，比如要A型号的核，就找A工厂要；否则找B工厂要，不再需要告诉工厂具体要什么型号的处理器核了。下面给出一个实现方案。

class SingleCore  {  public:      virtual void Show() = 0;};  //单核A  class SingleCoreA: public SingleCore  {  public:      void Show() { cout<<"SingleCore A"<<endl; }  };  //单核B  class SingleCoreB: public SingleCore  {  public:      void Show() { cout<<"SingleCore B"<<endl; }  };  class Factory  {  public:      virtual SingleCore* CreateSingleCore() = 0;};  //生产A核的工厂  class FactoryA: public Factory  {  public:      SingleCoreA* CreateSingleCore() { return new SingleCoreA; }  };  //生产B核的工厂  class FactoryB: public Factory  {  public:      SingleCoreB* CreateSingleCore() { return new SingleCoreB; }  };  

工厂方法模式也有缺点，每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的处理器核，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。

       既然有了简单工厂模式和工厂方法模式，为什么还要有抽象工厂模式呢？它到底有什么作用呢？还是举这个例子，这家公司的技术不断进步，不仅可以生产单核处理器，也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。具体这样应用，这家公司还是开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另一个工厂专门用来生产B型号的单核多核处理器，下面给出实现的代码。

//单核  class SingleCore   {  public:      virtual void Show() = 0;};  class SingleCoreA: public SingleCore    {  public:      void Show() { cout<<"Single Core A"<<endl; }  };  class SingleCoreB :public SingleCore  {  public:      void Show() { cout<<"Single Core B"<<endl; }  };  //多核  class MultiCore    {  public:      virtual void Show() = 0;};  class MultiCoreA : public MultiCore    {  public:      void Show() { cout<<"Multi Core A"<<endl; }    };  class MultiCoreB : public MultiCore    {  public:      void Show() { cout<<"Multi Core B"<<endl; }  };  //工厂  class CoreFactory    {  public:      virtual SingleCore* CreateSingleCore() = 0;    virtual MultiCore* CreateMultiCore() = 0;};  //工厂A，专门用来生产A型号的处理器  class FactoryA :public CoreFactory  {  public:      SingleCore* CreateSingleCore() { return new SingleCoreA(); }      MultiCore* CreateMultiCore() { return new MultiCoreA(); }  };  //工厂B，专门用来生产B型号的处理器  class FactoryB : public CoreFactory  {  public:      SingleCore* CreateSingleCore() { return new SingleCoreB(); }      MultiCore* CreateMultiCore() { return new MultiCoreB(); }  }; 

  至此，工厂模式介绍完了。利用Rational Rose 2003软件，给出三种工厂模式的UML图，加深印象。

         简单工厂模式的UML图：

         工厂方法的UML图：

         抽象工厂模式的UML图：

 代码出处 http://blog.csdn.net/wuzhekai1985

总结。
（1）简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。 
（2）工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。 
（3）抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。