当前位置：首页 > news >正文

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

news 来源：原创 2025/5/21 3:00:25

引言

一、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 模式实现示例，展示了如何分步骤构建一个复杂对象。

产品类定义

// 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_

构建者类定义

// 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_

构建者类实现

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

指导者类定义

// 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_

指导者类实现

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

测试程序

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