Modo de generador de patrones de diseño C ++ (4)

Introducción

  El patrón de construcción separa la construcción de un objeto complejo y su representación, y puede construir diferentes representaciones a través del mismo método de construcción.
  La creación de un objeto complejo generalmente se construye con múltiples subobjetos; debido a los cambios continuos en los requisitos de ingeniería del proyecto, también cambiarán varias partes del objeto complejo correspondiente. Si el objeto se reconstruye, el código estará demasiado inflado. Propicio para mantenimiento y expansión. Aunque los requisitos están cambiando, el proceso de construcción no cambiará. El modo de constructor es proporcionar un mecanismo cerrado para aislar las partes modificadas y no modificadas (es decir, el objeto creado se modifica, lo que significa que no se modifica).
  Ventajas: 1. Encapsular los pasos del proceso de creación de objetos y abstraerlos, reflejando el principio de inversión de dependencia, 2. Encapsular el proceso de creación, reducir la redundancia de código y mejorar la legibilidad y escalabilidad del código.
  Desventajas: Los pasos del proceso para crear objetos son relativamente estrictos y es mejor ser coherente, por lo tanto, la flexibilidad del código se reduce.

• Director: construya una interfaz que use el objeto Builder;
• Constructor: Resumen los pasos del proceso de creación de productos como clases abstractas;
• ConcreteBuilder: la clase de realización concreta de la clase abstracta Builder;
• Producto : representa el objeto complejo que se está construyendo. ConcreteBuilder crea la representación interna del producto y define su proceso de ensamblaje, incluidas las clases que definen las partes componentes, incluida la interfaz para ensamblar estas partes en el producto final.

Código

// buider_pattern.h
class Production{
public:
    void set_part_a(int param);
    void set_part_b(int param);
    void set_part_c(int param);
    void show();
private:
    int part_a_;
    int part_b_;
    int part_c_;
}; // Production

class AbstractBuilder{
public:
    AbstractBuilder() = default;
    virtual ~AbstractBuilder() = default;
    virtual void create_porduction() = 0;
    virtual void set_part_a(int param) = 0;
    virtual void set_part_b(int param) = 0;
    virtual void set_part_c(int param) = 0;
    virtual std::shared_ptr<Production> get_production() = 0;
}; // AbstractBuilder

class ProductionBuilder: public AbstractBuilder{
public:
    void create_porduction() override;
    void set_part_a(int param) override;
    void set_part_b(int param) override;
    void set_part_c(int param) override;
    std::shared_ptr<Production> get_production() override;

private:
    std::shared_ptr<Production> production_ptr_;

}; // ProductionBuilder

class Director{
public:
    Director(std::shared_ptr<AbstractBuilder>& builder);
    ~Director() = default;
    void create();
private:
    std::shared_ptr<AbstractBuilder> builder_;
}; // Director

// buider_pattern.cpp
void Production::set_part_a(int param) {
    this->part_a_ = param;
}

void Production::set_part_b(int param) {
    this->part_b_ = param;
}

void Production::set_part_c(int param) {
    this->part_c_ = param;
}

void Production::show() {
    std::cout << "Production, part_a: " << part_a_
              << ", part_b: " << part_b_
              << ", part_c: " << part_c_ << std::endl;
}

void ProductionBuilder::create_porduction() {
    this->production_ptr_ = std::make_shared<Production>();
}

void ProductionBuilder::set_part_a(int param) {
    this->production_ptr_->set_part_a(param);
}

void ProductionBuilder::set_part_b(int param) {
    this->production_ptr_->set_part_b(param);
}

void ProductionBuilder::set_part_c(int param) {
    this->production_ptr_->set_part_c(param);
}

std::shared_ptr<Production> ProductionBuilder::get_production() {
    return this->production_ptr_;
}

Director::Director(std::shared_ptr<AbstractBuilder>& builder) {
    this->builder_ = builder;
}

void Director::create() {
    this->builder_->create_porduction();
    this->builder_->set_part_a(1);
    this->builder_->set_part_b(2);
    this->builder_->set_part_c(3);
}

int main(){
    std::shared_ptr<AbstractBuilder> builder = std::make_shared<ProductionBuilder>();
    std::shared_ptr<Director> director = std::make_shared<Director>(builder);
    director->create();
    std::shared_ptr<Production> production = builder->get_production();
    production->show();
	return 0;
}