Modo de constructor Generador (modo de diseño de c ++)

El modo constructor consiste en separar la construcción de un objeto complejo de su representación , de modo que el mismo proceso de construcción pueda crear diferentes representaciones. El cliente no necesita conocer los componentes internos y los métodos de ensamblaje del objeto complejo , solo el tipo de constructor requerido. lata

Ventajas del modelo

• El cliente no necesita conocer los detalles de la composición interna del producto, y desacopla el producto en sí del proceso de creación, para que una misma creación pueda crear diferentes objetos de producto.
• Para la sustitución y adición de nuevos constructores de hormigón, se cumple el principio de apertura y cierre.
• Puede controlar con precisión el proceso de creación del producto
• Características: alta cohesión y bajo acoplamiento.

Desventajas del modelo

• La diferencia entre productos es muy grande y no es adecuado utilizar el modelo de constructor.
• Si los cambios internos del producto son complejos, es necesario definir muchas clases de constructores específicas, lo que genera una alta sobrecarga del sistema.

Entorno aplicable

• El producto que se necesita generar tiene una estructura interna compleja
• Los atributos de los objetos de producto que deben generarse dependen unos de otros
• El proceso de creación de un objeto es independiente de la clase que creó el objeto.
• Aislar la creación y uso de objetos complejos.

Código del modo de constructor

/*
 * @ Description: C++ Design Patterns___Builder
 * @ version: v1.0
 * @ Author: WeissxJ
 */
#include<iostream>
#include<string>

class Product
{
    
    
    private:
        std::string partA;
        std::string partB;
        std::string partC;
    public:
        void makeA(const std::string &part){
    
    
            partA=part;
        }
        void makeB(const std::string &part){
    
    
            partB=part;
        }
        void makeC(const std::string &part){
    
    
            partC=part;
        }
        std::string get(){
    
    
            return (partA+" "+partB+" "+partC);
        }
        // ...
};

class Builder
{
    
    
    protected:
        Product product;
    public:
        virtual ~Builder() {
    
    }

        Product get(){
    
    
            return product;
        }
        virtual void buildPartA()=0;
        virtual void buildPartB()=0;
        virtual void buildPartC()=0;
        // ...
};

class ConcretBuilderX : public Builder
{
    
    
    public:
        void buildPartA(){
    
    
            product.makeA("A-X");
        }
        void buildPartB(){
    
    
            product.makeB("B-X");
        }
        void buildPartC(){
    
    
            product.makeC("C-X");
        }
        // ...
};

class ConcretBuilderY : public Builder
{
    
    
    public:
        void buildPartA(){
    
    
            product.makeA("A-Y");
        }
        void buildPartB(){
    
    
            product.makeB("B-Y");
        }
        void buildPartC(){
    
    
            product.makeC("C-Y");
        }
        // ...
};

class Director
{
    
    
    private:
        Builder* builder;
    public:
        Director():builder() {
    
    }
        ~Director(){
    
    
            if(builder)
                delete builder;
        }
        void set(Builder* b){
    
    
            if(builder){
    
    
                delete builder;
            }
            builder=b;
        }
        Product get(){
    
    
            return builder->get();
        }
        void construct(){
    
    
            builder->buildPartA();
            builder->buildPartB();
            builder->buildPartC();
            // ...
        }
        // ...
};

int main(){
    
    
    Director director;
    director.set(new ConcretBuilderX);
    director.construct();

    Product product1=director.get();
    std::cout<<"1st product parts: "<<product1.get()<<std::endl;

    director.set(new ConcretBuilderY);
    director.construct();

    Product product2=director.get();
    std::cout<<"2nd product parts: "<<product2.get()<<std::endl;
    return 0;
}