C++ 设计模式之建造者模式（四）

简介

  建造者模式(builder pattern)，是将一个复杂对象的构建及其表示这两部分分离开来，并能通过同样构建方式构建不同的表示。
  复杂对象的创建，通常是由多个子对象构建而成的；由于项目工程需求的不断变化，相应复杂对象的各部分同样也会发生变化，若重新去构建这个对象，会使得代码过于臃肿，不利于维护扩展。虽然，需求是变化的；但是，构建过程是不会发生变化。建造者模式，就是提供一种封闭机制，将变化和不变化的部分进行隔离开来（即创建对象是变化的，表示是不变化的）。
  优点： 1.封装创建对象的过程步骤，并将其抽象出来，体现了依赖倒转原则；2.封装创建过程，降低代码的冗余，提高了代码的可阅读性、可扩展性。
  缺点： 对创建对象的过程步骤要求比较严格，最好一致不变，因此，降低了代码的灵活性。

• Director： 构建使用Builder对象的接口；
• Builder： 抽象创建产品的过程步骤做为抽象类；
• ConcreteBuilder： 抽象类Builder的具体实现类；
• Product： 表示被构造的复杂对象。ConcreteBuilder 创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

代码

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