工厂模式

1）简单工厂模式：

     主要特定是需要在工厂类中做判断，从而创造相应的产品，当增加新产品时，需要修改工厂类。

typedef enum  
{  
    T80 = 1,  
    T99  
}TankType;  
  
class Tank  
{  
public:  
    virtual void message() = 0;  
};  
  
class Tank80:public Tank  
{  
public:  
    void message()  
    {  
        cout << "Tank80" << endl;  
    }  
};  
  
class Tank99:public Tank  
{  
public:  
    void message()  
    {  
        cout << "Tank99" << endl;  
    }  
};  
  
class TankFactory  
{  
public:  
    Tank* createTank(TankType type)  
    {  
        switch(type)  
        {  
        case 1:  
            return new Tank80();  
        case 2:  
            return new Tank99();  
        default:  
            return NULL;  
        }  
    }  
};  

2）工厂方法模式

   是指定义一个创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到其子类。

   意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

   主要解决：主要解决接口选择的问题。

   何时使用：我们明确地计划不同条件下创建不同实例时。

   如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

   关键代码：创建过程在其子类执行。

   缺点：每增加一种产品，就需要增加一个对象工厂。相比简单工厂模式，工厂方法模式需要定义更多的类

class Tank  
{  
public:  
    virtual void message() = 0;  
};  
  
class Tank80:public Tank  
{  
public:  
    void message()  
    {  
        cout << "Tank80" << endl;  
    }  
};  
  
class Tank99:public Tank  
{  
public:  
    void message()  
    {  
        cout << "Tank99" << endl;  
    }  
};  
  
class TankFactory  
{  
public:  
    virtual Tank* createTank() = 0;  
};  
  
class Tank80Factory:public TankFactory  
{  
public:  
    Tank* createTank()  
    {  
        return new Tank80();  
    }  
};  
  
class Tank99Factory:public TankFactory  
{  
public:  
    Tank* createTank()  
    {  
        return new Tank99();  
    }  
};  

3).抽象工厂模式

   提供一个创建一系列相关或相互依赖的对象接口，而无需指定它们的具体类。

   意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

   主要解决：主要解决接口选择的问题。

   何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

   如何解决：在一个产品族里面，定义多个产品。

  关键代码：在一个工厂里聚合多个同类产品。

  缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

class Tank  
{  
public:  
    virtual void message() = 0;  
};  
  
class Tank80:public Tank  
{  
public:  
    void message()  
    {  
        cout << "Tank80" << endl;  
    }  
};  
  
class Tank99:public Tank  
{  
public:  
    void message()  
    {  
        cout << "Tank99" << endl;  
    }  
};  
  
class Plain  
{  
public:  
    virtual void message() = 0;  
};  
  
class Plain80: public Plain  
{  
public:  
    void message()  
    {  
        cout << "Plain80" << endl;  
    }  
};  
  
class Plain99: public Plain  
{  
public:  
    void message()  
    {  
        cout << "Plain99" << endl;  
    }  
};  
  
class Factory  
{  
public:  
    virtual Tank* createTank() = 0;  
    virtual Plain* createPlain() = 0;  
};  
  
class Factory80:public Factory  
{  
public:  
    Tank* createTank()  
    {  
        return new Tank80();  
    }  
    Plain* createPlain()  
    {  
        return new Plain80();  
    }  
};  
  
class Factory99:public Factory  
{  
public:  
    Tank* createTank()  
    {  
        return new Tank99();  
    }  
    Plain* createPlain()  
    {  
        return new Plain99();  
    }  
};  

参考：

https://www.yuque.com/docs/share/82d74531-c34c-45af-a9a5-41e35c140693