建造者模式在c++中的核心思想是将复杂对象的构建过程与其最终表示解耦，适用于对象创建涉及多个有序步骤或大量可选部件的场景。1. 它通过四个主要角色协同工作：产品（product）仅包含组成部分；抽象建造者（builder）定义构建接口；具体建造者（concrete builder）实现部件构建逻辑；指挥者（director）控制构建流程。2. 该模式使构建过程与表示分离，提升代码可读性、可维护性和扩展性。3. 相比工厂方法和抽象工厂，建造者更适合多步骤、可变顺序的对象构建任务。4. 常见应用场景包括高度定制化的对象创建，如不同配置的计算机、多种格式的文档生成以及参数复杂的网络请求对象构建等。
建造者模式在C++中，核心思想就是将一个复杂对象的构建过程与其最终表示解耦。你可以把它想象成一个高度定制化的产品组装流水线：你告诉流水线主管（Director）你想要什么类型的产品，然后一个专门的工人（Builder）会按照你的要求，一步一步、一丝不苟地把各个部件组装起来，最终交付给你一个完整的、符合预期的产品。它特别适合那些对象拥有大量可选部件，或者其创建过程需要遵循特定、有序步骤的场景。
解决方案
应用建造者模式，通常会涉及四个主要角色，它们协同工作来完成复杂对象的构建：
- 产品（Product）: 这是我们最终想要构建的复杂对象。它只关心自己由哪些部分组成，而不关心这些部分是如何被创建或组装的。例如，一辆汽车，它有车身、引擎、轮胎等，但它不知道是谁把这些部件装配起来的。
- 抽象建造者（Builder）: 这是一个接口或抽象类，定义了构建产品各个部件的方法，以及一个获取最终产品的方法。它规定了“可以构建哪些部件”，但没有具体说明“如何构建”。
-
具体建造者（Concrete Builder）: 实现了抽象建造者接口，负责具体地构建产品的各个部件。每个具体建造者都专注于构建特定类型的产品变体。比如，一个“跑车建造者”会构建跑车的车身、引擎和轮胎，而一个“SUV建造者”则会构建SUV的相应部件。它们会维护一个正在构建中的产品实例，并在构建完成后通过
getResult()或类似的接口返回。 -
指挥者（Director）: 这个角色负责协调构建过程。它接收一个具体建造者对象，然后按照特定的顺序调用建造者的方法来构建产品。指挥者并不知道产品部件的具体实现细节，它只知道构建一个特定产品所需的步骤序列。这使得你可以用相同的构建过程（Director的
construct方法）来构建不同类型的产品，只要提供不同的具体建造者即可。
这种模式的精髓在于将“如何构建一个复杂对象”的逻辑从“表示这个复杂对象”的逻辑中分离出来。当对象的构造函数参数过多，或者对象的构建过程非常复杂且可能存在多种变体时，建造者模式能极大地提高代码的可读性、可维护性和扩展性。
立即学习“C++免费学习笔记（深入）”；
例如，假设我们要构建一个 Computer 对象，它可能包含 CPU, RAM, `Storage, GPU, OS 等部件。这些部件有多种选择，而且某些组合可能不兼容。
#include <iostream>
#include <string>
#include <memory> // For std::unique_ptr
// 1. 产品 (Product)
class Computer {
public:
void setCPU(const std::string& cpu) { cpu_ = cpu; }
void setRAM(const std::string& ram) { ram_ = ram; }
void setStorage(const std::string& storage) { storage_ = storage; }
void setGPU(const std::string& gpu) { gpu_ = gpu; }
void setOS(const std::string& os) { os_ = os; }
void showConfiguration() const {
std::cout << "--- Computer Configuration ---" << std::endl;
std::cout << "CPU: " << cpu_ << std::endl;
std::cout << "RAM: " << ram_ << std::endl;
std::cout << "Storage: " << storage_ << std::endl;
std::cout << "GPU: " << gpu_ << std::endl;
std::cout << "OS: " << os_ << std::endl;
std::cout << "----------------------------" << std::endl;
}
private:
std::string cpu_;
std::string ram_;
std::string storage_;
std::string gpu_;
std::string os_;
};
// 2. 抽象建造者 (Builder)
class ComputerBuilder {
public:
virtual ~ComputerBuilder() = default;
virtual void buildCPU() = 0;
virtual void buildRAM() = 0;
virtual void buildStorage() = 0;
virtual void buildGPU() = 0;
virtual void buildOS() = 0;
virtual std::unique_ptr<Computer> getComputer() = 0;
};
// 3. 具体建造者 (Concrete Builder) - 用于构建高端游戏电脑
class GamingComputerBuilder : public ComputerBuilder {
private:
std::unique_ptr<Computer> computer_;
public:
GamingComputerBuilder() : computer_(std::make_unique<Computer>()) {}
void buildCPU() override { computer_->setCPU("Intel Core i9"); }
void buildRAM() override { computer_->setRAM("32GB DDR5"); }
void buildStorage() override { computer_->setStorage("1TB NVMe SSD"); }
void buildGPU() override { computer_->setGPU("NVIDIA GeForce RTX 4090"); }
void buildOS() override { computer_->setOS("Windows 11 Pro"); }
std::unique_ptr<Computer> getComputer() override {
return std::move(computer_); // 返回所有权，并重置内部指针
}
};
// 另一个具体建造者 - 用于构建办公电脑
class OfficeComputerBuilder : public ComputerBuilder {
private:
std::unique_ptr<Computer> computer_;
public:
OfficeComputerBuilder() : computer_(std::make_unique<Computer>()) {}
void buildCPU() override { computer_->setCPU("Intel Core i5"); }
void buildRAM() override { computer_->setRAM("16GB DDR4"); }
void buildStorage() override { computer_->setStorage("512GB SATA SSD"); }
void buildGPU() override { computer_->setGPU("Integrated Graphics"); }
void buildOS() override { computer_->setOS("Windows 10 Home"); }
std::unique_ptr<Computer> getComputer() override {
return std::move(computer_);
}
};
// 4. 指挥者 (Director)
class ComputerAssembler {
public:
void assembleGamingComputer(ComputerBuilder* builder) {
builder->buildCPU();
builder->buildRAM();
builder->buildStorage();
builder->buildGPU();
builder->buildOS();
}
void assembleOfficeComputer(ComputerBuilder* builder) {
builder->buildCPU();
builder->buildRAM();
builder->buildStorage();
builder->buildOS(); // 办公电脑可能不需要独立显卡
}
// 可以有更多不同配置的组装方法
};
/*
// 客户端代码示例
int main() {
ComputerAssembler assembler;
// 组装一台游戏电脑
GamingComputerBuilder gamingBuilder;
assembler.assembleGamingComputer(&gamingBuilder);
std::unique_ptr<Computer> gamingComputer = gamingBuilder.getComputer();
if (gamingComputer) {
gamingComputer->showConfiguration();
}
// 组装一台办公电脑
OfficeComputerBuilder officeBuilder;
assembler.assembleOfficeComputer(&officeBuilder);
std::unique_ptr<Computer> officeComputer = officeBuilder.getComputer();
if (officeComputer) {
officeComputer->showConfiguration();
}
return 0;
}
*/这个例子清晰地展示了，通过 ComputerAssembler (Director) 和不同的 ComputerBuilder，我们能够灵活地创建不同配置的 Computer 对象，而客户端代码只需要与 Director 和 Builder 接口打交道，无需关心具体的构建细节。
为什么选择建造者模式而非其他创建型模式？
这是一个经常被问到的问题，毕竟创建型模式家族里成员不少。什么时候建造者模式能脱颖而出呢？
我认为，最核心的考量点在于“复杂对象的分步构建”和“表示与构建的分离”。当一个对象的构造过程不仅仅是简单地调用一个构造函数就能搞定，而是需要一系列有序的、可能带有条件判断的步骤，并且这些步骤的顺序或具体实现会根据最终产品的不同而变化时，建造者模式的优势就非常明显了。
举个例子，假设你正在开发一个复杂的文档生成器，它可以生成各种格式的文档：HTML、Markdown、PDF草稿。一份文档可以包含标题、段落、列表、图片、表格等。不同格式的文档，这些元素的表示方式截然不同；不同类型的文档（比如技术手册、市场宣传册），元素的组合顺序和内容也可能不一样。
- 如果用工厂方法： 你可能需要为每种文档类型创建一个工厂，但工厂方法通常只负责创建“一个”产品实例，而不是“一步步组装”一个复杂产品。它更侧重于决定创建哪个具体类的对象，而不是如何构建这个对象的内部结构。它无法很好地处理这种多步骤、可变序列的构建。
- 如果用抽象工厂： 抽象工厂是用来创建“一系列相关或相互依赖的对象家族”的。比如一个UI工厂可以创建Windows风格的按钮和文本框，或者Mac风格的按钮和文本框。它关注的是产品家族的兼容性，而不是一个单一复杂产品的内部构建流程。它在管理多套相互关联的组件集时很强大，但在构建一个由多个可选且有序步骤组成的对象时，就不那么直接了。
-
建造者模式的优势： 在文档生成这个场景下，建造者模式就能完美契合。你可以有一个
DocumentBuilder接口，定义buildTitle(),buildParagraph(),buildImage(),buildTable()等方法。然后有HtmlDocumentBuilder,MarkdownDocumentBuilder,PdfDraftBuilder等具体建造者，它们各自实现这些方法，以不同的方式组装文档的各个部分。而DocumentDirector只需要知道“我需要一个技术手册”，然后调用builder->buildTitle(); builder->buildParagraph(); builder->buildImage();这样的序列，而无需关心这些部分具体是怎么生成的，或者最终是HTML还是PDF。
所以，当构造逻辑变得复杂，涉及多步、多变，并且你希望将“如何构建”与“构建什么”解耦时，建造者模式往往是首选。它提供了一种更细粒度的控制，让构建过程更加灵活和可扩展。它允许你通过不同的建造者实现来生产同一类型产品的不同“风味”，或者通过不同的指挥者来以不同的顺序组装部件。
建造者模式在实际项目中的常见应用场景是什么？
在实际的软件开发中，建造者模式的应用场景远比我们想象的要多，尤其是在那些需要高度配置或多种变体的复杂对象构建上。
一个非常典型的场景就是配置对象或参数的构建。比如，一个网络请求对象 HttpRequest，它可能有URL、方法（GET/POST）、各种Header、请求体、超时时间、认证信息等等。如果用构造函数来承载这些，那参数列表会变得异常庞大且难以维护，甚至需要大量的重载构造函数来应对各种参数组合。通过建造者模式，你可以用一种非常流畅、可读性极高的方式来构建它，这通常被称为“链式调用”或“流式接口”。
// 伪代码，C++中通过返回*this实现
class HttpRequest {
public:
// ... 私有成员和设置方法
void send() { /* ... */ }
};
class HttpRequestBuilder {
private:
HttpRequest request_; // 正在构建的请求对象
public:
HttpRequestBuilder& withUrl(const std::string& url) {
// request_.setUrl(url);
return *this;
}
HttpRequestBuilder& withMethod(const std::string& method) {
// request_.setMethod(method);
return *this;
}
HttpRequestBuilder& addHeader(const std::string& key, const std::string& value) {
// request_.addHeader(key, value);
return *this;
}
HttpRequestBuilder& setBody(const std::string& body) 
