抽象工厂模式AbstractFactory（c++设计模式）

面试官：请你谈谈抽象工厂模式

• 从 简单工厂模式 说起，简单工厂模式通过设置工厂来模板化了大部分重复的创建产品代码，工厂通过参数来创建不同的产品。
• 由于这些参数得事先定义好，也就是说这工厂只能生产某些产品，如果我希望添加或者删除产品，需要对工厂进行修改，违背了 开闭原则，从而引入了 工厂方法模式 ，通过添加抽象工厂，每个工厂负责一种产品的创建，但这样工厂类会特别多，增加了系统开销。
• 所以就有了抽象工厂模式，抽象工厂模式里每个工厂负责一个产品族的创建，也就是引入了抽象产品跟抽象工厂的结合。

抽象工厂模式的开闭原则倾斜性

对于新增产品族，相当于新增了一个生产产品的商家，此时符合开闭原则；
但对于新增产品等级结构时，也就是新增产品时，此时不符合开闭原则。

抽象工厂模式代码

/*
 * @ Description: C++ Design Patterns___Abstract Factory
 * @ version: v1.0
 * @ Author: WeissxJ
 */

#include<iostream>
class ProductA                  //抽象产品A
{
    
    
    public:
        virtual ~ProductA() {
    
    }
        virtual const char * getName()=0;
        // ...
};

class ConcreteProductAX : public ProductA   //具体产品X
{
    
    
    public:
        ~ConcreteProductAX() {
    
    }
        const char* getName(){
    
    
            return "A->X";
        }
        // ...
};

class ConcreteProductAY : public ProductA   //具体产品Y
{
    
    
    public:
        ~ConcreteProductAY() {
    
    }
        const char* getName(){
    
    
            return "A->Y";
        }
        // ...
};

class ProductB
{
    
    
    public:
        virtual ~ProductB() {
    
    }
        virtual const char * getName()=0;
        // ...
};

class ConcreteProductBX : public ProductB
{
    
    
    public:
        ~ConcreteProductBX() {
    
    }
        const char* getName(){
    
    
            return "B->X";
        }
        // ...
};

class ConcreteProductBY : public ProductB
{
    
    
    public:
        ~ConcreteProductBY() {
    
    }
        const char* getName(){
    
    
            return "B->Y";
        }
        // ...
};

class AbstractFactory
{
    
    
    public:
        virtual ~AbstractFactory() {
    
    }
        virtual ProductA* createProductA()=0;
        virtual ProductB* createProductB()=0;
};

class ConcreteFactoryX : public AbstractFactory
{
    
    
    public:
        ~ConcreteFactoryX() {
    
    }
        ProductA *createProductA(){
    
    
            return new ConcreteProductAX();
        }
        ProductB *createProductB(){
    
    
            return new ConcreteProductBX();
        }
        // ...
};

class ConcreteFactoryY : public AbstractFactory
{
    
    
    public:
        ~ConcreteFactoryY() {
    
    }
        ProductA *createProductA(){
    
    
            return new ConcreteProductAY();
        }
        ProductB *createProductB(){
    
    
            return new ConcreteProductBY();
        }
        // ...
};

int main(){
    
    
    ConcreteFactoryX *factoryX = new ConcreteFactoryX();
    ConcreteFactoryY *factoryY = new ConcreteFactoryY();

    ProductA *p1 = factoryX->createProductA();
    std::cout << "Product: " << p1->getName() << std::endl;
  
    ProductA *p2 = factoryY->createProductA();
    std::cout << "Product: " << p2->getName() << std::endl;
  
    delete p1;
    delete p2;
    
    delete factoryX;
    delete factoryY;
  
    return 0;
}