Modo de design (5) Modo construtor

Modo Builder

O modo construtor separa o cliente da criação de objetos complexos que contêm vários componentes.O cliente não precisa saber a composição interna e os métodos do objeto complexo, mas apenas precisa conhecer o construtor necessário.
Em outras palavras, ao construir a casa, o desenvolvedor deu o desenho de projeto da casa que ele esperava construir para o partido da construção. O partido da construção lança as bases, constrói a casa e executa a decoração interior de acordo com o processo de construção projetado pela empresa Apenas para o desenvolvedor Você só precisa entrar em contato com um construtor qualificado e deixar o resto para o construtor para a construção. O responsável pela construção irá construir casas de diferentes estilos de acordo com os desenhos do desenvolvedor.

Definição do padrão do construtor: Separe a construção de um objeto complexo de sua representação, de forma que o mesmo processo de construção possa criar diferentes representações.

Estrutura do modo Builder

A estrutura do modo builder inclui as seguintes funções:

1. Abstract Builder (AbstractBuilder) : Crie uma interface abstrata especificada por cada componente de um objeto Produto;
2. Concrete Builder (ConcreteBuilder) : implementa a interface AbstractBuilder, implementa o método de construção concreto e o método de montagem de cada componente e retorna o resultado da criação.
3. Produto : objeto de produto específico
4. Diretor : constrói um objeto usando a interface Builder e organiza a construção de objetos complexos. O cliente geralmente só precisa interagir com o Diretor, especificar o tipo de construtor e, em seguida, passar o objeto construtor concreto para o Diretor por meio do construtor ou método setter. Sua principal função é isolar o processo de produção de clientes e objetos, e ser responsável por controlar o processo de produção de objetos de produto.

Diagrama UML:

Agora olhe para o diagrama UML.O Diretor seleciona o Construtor apropriado de acordo com as necessidades e, em seguida, o Construtor construirá seu Produto correspondente. O Diretor não precisa saber como o Builder implementa o processo de produção do Produto.

Exemplo de código do modo Builder

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;
}

Resumo do modo construtor

Pode-se ver a partir do cliente que o cliente especifica o construtor correspondente conforme necessário e passa o construtor como um parâmetro para o comandante e o resultado pode ser obtido por meio do comandante. O cliente não precisa se preocupar com o processo específico de construção do produto.
Se você deseja alterar o estilo de construção, você só precisa alterar o construtor específico.Não há conexão entre os diferentes construtores, o que é conveniente para a substituição. Do ponto de vista da otimização do código, na verdade, o papel do diretor não é necessário e o método de construção pode ser colocado diretamente no construtor concreto.

vantagem:

• No modo builder, o cliente não precisa saber os detalhes da composição interna do produto e separa o próprio produto do processo de criação do produto, de forma que o mesmo processo de criação possa criar diferentes objetos de produto;
• Construtores diferentes são independentes uns dos outros e não há corrente, o que é conveniente para substituição.

Desvantagens:

• Os produtos criados pelo modo construtor geralmente têm mais em comum e seus componentes são semelhantes.Se as diferenças entre os produtos forem grandes, o modo construtor não é adequado para uso, portanto, o escopo de seu uso está sujeito a certas restrições.
• Se as mudanças internas do produto forem complexas, pode levar à necessidade de definir uma série de classes de construtor específicas para atingir essa mudança, resultando no sistema se tornando muito grande

Ambiente aplicável:

• O objeto de produto que precisa ser gerado tem uma estrutura interna complexa (geralmente contendo várias variáveis ​​de membro);
• Os atributos internos do objeto de produto têm uma certa sequência de geração;
• O mesmo processo de criação se aplica a muitos produtos diferentes.