设计模式-工厂模式

* 2、工厂模式

伪代码1

ifndef _FACTORY_METHOD_

define _FACTORY_METHOD_

include 

include 

using namespace std;
抽象产品类：基类
class AbstractProduct{
public:
    AbstractProduct(){}构造函数
    virtual ~AbstractProduct(){}
    virtual void play(){};
};
具体产品类 子类
继承：实现 （继承抽象类）
class Basketball : public AbstractProduct{
    public: 
    Basketball(){
    play();
    }
    void play(){
    printf("XXXXX play basketball\n");
    }
};
抽象工厂
class AbstractFactory
{
    public:
         virtual ~AbstractFacory()；        
    返回值为抽象产品类
         virtual  AbstractProduct *getProduct()= 0;
    //纯虚函数写法,不写具体实现。
};

具体工厂类 
class BasketballFactory : public AbstractFactory{
    public:
    BasketballFactory(){
        printf("xxxx play basketball\n");
    }
    //通过具体产品子类、调用具体工厂类，返回值为生产出的具体产品。
    AbstractProduct* getProduct(){
        printf("basketball");
        return new Basketball();
    }
}

一个调用：
//定义工厂类对象和产品类对象
AbstractFactory * fac = NULL;
AbstractProduct* product = NULL;

通过调用具体工厂，完成对具体产品的生产。具体工厂返回值为具体产品。
fac = new BasketballFactory（）;获取具体工厂
product = fac->getProduct();使用具体工厂生产具体产品    

if (fac)
{
    delete fac;
}
if (product)
{
    delete fac;
}
注1：和简单工厂区别、简单工厂只有一个工厂类，如果增加产品，工厂类整体代码都要改
动，工厂模式增加产品，只需要增加具体工厂，改动的代码较小，耦合低。
注2：基类中 
析构函数需要加virtual 防止子类释放过程内存泄露。 
基类中方法加vritual 在对象实例化防止误指基类实现。
virtual void xxx() = 0; 纯虚函数写法。
注3：类末尾加";"起源 类：由C语音结构体演化得来。

伪代码2

include "ConcreteFactory.h"

include "ConcreteProduct.h"

由具体工厂，产生具体产品
Product* ConcreteFactory::factoryMethod(){
return new ConcreteProduct();
}

include "Factory.h"

include "ConcreteFactory.h"

include "Product.h"

include 

using namespace std;
int main (int argc, char argv[])
{
Factory* fac = newConcretaFactory();
Product* prod = fac->factoryMethod;
prod->use();
delete fac;
delete prod;
}
注：缺点：增加新产品需要增加新的工厂类。需要写具体产品+ 具体工厂。
优点：不需要改变旧的工厂和产品。