目录
引言
一、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;
}五、Builder 模式的优缺点
优点
构建过程与表示分离：对象的构建过程独立于其最终表示，使得相同的构建过程可以生成不同的对象。
灵活性：通过在每一步骤中引入参数，可以灵活地调整对象的构建过程。
易于扩展：新增构建步骤或调整构建顺序非常方便。
缺点
复杂性增加：随着构建步骤的增多，Builder 模式的实现可能变得复杂。
代码冗余：每个具体构建者类都需要实现相同的构建步骤接口，可能导致代码冗余。
六、总结
Builder 模式是一种强大的设计模式，适用于复杂对象的构建。它通过分步骤构建对象，并将构建过程与表示分离，提供了灵活性和可扩展性。然而，在面对简单对象的构建时，Builder 模式可能显得过于复杂。因此，在实际开发中，应根据具体需求选择合适的设计模式。
