【第四节】C++设计模式(创建型模式)-Builder(建造者)模式

[一、Builder 模式概述](#一、Builder 模式概述)

[二、Builder 模式举例](#二、Builder 模式举例)

[三、Builder 模式的结构](#三、Builder 模式的结构)

[四、Builder 模式的实现](#四、Builder 模式的实现)

[五、Builder 模式的优缺点](#五、Builder 模式的优缺点)

引言

Builder 模式是一种创建型设计模式，旨在将复杂对象的构建过程与其表示分离。通过一步步构建对象，Builder 模式允许在构建过程中引入参数，从而生成不同的对象表示。本文将通过理论讲解和代码示例，深入探讨 Builder 模式的核心思想、适用场景及其实现方式。

一、Builder 模式概述

核心思想

Builder 模式的核心思想是将复杂对象的构建过程分解为多个步骤，并通过一个指导者（Director）对象来协调这些步骤。这样做的好处是：

构建过程与表示分离：对象的构建过程独立于其最终表示，使得相同的构建过程可以生成不同的对象。

灵活性：通过在每一步骤中引入参数，可以灵活地调整对象的构建过程。

适用场景

Builder 模式适用于以下场景：

需要创建的对象非常复杂，由多个部分组成。

对象的构建过程需要分步骤进行，且每个步骤可能需要不同的参数。

希望将对象的构建过程与其表示分离，以便生成不同的对象表示。

二、Builder 模式举例

建造一栋房屋是一个复杂的过程，通常分为多个步骤，例如：

（1）打地基：为房屋奠定基础。

（2）搭建框架：构建房屋的主体结构。

（3）安装水电：布置水管、电线等基础设施。

（4）装修：进行内部和外部的装饰。

每个步骤都需要不同的材料和工艺，且可以根据需求进行调整。例如，地基的深度、框架的材料、装修的风格等都可以根据房屋的用途和预算进行定制。

在房屋建造过程中，Builder 模式可以很好地发挥作用：

分步骤构建：将房屋的建造过程分解为多个步骤（如打地基、搭建框架等），每个步骤由专门的工人或团队负责。

参数化构建：在每个步骤中引入不同的参数（如材料选择、设计风格等），从而生成不同的房屋。

统一管理：通过一个总指挥（Director）来协调各个步骤，确保房屋的建造过程有序进行。

通过 Builder 模式，相同的建造过程可以生成不同的房屋。例如：

经济型房屋：使用低成本材料，简化装修。

豪华型房屋：使用高端材料，精心设计装修。

环保型房屋：采用绿色建材，注重节能设计。

Builder 模式解决的问题与此类似：当我们需要创建的对象非常复杂时，可以通过分步骤构建对象，并在每一步骤中引入参数，从而生成不同的对象表示。

三、Builder 模式的结构

典型结构图

Builder 模式的典型结构包括以下几个角色：

Product（产品）：最终要构建的复杂对象。

Builder（构建者）：定义构建对象的各个步骤的接口。

ConcreteBuilder（具体构建者）：实现 Builder 接口，完成对象的具体构建。

Director（指导者）：负责调用 Builder 的步骤，控制对象的构建过程。

关键点

分步骤构建：Builder 模式通过分步骤构建对象，使得构建过程更加清晰和可控。

参数化构建：在每一步骤中引入参数，可以生成不同的对象表示。

四、Builder 模式的实现

代码示例

以下是一个简单的 Builder 模式实现示例，展示了如何分步骤构建一个复杂对象。

产品类定义

cpp 复制代码

// Product.h
#ifndef _PRODUCT_H_
#define _PRODUCT_H_

class Product {
public:
    Product();
    ~Product();
    void ProducePart();
protected:
private:
};

class ProductPart {
public:
    ProductPart();
    ~ProductPart();
    ProductPart* BuildPart();
protected:
private:
};

#endif // ~_PRODUCT_H_

构建者类定义

cpp 复制代码

// Builder.h
#ifndef _BUILDER_H_
#define _BUILDER_H_
#include <string>
using namespace std;

class Product;

class Builder {
public:
    virtual ~Builder();
    virtual void BuildPartA(const string& buildPara) = 0;
    virtual void BuildPartB(const string& buildPara) = 0;
    virtual void BuildPartC(const string& buildPara) = 0;
    virtual Product* GetProduct() = 0;
protected:
    Builder();
private:
};

class ConcreteBuilder : public Builder {
public:
    ConcreteBuilder();
    ~ConcreteBuilder();
    void BuildPartA(const string& buildPara);
    void BuildPartB(const string& buildPara);
    void BuildPartC(const string& buildPara);
    Product* GetProduct();
protected:
private:
};

#endif // ~_BUILDER_H_

构建者类实现

cpp 复制代码

// Builder.cpp
#include "Builder.h"
#include "Product.h"
#include <iostream>
using namespace std;

Builder::Builder() {}
Builder::~Builder() {}

ConcreteBuilder::ConcreteBuilder() {}
ConcreteBuilder::~ConcreteBuilder() {}

void ConcreteBuilder::BuildPartA(const string& buildPara) {
    cout << "Step1: Build PartA..." << buildPara << endl;
}

void ConcreteBuilder::BuildPartB(const string& buildPara) {
    cout << "Step2: Build PartB..." << buildPara << endl;
}

void ConcreteBuilder::BuildPartC(const string& buildPara) {
    cout << "Step3: Build PartC..." << buildPara << endl;
}

Product* ConcreteBuilder::GetProduct() {
    BuildPartA("pre-defined");
    BuildPartB("pre-defined");
    BuildPartC("pre-defined");
    return new Product();
}

指导者类定义

cpp 复制代码

// Director.h
#ifndef _DIRECTOR_H_
#define _DIRECTOR_H_

class Builder;

class Director {
public:
    Director(Builder* bld);
    ~Director();
    void Construct();
protected:
private:
    Builder* _bld;
};

#endif // ~_DIRECTOR_H_

指导者类实现

cpp 复制代码

// Director.cpp
#include "Director.h"
#include "Builder.h"

Director::Director(Builder* bld) {
    _bld = bld;
}

Director::~Director() {}

void Director::Construct() {
    _bld->BuildPartA("user-defined");
    _bld->BuildPartB("user-defined");
    _bld->BuildPartC("user-defined");
}

测试程序

cpp 复制代码

// main.cpp
#include "Builder.h"
#include "Product.h"
#include "Director.h"
#include <iostream>
using namespace std;

int main(int argc, char* argv[]) {
    Director* d = new Director(new ConcreteBuilder());
    d->Construct();
    return 0;
}

五、Builder 模式的优缺点

优点

构建过程与表示分离：对象的构建过程独立于其最终表示，使得相同的构建过程可以生成不同的对象。

灵活性：通过在每一步骤中引入参数，可以灵活地调整对象的构建过程。

易于扩展：新增构建步骤或调整构建顺序非常方便。

缺点

复杂性增加：随着构建步骤的增多，Builder 模式的实现可能变得复杂。

代码冗余：每个具体构建者类都需要实现相同的构建步骤接口，可能导致代码冗余。

六、总结

Builder 模式是一种强大的设计模式，适用于复杂对象的构建。它通过分步骤构建对象，并将构建过程与表示分离，提供了灵活性和可扩展性。然而，在面对简单对象的构建时，Builder 模式可能显得过于复杂。因此，在实际开发中，应根据具体需求选择合适的设计模式。