1 概念定义
构建器模式是一种创建型设计模式，它将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。它通过一步步地构建复杂对象，允许用户在不知道内部构建细节的情况下，创建出复杂的对象。
2 核心思想：
将复杂对象的构建过程分解为多个简单的步骤
相同的构建过程可以产生不同的产品表示
将产品的内部表示和组装过程分离开
提供更精细的控制来创建复杂对象
3 主要角色：
Builder（抽象构建器）：为创建产品的各个部件指定抽象接口
ConcreteBuilder（具体构建器）：实现Builder接口，构造和装配各个部件
Director（指挥者）：构造一个使用Builder接口的对象，控制构建过程
Product（产品）：表示被构造的复杂对象
4 应用场景
以电脑定制系统为例：
用户可以定制不同类型的电脑：游戏电脑、办公电脑、服务器
每台电脑包含多个组件：CPU、GPU、内存、硬盘、主板、电源等
不同配置的电脑组件兼容性和搭配方案不同
构建过程需要保证组件之间的兼容性
用户只需要选择配置类型，不需要关心具体组装过程
5 UML
6 c++ 代码实现
cpp
#include <iostream>
#include <string>
#include <vector>
#include <memory>
using namespace std;
// ========== 产品类：电脑 ==========
class Computer {
private:
string type;
string cpu;
string gpu;
string memory;
string storage;
string motherboard;
string powerSupply;
string coolingSystem;
vector<string> features;
public:
void setType(const string& t) { type = t; }
void setCPU(const string& c) { cpu = c; }
void setGPU(const string& g) { gpu = g; }
void setMemory(const string& m) { memory = m; }
void setStorage(const string& s) { storage = s; }
void setMotherboard(const string& m) { motherboard = m; }
void setPowerSupply(const string& p) { powerSupply = p; }
void setCoolingSystem(const string& c) { coolingSystem = c; }
void addFeature(const string& f) { features.push_back(f); }
void showSpecifications() const {
cout << "\n=== " << type << " 配置单 ===" << endl;
cout << "CPU: " << cpu << endl;
cout << "GPU: " << gpu << endl;
cout << "内存: " << memory << endl;
cout << "硬盘: " << storage << endl;
cout << "主板: " << motherboard << endl;
cout << "电源: " << powerSupply << endl;
cout << "散热系统: " << coolingSystem << endl;
if (!features.empty()) {
cout << "附加功能:" << endl;
for (const auto& f : features) {
cout << " - " << f << endl;
}
}
}
// 测试用：检查组件兼容性
bool checkCompatibility() const {
// 模拟组件兼容性检查
if (cpu.find("Intel") != string::npos && motherboard.find("AMD") != string::npos) {
cout << "警告：CPU和主板不兼容！" << endl;
return false;
}
return true;
}
};
// ========== 抽象构建器 ==========
class ComputerBuilder {
protected:
Computer* computer;
public:
ComputerBuilder() : computer(nullptr) {}
virtual ~ComputerBuilder() {
if (computer) delete computer;
}
// 创建新电脑
void createNewComputer() {
if (computer) delete computer;
computer = new Computer();
}
// 获取构建好的电脑
Computer* getComputer() {
Computer* result = computer;
computer = nullptr; // 转移所有权
return result;
}
// 构建步骤的抽象方法
virtual void buildCPU() = 0;
virtual void buildGPU() = 0;
virtual void buildMemory() = 0;
virtual void buildStorage() = 0;
virtual void buildMotherboard() = 0;
virtual void buildPowerSupply() = 0;
virtual void buildCoolingSystem() = 0;
virtual void buildFeatures() = 0;
virtual string getComputerType() = 0;
};
// ========== 具体构建器：游戏电脑 ==========
class GamingComputerBuilder : public ComputerBuilder {
public:
void buildCPU() override {
computer->setCPU("Intel Core i9-13900K (24核, 5.8GHz)");
}
void buildGPU() override {
computer->setGPU("NVIDIA RTX 4090 24GB GDDR6X");
}
void buildMemory() override {
computer->setMemory("DDR5 64GB (32GB x2) 6000MHz");
}
void buildStorage() override {
computer->setStorage("Samsung 990 Pro 2TB NVMe SSD + 4TB HDD");
}
void buildMotherboard() override {
computer->setMotherboard("ROG MAXIMUS Z790 HERO");
}
void buildPowerSupply() override {
computer->setPowerSupply("1000W 80+ Platinum 全模组");
}
void buildCoolingSystem() override {
computer->setCoolingSystem("360mm 水冷散热器 + 6个机箱风扇");
}
void buildFeatures() override {
computer->addFeature("RGB 灯光系统");
computer->addFeature("游戏机械键盘");
computer->addFeature("专业游戏鼠标");
computer->addFeature("7.1声道声卡");
}
string getComputerType() override {
return "顶级游戏电脑";
}
};
// ========== 具体构建器：办公电脑 ==========
class OfficeComputerBuilder : public ComputerBuilder {
public:
void buildCPU() override {
computer->setCPU("Intel Core i5-13400 (10核, 4.6GHz)");
}
void buildGPU() override {
computer->setGPU("集成显卡 UHD Graphics 730");
}
void buildMemory() override {
computer->setMemory("DDR4 16GB (8GB x2) 3200MHz");
}
void buildStorage() override {
computer->setStorage("512GB NVMe SSD");
}
void buildMotherboard() override {
computer->setMotherboard("B760M 主板");
}
void buildPowerSupply() override {
computer->setPowerSupply("450W 80+ Bronze");
}
void buildCoolingSystem() override {
computer->setCoolingSystem("风冷散热器");
}
void buildFeatures() override {
computer->addFeature("WiFi 6E 无线网卡");
computer->addFeature("蓝牙5.3");
computer->addFeature("多屏输出支持");
}
string getComputerType() override {
return "商务办公电脑";
}
};
// ========== 具体构建器：服务器 ==========
class ServerComputerBuilder : public ComputerBuilder {
public:
void buildCPU() override {
computer->setCPU("AMD EPYC 9654 (96核, 3.7GHz)");
}
void buildGPU() override {
computer->setGPU("无需独立显卡");
}
void buildMemory() override {
computer->setMemory("DDR5 ECC 256GB (64GB x4)");
}
void buildStorage() override {
computer->setStorage("2TB NVMe SSD + 8TB x4 HDD RAID 10");
}
void buildMotherboard() override {
computer->setMotherboard("双路服务器主板");
}
void buildPowerSupply() override {
computer->setPowerSupply("1600W 80+ Titanium 冗余电源");
}
void buildCoolingSystem() override {
computer->setCoolingSystem("服务器级强风散热");
}
void buildFeatures() override {
computer->addFeature("IPMI 远程管理");
computer->addFeature("冗余电源模块");
computer->addFeature("热插拔硬盘架");
computer->addFeature("ECC内存纠错");
}
string getComputerType() override {
return "企业级服务器";
}
};
// ========== 指挥者：组装工程师 ==========
class AssemblyDirector {
private:
ComputerBuilder* builder;
public:
AssemblyDirector(ComputerBuilder* b) : builder(b) {}
void setBuilder(ComputerBuilder* b) {
builder = b;
}
// 标准构建过程
Computer* constructStandard() {
builder->createNewComputer();
cout << "\n开始组装 " << builder->getComputerType() << "..." << endl;
builder->buildCPU();
builder->buildGPU();
builder->buildMemory();
builder->buildStorage();
builder->buildMotherboard();
builder->buildPowerSupply();
builder->buildCoolingSystem();
builder->buildFeatures();
Computer* computer = builder->getComputer();
computer->setType(builder->getComputerType());
// 进行兼容性检查
if (computer->checkCompatibility()) {
cout << builder->getComputerType() << " 组装完成！" << endl;
} else {
cout << "警告：配置可能存在兼容性问题！" << endl;
}
return computer;
}
// 精简版构建过程（快速组装）
Computer* constructQuick() {
builder->createNewComputer();
cout << "\n快速组装 " << builder->getComputerType() << "..." << endl;
builder->buildCPU();
builder->buildMemory();
builder->buildStorage();
builder->buildMotherboard();
Computer* computer = builder->getComputer();
computer->setType(builder->getComputerType() + " (精简版)");
return computer;
}
// 定制构建过程（可以自定义步骤）
Computer* constructCustom(bool withGPU, bool withExtraFeatures) {
builder->createNewComputer();
cout << "\n定制组装 " << builder->getComputerType() << "..." << endl;
builder->buildCPU();
if (withGPU) builder->buildGPU();
builder->buildMemory();
builder->buildStorage();
builder->buildMotherboard();
builder->buildPowerSupply();
builder->buildCoolingSystem();
if (withExtraFeatures) builder->buildFeatures();
Computer* computer = builder->getComputer();
computer->setType(builder->getComputerType() + " (定制版)");
return computer;
}
};
// ========== 简化版本的构建器（不使用Director） ==========
// 这种方式更常见，通过链式调用实现
class ComputerConfigurator {
private:
Computer computer;
public:
ComputerConfigurator& setCPU(const string& cpu) {
computer.setCPU(cpu);
return *this;
}
ComputerConfigurator& setGPU(const string& gpu) {
computer.setGPU(gpu);
return *this;
}
ComputerConfigurator& setMemory(const string& memory) {
computer.setMemory(memory);
return *this;
}
ComputerConfigurator& setStorage(const string& storage) {
computer.setStorage(storage);
return *this;
}
ComputerConfigurator& setMotherboard(const string& motherboard) {
computer.setMotherboard(motherboard);
return *this;
}
ComputerConfigurator& setPowerSupply(const string& power) {
computer.setPowerSupply(power);
return *this;
}
ComputerConfigurator& setCoolingSystem(const string& cooling) {
computer.setCoolingSystem(cooling);
return *this;
}
ComputerConfigurator& addFeature(const string& feature) {
computer.addFeature(feature);
return *this;
}
Computer build() {
computer.setType("自定义电脑");
return computer;
}
};
// ========== 客户端代码 ==========
int main() {
cout << "=== 电脑定制系统 ===\n" << endl;
// 方式1：使用Director控制构建过程
cout << "【方式1：使用Director组装电脑】" << endl;
// 组装游戏电脑
GamingComputerBuilder gamingBuilder;
AssemblyDirector director(&gamingBuilder);
Computer* gamingPC = director.constructStandard();
gamingPC->showSpecifications();
// 组装办公电脑
OfficeComputerBuilder officeBuilder;
director.setBuilder(&officeBuilder);
Computer* officePC = director.constructStandard();
officePC->showSpecifications();
// 组装服务器
ServerComputerBuilder serverBuilder;
director.setBuilder(&serverBuilder);
Computer* serverPC = director.constructStandard();
serverPC->showSpecifications();
// 方式2：使用快速构建
cout << "\n【方式2：快速构建示例】" << endl;
director.setBuilder(&officeBuilder);
Computer* quickPC = director.constructQuick();
quickPC->showSpecifications();
// 方式3：使用定制构建
cout << "\n【方式3：定制构建示例】" << endl;
director.setBuilder(&gamingBuilder);
Computer* customPC = director.constructCustom(true, false); // 要GPU，不要额外功能
customPC->showSpecifications();
// 方式4：使用链式调用的构建器（不使用Director）
cout << "\n【方式4：链式调用构建器】" << endl;
ComputerConfigurator configurator;
Computer customComputer = configurator
.setCPU("AMD Ryzen 9 7950X")
.setGPU("AMD Radeon RX 7900 XTX")
.setMemory("DDR5 32GB")
.setStorage("1TB NVMe SSD")
.setMotherboard("X670E 主板")
.setPowerSupply("850W 80+ Gold")
.setCoolingSystem("水冷散热器")
.addFeature("RGB 灯效")
.build();
customComputer.showSpecifications();
// 清理内存
delete gamingPC;
delete officePC;
delete serverPC;
delete quickPC;
delete customPC;
return 0;
}7 总结
不使用构建器模式的坏处
如果不使用构建器模式，可能会采用以下几种实现方式：
方式1：使用庞大的构造函数
cpp
class Computer {
public:
// 问题：构造函数参数太多，难以使用和维护
Computer(const string& type, const string& cpu, const string& gpu,
const string& memory, const string& storage,
const string& motherboard, const string& powerSupply,
const string& coolingSystem, const vector<string>& features) {
// 初始化所有成员
}
};
// 客户端使用时：
vector<string> features = {"RGB灯光", "机械键盘"};
Computer gamingPC("游戏电脑",
"Intel i9-13900K",
"RTX 4090",
"64GB DDR5",
"2TB SSD",
"ROG Z790",
"1000W Platinum",
"360mm水冷",
features);问题：
构造函数参数太多，容易混淆顺序
可读性差，不知道每个参数的含义
许多参数可能是可选的，导致多个构造函数重载
添加新参数需要修改所有调用处
方式2：使用setter方法
cpp
class Computer {
private:
string cpu;
string gpu;
// ... 其他成员
public:
void setCPU(const string& c) { cpu = c; }
void setGPU(const string& g) { gpu = g; }
// ... 其他setter
// 问题：缺少构建过程控制
};
// 客户端使用：
Computer pc;
pc.setCPU("Intel i9");
pc.setGPU("RTX 4090");
pc.setMemory("64GB");
// ... 需要设置所有必要属性
// 问题：可能会遗漏必要的设置
// 问题：没有一致性检查问题：
对象可能处于不一致的状态（某些属性未设置）
无法保证构建顺序
没有封装构建逻辑
客户端需要知道哪些属性是必须的
方式3：为每种配置创建子类
cpp
// 问题：类爆炸
class BasicGamingComputer : public Computer { /* ... */ };
class AdvancedGamingComputer : public Computer { /* ... */ };
class ProfessionalGamingComputer : public Computer { /* ... */ };
class BasicOfficeComputer : public Computer { /* ... */ };
class AdvancedOfficeComputer : public Computer { /* ... */ };
// ... 需要为每种组合创建类问题：
类的数量爆炸（N种组件 × M种选择）
代码重复严重
难以维护和扩展
构建器模式的优势
1 分步构建：将复杂对象的构建过程分解为多个步骤
2 参数清晰：方法名明确表示正在设置的属性
3 对象一致性：可以在构建过程中执行验证和兼容性检查
4 构建过程复用：相同的构建过程可以创建不同的表示
5 不可变对象：可以创建构建完成后不可修改的对象
6 链式调用：提供流畅的接口（Fluent Interface）
7 更好的封装：构建细节对客户端隐藏
构建器模式通过将复杂对象的构建过程封装起来，提供了一种优雅的方式来处理具有大量可选参数的复杂对象创建，是创建复杂对象的理想选择。
8 适用场景
需要创建的对象非常复杂，有很多可选参数
对象的构建过程需要保证一致性
需要创建不同表示的对象，但构建过程相似
对象的构建步骤可能需要变化
希望将复杂对象的构建与其表示分离
