Modo de diseño (5) Modo de constructor

Modo constructor

El modo de constructor separa al cliente de la creación de objetos complejos que contienen múltiples componentes El cliente no necesita conocer la composición interna y los métodos del objeto complejo, solo necesita conocer el constructor requerido.
Dicho de otra manera, al construir la casa, el desarrollador entregó el dibujo de diseño de la casa que esperaba construir a la parte de construcción. La parte de construcción pone los cimientos, construye la casa y realiza la decoración interior de acuerdo con el proceso de construcción diseñado por la empresa Solo el desarrollador Solo necesita contactar a una parte de construcción calificada y dejar el resto a la parte de construcción para la construcción La parte de construcción construirá casas de diferentes estilos de acuerdo con los planos de diseño del desarrollador.

Definición de patrón de constructor: separe la construcción de un objeto complejo de su representación, de modo que el mismo proceso de construcción pueda crear diferentes representaciones.

Estructura del modo de constructor

La estructura del modo de constructor incluye los siguientes roles:

1. Abstract Builder (AbstractBuilder) : crea una interfaz abstracta especificada por cada componente de un objeto Producto;
2. Concrete Builder (ConcreteBuilder) : implementa la interfaz AbstractBuilder, implementa el método de construcción de concreto y el método de ensamblaje de cada componente y devuelve el resultado de la creación.
3. Producto : objeto de producto específico
4. Director : Construya un objeto usando la interfaz Builder y organice la construcción de objetos complejos. El cliente generalmente solo necesita interactuar con el Director, especificar el tipo de constructor y luego pasar el objeto de constructor concreto al Director a través del método constructor o setter. Su función principal es aislar el proceso de producción de clientes y objetos, y ser responsable de controlar el proceso de producción de los objetos del producto.

Diagrama UML:

ahora mire el diagrama UML, el Director selecciona el Constructor apropiado de acuerdo con las necesidades, y luego el Constructor construirá su Producto correspondiente. Director no necesita saber cómo Builder implementa el proceso de producción de Producto.

Ejemplo de código del modo de constructor

BuilderPattern.h

#include <iostream>
#include <string.h>

using namespace std;

//产品类House
class House
{
    
    
public:
  House() {
    
    }

  void setFloor(string iFloor)
  {
    
    
    this->floor = iFloor;
  }

  void setWall(string iWall)
  {
    
    
    this->wall = iWall;
  }

  void setRoof(string iRoof)
  {
    
    
    this->roof = iRoof;
  }

  //打印House信息
  void printfHouseInfo()
  {
    
    
    cout << "Floor " << this->floor.c_str() << "\n";
    cout << "Wall " << this->wall.c_str() << "\n";
    cout << "Roof " << this->roof.c_str() << "\n\n";
  }

private:
  string floor;
  string wall;
  string roof;
};

//抽象建造者AbstractBuilder
class AbstractBuilder
{
    
    
public:
  AbstractBuilder()
  {
    
    
    house = new House();
  }

  virtual ~AbstractBuilder()
  {
    
    
    if (house != nullptr)
    {
    
    
      house = nullptr;
      delete house;
    }
  }

  //抽象方法：
  virtual void buildFloor() = 0;
  virtual void buildWall() = 0;
  virtual void buildRoof() = 0;
  virtual House *getHouse() = 0;

  House *house;
};

//具体建造者ConcreteBuilderA
class ConcreteBuilderA : public AbstractBuilder
{
    
    
public:
  ConcreteBuilderA()
  {
    
    
    printf("ConcreteBuilderA\n");
  }

  ~ConcreteBuilderA()
  {
    
    
    if (this->house != nullptr)
    {
    
    
      house = nullptr;
      delete house;
    }
  }

  //具体实现方法
  void buildFloor()
  {
    
    
    this->house->setFloor("Floor_A");
  }

  void buildWall()
  {
    
    
    this->house->setWall("Wall_A");
  }

  void buildRoof()
  {
    
    
    this->house->setRoof("Roof_A");
  }

  House *getHouse()
  {
    
    
    return this->house;
  }
};

//具体建造者ConcreteBuilderB
class ConcreteBuilderB : public AbstractBuilder
{
    
    
public:
  ConcreteBuilderB()
  {
    
    
    printf("ConcreteBuilderB\n");
  }

  ~ConcreteBuilderB()
  {
    
    
    if (this->house != nullptr)
    {
    
    
      house = nullptr;
      delete house;
    }
  }

  //具体实现方法
  void buildFloor()
  {
    
    
    this->house->setFloor("Floor_B");
  }

  void buildWall()
  {
    
    
    this->house->setWall("Wall_B");
  }

  void buildRoof()
  {
    
    
    this->house->setRoof("Roof_B");
  }

  House *getHouse()
  {
    
    
    return this->house;
  }
};

//指挥者Director
class Director
{
    
    
public:
  Director() : builder(nullptr) {
    
    }

  ~Director()
  {
    
    
    if (this->builder != nullptr)
    {
    
    
      builder = nullptr;
      delete builder;
    }
  }
  //具体实现方法
  void setBuilder(AbstractBuilder *iBuilder)
  {
    
    
    this->builder = iBuilder;
  }

  House *construct()
  {
    
    
    builder->buildFloor();
    builder->buildWall();
    builder->buildRoof();
    return builder->getHouse();
  }

private:
  AbstractBuilder *builder;
};

BuilderPattern.cpp

#include "BuilderPattern.h"

int main()
{
    
    
  // 抽象建造者 builder
	AbstractBuilder *builder;
  // 装饰者
	Director *director = new Director();
  // 产品类：house
	House *house;

  // 新建具体建造者A
	builder = new ConcreteBuilderA();
	director->setBuilder(builder);
	house = director->construct();
	house->printfHouseInfo();
	delete builder;

  // 新建具体建造者B
	builder = new ConcreteBuilderB();
	director->setBuilder(builder);
	house = director->construct();
	house->printfHouseInfo();

	director->~Director();
	builder->~AbstractBuilder();

	return 0;
}

Resumen del modo de constructor

El cliente puede ver que el cliente especifica el constructor correspondiente según sea necesario, y pasa el constructor como parámetro al comandante, y el resultado se puede obtener a través del comandante. El cliente no necesita preocuparse por el proceso de construcción específico del producto.
Si desea cambiar el estilo de construcción, solo necesita cambiar el constructor específico. No hay conexión entre los diferentes constructores, lo cual es conveniente para el reemplazo. Desde el punto de vista de la optimización del código, de hecho, el rol del director no es necesario y el método de construcción se puede poner directamente en el constructor de concreto.

ventaja:

• En el modo constructor, el cliente no necesita conocer los detalles de composición interna del producto y separa el producto en sí del proceso de creación del producto, de modo que el mismo proceso de creación puede crear diferentes objetos de producto;
• Los diferentes constructores son independientes entre sí y no hay cadena, lo que es conveniente para reemplazar.

Desventajas:

• Los productos creados por el modo constructor generalmente tienen más en común y sus componentes son similares. Si las diferencias entre los productos son grandes, el modo constructor no es adecuado para su uso, por lo que el alcance de su uso está sujeto a ciertas restricciones.
• Si los cambios internos del producto son complejos, puede llevar a la necesidad de definir muchas clases de constructores específicas para lograr este cambio, lo que hace que el sistema se vuelva muy grande.

Entorno aplicable:

• El objeto de producto que debe generarse tiene una estructura interna compleja (generalmente contiene múltiples variables miembro);
• Los atributos internos del objeto de producto tienen una cierta secuencia de generación;
• El mismo proceso de creación se aplica a muchos productos diferentes.