Patrón de fábrica abstracto AbstractFactory (patrón de diseño c ++)

Entrevistador: Hable sobre el modelo de fábrica abstracto

• A partir del modelo de fábrica simple , el modelo de fábrica simple incluyó la mayor parte de la creación repetida de códigos de producto configurando la fábrica, y la fábrica crea diferentes productos a través de parámetros.
• Porque estos parámetros tienen que estar definidos de antemano, es decir, esta fábrica solo puede producir ciertos productos. Si quiero agregar o eliminar productos, necesito modificar la fábrica, lo que viola el principio de apertura y cierre , y así introduce el patrón del método de fábrica agregando abstracción. Fábrica, cada fábrica es responsable de la creación de un producto, pero de esta manera habrá muchas clases de fábrica, lo que aumenta la sobrecarga del sistema.
• Entonces está el modelo de fábrica abstracta En el modelo de fábrica abstracta, cada fábrica es responsable de la creación de una familia de productos , es decir, se introduce la combinación de productos abstractos y fábricas abstractas.

La inclinación del principio de apertura y cierre del modelo de fábrica abstracto.

Para una nueva familia de productos, equivale a agregar un nuevo fabricante de producto , que cumple con el principio de apertura y cierre en este momento;
pero para la estructura de nivel de producto recién agregada, es decir, al agregar nuevos productos , el principio de apertura y cierre no se cumple en este momento.

Código de patrón de fábrica abstracto

/*
 * @ 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;
}