简单工厂，工厂方法，抽象工厂 三种设计模式的区别和实例

简单工厂：

一个产品抽象类，可以派生很多具体产品类。

一个具体工厂类，可以创建多种具体的产品实例。

工厂方法：

一个抽象产品类，可以派生很多具体产品类。

一个抽象工厂类，可以派生很多具体工厂类。

每一个具体工厂可以创建多种具体的产品实例

抽象工厂类：

一个抽象产品类，可以派生很多产品基类。

每一个产品基类可以派生很多具体产品类

一个抽象工厂类，可以派生很多具体工厂类。

每一个具体工厂类可以创建多种具体的产品实例。

实例代码，用QT实现

#include <QtCore/QCoreApplication>
#include <QDebug>
class product
{
  protected:
    product(void)
    {
      qDebug()<<"construct product";
    }
  public:
    virtual ~product(void)
    {
       qDebug()<<"destroy product";
    }
  public:
    virtual void Function()=0;
};


class CreateProductA:public product
{
  public:
    CreateProductA(void)
    {
       qDebug()<<"construct CreateProductA";
    }
 public:
    virtual ~CreateProductA(void)
   {
      qDebug()<<"destroy CreateProductA";
   }
  public:
    virtual void Function()
    {
        qDebug()<<"CreateProductA Function";
    }
};


class CreateProductA1:public CreateProductA
{
  public:
    CreateProductA1(void)
    {
       qDebug()<<"construct CreateProductA1";
    }
 public:
    virtual ~CreateProductA1(void)
   {
      qDebug()<<"destroy CreateProductA1";
   }
  public:
    virtual void Function()
    {
        qDebug()<<"CreateProductA Function";
    }
};




class CreateProductB:public product
{
  public:
    CreateProductB(void)
    {
       qDebug()<<"construct CreateProductB";
    }
 public:
    virtual ~CreateProductB(void)
   {
      qDebug()<<"destroy CreateProductB";
   }
  public:
    virtual void Function()
    {
        qDebug()<<"CreateProductB Function";
    }
};


class CreateProductB1:public CreateProductB
{
  public:
    CreateProductB1(void)
    {
       qDebug()<<"construct CreateProductB1";
    }
 public:
    virtual ~CreateProductB1(void)
   {
      qDebug()<<"destroy CreateProductB1";
   }
  public:
    virtual void Function()
    {
        qDebug()<<"CreateProductB Function";
    }
};


class SimplyFactory
{
  public:
    SimplyFactory(){}
    ~SimplyFactory(){}
  public:
    product *createProduct(int productType)
    {
       product *p = 0;
       switch(productType)
       {
         case 0:
           p= new CreateProductA();
         break;
       case 1:
         p= new CreateProductB();
       break;
       default:
         p= new CreateProductA();
       break;
       }
       return p;
    }
    product *CreateProA()
    {
        return new CreateProductA();
    }
    product *CreateProB()
    {


       return new CreateProductB();


    }
};


class FactoryWay
{
   public:
    FactoryWay(void)
    {
       qDebug()<<"construct FactoryWay";
    }
    virtual ~FactoryWay(void)
    {
      qDebug()<<"destroy FactoryWay";
    }
    virtual product* CreatePro(int ProductType=0)=0;
};


class CreateFactory1:public FactoryWay
{
  public:
    CreateFactory1()
    {
        qDebug()<<"construct CreateFactory1";
    }
    ~CreateFactory1()
    {
       qDebug()<<"Destory CreateFactory1";
    }
    product* CreatePro(int ProductType)
    {
       product *p =0;
       switch(ProductType)
       {
         case 0:
           p= new CreateProductA();
           break;
        case 1:
         p= new CreateProductB();
         break;
       default:
         p= new CreateProductA();
         break;
       }
       return p;
    }
};




class CreateFactory2:public FactoryWay
{
  public:
    CreateFactory2()
    {
        qDebug()<<"construct CreateFactory2";
    }
    ~CreateFactory2()
    {
       qDebug()<<"Destory CreateFactory2";
    }
    product* CreatePro(int ProductType)
    {
       product *p =0;
       switch(ProductType)
       {
         case 0:
           p= new CreateProductA();
           break;
        case 1:
         p=  new CreateProductB();
         break;
       default:
         p=  new CreateProductA();
         break;
       }
       return p;
    }
};




class AbstractFactory
{
  public:
    AbstractFactory()
    {
        qDebug()<<"construct AbstractFactory";
    }
    virtual ~AbstractFactory()
    {
      qDebug()<<"destroy AbstractFactory";
    }
  public:
    virtual CreateProductA* CreatA() =0;
    virtual CreateProductB* CreatB() =0;
};


class CreateAbstractFactory1:public AbstractFactory
{
  public:
    CreateAbstractFactory1()
    {
        qDebug()<<"construct CreateAbstractFactory1";
    }
    virtual ~CreateAbstractFactory1()
    {
      qDebug()<<"destroy CreateAbstractFactory1";
    }
  public:
    virtual CreateProductA* CreatA()
    {
        CreateProductA *q;
        q= new CreateProductA1();
        return q ;
    }
    virtual CreateProductB* CreatB()
    {
        CreateProductB *p;
        p= new CreateProductB1();
        return p ;


    }
};


class CreateAbstractFactory2:public AbstractFactory
{
  public:
    CreateAbstractFactory2()
    {
        qDebug()<<"construct CreateAbstractFactory2";
    }
    virtual ~CreateAbstractFactory2()
    {
      qDebug()<<"destroy CreateAbstractFactory2";
    }
  public:
    virtual CreateProductA* CreatA()
    {
        CreateProductA *p;
        p= new CreateProductA1();
        return p ;
    }
    virtual CreateProductB* CreatB()
    {
        CreateProductB *p;
        p= new CreateProductB1();
        return p ;


    }
};


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

//简单工厂
    SimplyFactory sf;
   product *p1 = sf.CreateProA();
    p1->Function();
    delete p;
    p1= sf.CreateProB();
   p1->Function();
    delete p1;

//工厂方法
    FactoryWay *fct = new CreateFactory1();
    product *p2 = fct->CreatePro(0);
   p2->Function();
    delete p2;
    p2= fct->CreatePro(2);
    p2->Function();
    delete p2;
    fct = new CreateFactory2();
    p2= fct->CreatePro();
    delete p2;
    delete fct;

//抽象工厂
    AbstractFactory *absfct = new CreateAbstractFactory1();
    CreateProductA *cpa = absfct->CreatA();
    cpa->Function();
    delete cpa;
    CreateProductB *cpb = absfct->CreatB();
    cpb->Function();
    delete cpb;
    delete absfct;
    absfct = new CreateAbstractFactory2();
    cpa = absfct->CreatA();
    delete cpa;
    cpb = absfct->CreatB();
    cpb->Function();
    delete cpb;

    return a.exec();
}