Factory && AbstractFactory

简单工厂:
简单工厂模式Simple Factory根据提供给它的数据，返回一个类的实例。通常它返回的类都有一个公共的父类（或者接口对象）

工厂方法：定义一个用于创建对象的接口，让接口子类通过工厂方法决定实例化哪一个类。

class Product{

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


};

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


class ConcreteFactory:public Factory{
public: 
~ConcreteFactory();
ConcreteFactory(){
}
Product *CreateProduct(){
return new ConcreteProduct();
}
};



int main(void){
    Factory *fac = new ConcreteFactory();
    Product *p = fac ->CreateProduct();
    return 0 ;

}

抽象工厂模式（Abstract Factory）
抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。（创建一组相关或者相互依赖的对象。）

//Product
class AbstractProductA{
public:
    virtual ~AbstractProductA(){}
protected:
    AbstractProductA(){}
};

class AbstractProductB{
public: 
    virtual ~AbstractProductB{}
protected:
     AbstractProductB{}
};
class ProductA1:public AbstractProductA{
public:
    ProductA1(){}
    ~ProductA1(){}
};

class ProductA2:public AbstractProductA{
public:
    ProductA2(){}
    ~ProductA2(){}
};

class ProductB1:public AbstractProductB{

public:
    ProductB1(){}
    ~ProductB1(){}
};


class ProductB2:public AbstractProductB{

public:
    ProductB2(){}
    ~ProductB2(){}
};

class AbstractFactory{
public:
    virtual ~AbstractFactory(){}
    virtual AbstractProductA* CreateProductA() =0;
    virtual AbstractProductB* CreateProductB() =0;
protected:
    AbstractFactory(){}

};

class ConcreteFactory1:public AbstractFactory{
public:
    Concretefactory1(){}
    ~ConcreteFactory1(){}
    AbstractProductA* CreateProductA(){
        return new ProductA1;
}
    AbstractProductB* CreateProductB(){}
        return new ProductB1;
};

class ConcreteFactory2:public AbstractFactory{
public:
    Concretefactory2(){}
    ~ConcreteFactory2(){}
    AbstractProductA* CreateProductA(){
        return new ProductA2;
}
    AbstractProductB* CreateProductB(){
        return new ProductB2;
}

};

int main(void){

    AbstractFactory *cf1 = new ConcreteFactory1();
    cf1 -> CreateProductA();
    cf1 -> CreateProductB();

        AbstractFactory *cf2 = new ConcreteFactory1();
    cf2 -> CreateProductA();
    cf2 -> CreateProductB();

    return 0;
}

区别

简单工厂 ： 用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力）

工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）
抽象工厂 ：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）