建造者模式实战：告别构造函数爆炸！复杂对象优雅组装，扩展不修改老代码

原创 已于 2025-11-25 14:32:06 修改 · 769 阅读 · 23 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#建造者模式 #c++ #算法 #设计模式

于 2025-11-18 07:45:02 首次发布

目录

引言：为什么创建复杂对象总让你头疼？

一、先搞懂：建造者模式到底是什么？

1.1 核心思想：“分步构建，统一组装”

1.2 建造者模式的 4 个核心角色（缺一不可）

1.3 建造者模式 vs 工厂模式：别搞混了！

1.4 什么时候该用建造者模式？3 个典型场景

二、C++ 反例实战：没有建造者的 “复杂订单” 有多坑？

2.1 需求背景

2.2 反例代码：构造函数爆炸 + 创建逻辑混乱

2.3 反例代码的 4 大致命问题

三、C++ 重构实战：用建造者模式打造 “优雅组装” 的订单系统

3.1 重构后的完整代码

3.1.1 产品：Order（复杂对象）

3.1.2 抽象建造者与具体建造者

3.1.3 指挥者：控制构建流程

3.1.4 主函数：测试建造者模式

3.2 编译与运行说明

3.2.1 编译命令（GCC）

3.2.2 运行结果

3.3 重构后的核心优势（对比反例）

四、扩展实战：建造者模式的 3 个经典应用场景

4.1 场景 1：电脑配置组装（硬件定制）

需求：支持组装不同配置的电脑（办公本、游戏本、设计本），每种电脑的 CPU、内存、显卡、硬盘配置不同，组装流程固定（CPU→主板→内存→显卡→硬盘）。

建造者模式实现：

4.2 场景 2：文档生成器（多格式文档）

需求：生成不同格式的文档（HTML 文档、Markdown 文档），文档包含标题、段落、列表、图片，生成流程固定（标题→段落→列表→图片）。

建造者模式实现：

4.3 场景 3：复杂消息构造（网络通信）

需求：构造不同类型的网络消息（登录消息、数据上报消息），消息包含头部（版本、类型、长度）、主体（业务数据）、尾部（校验码），构造流程固定（头部→主体→尾部）。

建造者模式实现：

五、C++ 实战避坑指南：建造者模式的 5 个常见误区

误区 1：滥用建造者模式，简单对象也用

误区 2：指挥者职责不清，耦合具体建造者

误区 3：建造者步骤过多，接口臃肿

误区 4：忽略链式调用，导致代码繁琐

误区 5：混淆建造者模式与流畅接口（Fluent Interface）

六、总结：建造者模式的核心与实战建议

6.1 核心要点提炼

6.2 C++ 实战建议

6.3 最后一句话

class 卑微码农:
    def __init__(self):
        self.技能 = ['能读懂十年前祖传代码', '擅长用Ctrl+C/V搭建世界', '信奉"能跑就别动"的玄学']
        self.发量 = 100  # 初始发量
        self.咖啡因耐受度 = '极限'
        
    def 修Bug(self, bug):
        try:
            # 试图用玄学解决问题
            if bug.严重程度 == '离谱':
                print("这一定是环境问题！")
            else:
                print("让我看看是谁又没写注释...哦，是我自己。")
        except Exception as e:
            # 如果try块都救不了，那就...
            print("重启一下试试？")
            self.发量 -= 1  # 每解决一个bug，头发-1
 
 
# 实例化一个我
我 = 卑微码农()

引言：为什么创建复杂对象总让你头疼？

作为 C++ 开发者，你一定写过这样的代码：

// 复杂对象：电商订单（包含基础信息、支付信息、物流信息、商品列表、优惠券）
class Order {
public:
    // 构造函数参数爆炸！10+参数，顺序记不住，容易传错
    Order(const std::string& orderId, const std::string& userId, double totalAmount,
          const std::string& payType, const std::string& payStatus,
          const std::string& receiverName, const std::string& receiverPhone,
          const std::string& address, const std::vector<std::string>& products,
          const std::string& couponCode = "", double discount = 0.0) 
        : orderId_(orderId), userId_(userId), totalAmount_(totalAmount),
          payType_(payType), payStatus_(payStatus), receiverName_(receiverName),
          receiverPhone_(receiverPhone), address_(address), products_(products),
          couponCode_(couponCode), discount_(discount) {}

private:
    // 10+成员变量，涵盖基础、支付、物流、商品、优惠等信息
    std::string orderId_;
    std::string userId_;
    double totalAmount_;
    std::string payType_;
    std::string payStatus_;
    std::string receiverName_;
    std::string receiverPhone_;
    std::string address_;
    std::vector<std::string> products_;
    std::string couponCode_;
    double discount_;
};

// 创建订单时，参数顺序容易搞混，漏传/错传风险极高
Order order("ORDER001", "USER100", 199.9, "微信支付", "已支付",
            "张三", "13800138000", "北京市海淀区", {"手机", "耳机"}, "COUPON10", 10.0);

这段代码的痛点，你大概率深有体会：

  • 构造函数爆炸：复杂对象的成员变量越多，构造函数参数越长，顺序难记，传参容易出错；
  • 创建逻辑分散：如果对象需要分步创建（比如先填基础信息，再加商品，最后用优惠券），逻辑会散落在业务代码中，难以维护；
  • 扩展困难：新增字段（如发票信息）时，需要修改构造函数和所有创建订单的地方，违反开放封闭原则；
  • 灵活性差：无法灵活创建不同 “配置” 的对象（比如有的订单有优惠券，有的没有；有的需要物流，有的自提）。

而建造者模式（Builder Pattern），正是为解决 “复杂对象创建” 而生的设计模式：它将复杂对象的构造过程与表示分离，通过 “建造者” 逐步构建对象，“指挥者” 控制构建流程，最终让同一构造过程能创建不同的对象表示，实现复杂对象的优雅组装。

这篇文章不会堆砌枯燥的 UML 图，而是用 C++ 实战场景 + 可运行代码 + 真实踩坑经验，带你彻底吃透建造者模式。不管你是刚接触设计模式的新手，还是想解决复杂对象创建混乱的开发者，读完这篇，你都能写出 “构造逻辑清晰，扩展不碰老代码” 的优雅代码。

一、先搞懂：建造者模式到底是什么？

1.1 核心思想：“分步构建，统一组装”

建造者模式的核心是：将复杂对象的构建过程拆分为多个步骤（如创建订单基础信息、添加商品、设置支付方式），由具体建造者实现每个步骤，指挥者控制步骤的执行顺序，最终构建出不同配置的复杂对象。

用一句大白话解释：建造者模式就像 “组装家具”—— 宜家的家具（产品）有统一的组装步骤（抽象建造者），不同款式的家具（具体产品）有对应的组装说明书（具体建造者），你（指挥者）按照说明书一步步组装，最终得到不同的家具（不同表示）。

举个生活化的例子：

  • 产品：电脑（包含 CPU、主板、内存、显卡、硬盘等部件）；
  • 抽象建造者：电脑组装指南（定义 “装 CPU”“装主板”“装内存” 等步骤）；
  • 具体建造者：联想电脑组装厂、戴尔电脑组装厂（各自实现组装步骤，用不同品牌的部件）；
  • 指挥者：组装工人（按照指南的顺序，调用具体建造者的步骤，完成电脑组装）。

这样一来，同一组装流程（指挥者），可以通过不同的建造者，组装出联想、戴尔等不同配置的电脑，且新增电脑品牌时，只需新增建造者，无需修改指挥者和组装流程。

1.2 建造者模式的 4 个核心角色（缺一不可）

理解建造者模式，必须记住 4 个核心角色，它们各司其职，共同完成复杂对象的构建：

  • 产品（Product）：需要构建的复杂对象（如订单、电脑），包含多个组成部分；
  • 抽象建造者（Abstract Builder）：定义构建产品的抽象步骤（如buildBasicInfo()“buildPayInfo()），通常包含一个获取最终产品的方法（getProduct()`）；
  • 具体建造者（Concrete Builder）：实现抽象建造者的步骤，负责具体部件的创建和组装（如 “普通订单建造者”“VIP 订单建造者”）；
  • 指挥者（Director）：负责控制构建流程的顺序（如先构建基础信息，再构建支付信息，最后构建物流信息），调用具体建造者的步骤完成构建，不直接依赖产品的具体实现。

它们的协作流程：

  1. 客户端创建指挥者和具体建造者实例；
  2. 指挥者关联具体建造者，调用建造步骤；
  3. 具体建造者执行每个步骤，组装产品部件；
  4. 客户端通过建造者获取最终产品。

1.3 建造者模式 vs 工厂模式：别搞混了！

很多开发者分不清建造者模式和工厂模式，这里用一句话和表格明确区别：

  • 核心区别：工厂模式关注 “创建产品的整体”，建造者模式关注 “分步构建产品的过程”；
  • 工厂模式：给你原材料（参数），直接给你成品（产品）；
  • 建造者模式：给你原材料，一步步教你组装，最终得到成品（支持不同组装方式得到不同成品）。
维度建造者模式工厂模式（抽象工厂 / 工厂方法）
核心目标分步构建复杂对象，控制构建过程快速创建产品，不关心构建过程
产品特点产品复杂，由多个部件组成（如订单、电脑）产品相对简单，或产品族的整体创建
关注重点构建步骤和流程产品的创建结果
客户端参与度可通过指挥者或直接控制构建步骤只需传入参数，不参与创建过程

举个例子：

  • 工厂模式：你去奶茶店，点一杯 “珍珠奶茶”（参数），店员直接给你做好的奶茶（产品）；
  • 建造者模式：你去奶茶店，选择 “自定义奶茶”，一步步选茶底、甜度、配料、冰量（分步构建），店员按照你的选择组装（指挥者），最终得到专属奶茶（产品）。

1.4 什么时候该用建造者模式？3 个典型场景

建造者模式不是万能的，以下 3 种场景下它是最优解：

  1. 复杂对象创建：对象包含多个部件，且部件的组装顺序固定或可配置（如订单、电脑、文档）；
  2. 构造函数爆炸：对象的构造函数参数过多（超过 5 个），或有很多可选参数，导致传参困难；
  3. 同一构建过程需不同表示：相同的构建步骤，需要得到不同配置的产品（如 “普通订单” 和 “VIP 订单”，构建步骤相同，但 VIP 订单多了优惠券和优先物流）。

简单说：当你觉得 “这个对象创建太麻烦了，参数多、步骤杂、还得灵活配置” 时，就该用建造者模式。

二、C++ 反例实战：没有建造者的 “复杂订单” 有多坑？

为了让你直观感受建造者模式的价值，我们先实现一个 “没有建造者” 的复杂订单系统，看看它的痛点有多明显。

2.1 需求背景

实现一个电商订单系统，核心需求：

  1. 订单包含基础信息（订单号、用户 ID、总金额）、支付信息（支付方式、支付状态）、物流信息（收件人、电话、地址）、商品列表、优惠券信息（可选）；
  2. 支持普通订单和 VIP 订单（VIP 订单有专属优惠券、优先物流标识）；
  3. 未来可能新增 “企业订单”（包含发票信息、对公支付信息）。

2.2 反例代码：构造函数爆炸 + 创建逻辑混乱

#include <iostream>
#include <string>
#include <vector>
#include <ctime>

// 复杂产品：电商订单
class Order {
public:
    // 构造函数爆炸！11个参数，其中3个是可选参数，顺序极易混淆
    Order(const std::string& orderId, const std::string& userId, double totalAmount,
          const std::string& payType, const std::string& payStatus,
          const std::string& receiverName, const std::string& receiverPhone,
          const std::string& address, const std::vector<std::string>& products,
          const std::string& couponCode = "", bool isVip = false)
        : orderId_(orderId), userId_(userId), totalAmount_(totalAmount),
          payType_(payType), payStatus_(payStatus), receiverName_(receiverName),
          receiverPhone_(receiverPhone), address_(address), products_(products),
          couponCode_(couponCode), isVip_(isVip), isPriorityLogistics_(isVip) {
        // 构造函数中还要处理逻辑：VIP订单默认优先物流
        createTime_ = getCurrentTime();
    }

    // 新增企业订单字段后，需要修改构造函数（违反开放封闭原则）
    // 新增参数：invoiceTitle（发票抬头）、companyName（企业名称）
    Order(const std::string& orderId, const std::string& userId, double totalAmount,
          const std::string& payType, const std::string& payStatus,
          const std::string& receiverName, const std::string& receiverPhone,
          const std::string& address, const std::vector<std::string>& products,
          const std::string& couponCode = "", bool isVip = false,
          const std::string& invoiceTitle = "", const std::string& companyName = "")
        : orderId_(orderId), userId_(userId), totalAmount_(totalAmount),
          payType_(payType), payStatus_(payStatus), receiverName_(receiverName),
          receiverPhone_(receiverPhone), address_(address), products_(products),
          couponCode_(couponCode), isVip_(isVip), isPriorityLogistics_(isVip),
          invoiceTitle_(invoiceTitle), companyName_(companyName) {
        createTime_ = getCurrentTime();
    }

    // 业务方法：打印订单信息
    void printOrder() const {
        std::cout << "=== 订单信息 ===" << std::endl;
        std::cout << "订单号：" << orderId_ << std::endl;
        std::cout << "创建时间：" << createTime_ << std::endl;
        std::cout << "用户ID：" << userId_ << std::endl;
        std::cout << "总金额：" << totalAmount_ << "元" << std::endl;
        std::cout << "支付方式：" << payType_ << "，状态：" << payStatus_ << std::endl;
        std::cout << "收件人：" << receiverName_ << "，电话：" << receiverPhone_ << std::endl;
        std::cout << "收货地址：" << address_ << std::endl;
        std::cout << "商品列表：";
        for (const auto& product : products_) {
            std::cout << product << " ";
        }
        std::cout << std::endl;
        if (!couponCode_.empty()) {
            std::cout << "优惠券：" << couponCode_ << std::endl;
        }
        std::cout << "VIP订单：" << (isVip_ ? "是" : "否") << "，优先物流：" << (isPriorityLogistics_ ? "是" : "否") << std::endl;
        if (!companyName_.empty()) {
            std::cout << "企业名称：" << companyName_ << "，发票抬头：" << invoiceTitle_ << std::endl;
        }
    }

private:
    // 辅助函数：获取当前时间
    std::string getCurrentTime() {
        time_t now = time(nullptr);
        char timeStr[26];
        ctime_s(timeStr, sizeof(timeStr), &now);
        return timeStr;
    }

    // 订单基础信息
    std::string orderId_;
    std::string userId_;
    double totalAmount_;
    std::string createTime_;

    // 支付信息
    std::string payType_;
    std::string payStatus_;

    // 物流信息
    std::string receiverName_;
    std::string receiverPhone_;
    std::string address_;
    bool isPriorityLogistics_; // 优先物流（VIP专属）

    // 商品信息
    std::vector<std::string> products_;

    // 优惠信息
    std::string couponCode_;
    bool isVip_;

    // 企业订单专属信息（新增字段，导致构造函数修改）
    std::string invoiceTitle_;
    std::string companyName_;
};

// 业务模块：创建订单（创建逻辑分散，参数传递混乱）
int main() {
    // 1. 创建普通订单（参数顺序容易记混，漏传优惠券时需留空）
    std::vector<std::string> commonProducts = {"手机", "耳机"};
    Order commonOrder(
        "ORDER001", "USER100", 199.9,
        "微信支付", "已支付",
        "张三", "13800138000",
        "北京市海淀区XX街", commonProducts,
        "", false // 优惠券留空，非VIP
    );
    commonOrder.printOrder();

    // 2. 创建VIP订单（需要传递优惠券，标记为VIP）
    std::vector<std::string> vipProducts = {"笔记本电脑", "鼠标"};
    Order vipOrder(
        "ORDER002", "USER101", 5999.9,
        "支付宝支付", "已支付",
        "李四", "13900139000",
        "上海市浦东新区XX路", vipProducts,
        "VIP2025", true // VIP优惠券，标记为VIP
    );
    std::cout << "\n" << std::endl;
    vipOrder.printOrder();

    // 3. 创建企业订单（需要传递企业信息，构造函数参数更多）
    std::vector<std::string> companyProducts = {"办公电脑", "打印机"};
    Order companyOrder(
        "ORDER003", "COMPANY200", 12999.9,
        "对公转账", "待支付",
        "王五", "13700137000",
        "广州市天河区XX大厦", companyProducts,
        "", false,
        "XX科技有限公司", "XX科技有限公司" // 新增的企业字段
    );
    std::cout << "\n" << std::endl;
    companyOrder.printOrder();

    return 0;
}

2.3 反例代码的 4 大致命问题

这段代码能实现功能，但在实际开发中会让维护者崩溃：

  1. 构造函数爆炸：普通订单 11 个参数，企业订单 13 个参数，参数顺序极易混淆（比如把 “电话” 和 “地址” 传反），漏传可选参数时还要手动留空；
  2. 扩展困难：新增 “企业订单” 字段时，必须修改原有构造函数，违反开放封闭原则，且所有创建订单的地方都要同步修改（如果项目中有 100 个地方创建订单，就要改 100 次）；
  3. 创建逻辑分散：创建订单的逻辑散落在各个业务模块，参数传递混乱，新增步骤（如校验优惠券有效性）时，需要修改所有创建订单的代码；
  4. 可读性差：别人看代码时，很难快速理解每个参数的含义，比如Order("ORDER001", "USER100", 199.9, ...)，不看构造函数定义，根本不知道 199.9 是总金额。

这就是复杂对象创建的痛点 —— 当对象的部件增多、配置变灵活时，直接用构造函数和分散的创建逻辑会导致代码臃肿、难以维护。而建造者模式，正是为解决这个问题而生。

三、C++ 重构实战：用建造者模式打造 “优雅组装” 的订单系统

针对反例的痛点，我们用建造者模式重构，核心思路是 **“拆分构建步骤，分离构造与表示”**：

  1. 定义产品Order，保持成员变量不变；
  2. 定义抽象建造者IOrderBuilder，声明构建各个部件的步骤（buildBasicInfo()“buildPayInfo()“buildLogisticsInfo()等）；
  3. 定义具体建造者（CommonOrderBuilder“VipOrderBuilder“CompanyOrderBuilder），实现抽象步骤；
  4. 定义指挥者OrderDirector，控制构建流程的顺序；
  5. 业务模块通过指挥者和具体建造者，分步构建订单，新增订单类型时只需扩展建造者，无需修改老代码。

3.1 重构后的完整代码

3.1.1 产品：Order（复杂对象）

// Order.h（产品：电商订单）
#ifndef ORDER_H
#define ORDER_H

#include <string>
#include <vector>
#include <ctime>
#include <iostream>

class Order {
public:
    // 禁用默认构造（必须通过建造者创建）
    Order() = default;
    ~Order() = default;

    // 打印订单信息（业务方法）
    void printOrder() const {
        std::cout << "=== 订单信息 ===" << std::endl;
        std::cout << "订单号：" << orderId_ << std::endl;
        std::cout << "创建时间：" << createTime_ << std::endl;
        std::cout << "用户ID：" << userId_ << std::endl;
        std::cout << "总金额：" << totalAmount_ << "元" << std::endl;
        std::cout << "支付方式：" << payType_ << "，状态：" << payStatus_ << std::endl;
        std::cout << "收件人：" << receiverName_ << "，电话：" << receiverPhone_ << std::endl;
        std::cout << "收货地址：" << address_ << std::endl;
        std::cout << "商品列表：";
        for (const auto& product : products_) {
            std::cout << product << " ";
        }
        std::cout << std::endl;
        if (!couponCode_.empty()) {
            std::cout << "优惠券：" << couponCode_ << std::endl;
        }
        std::cout << "VIP订单：" << (isVip_ ? "是" : "否") << "，优先物流：" << (isPriorityLogistics_ ? "是" : "否") << std::endl;
        if (!companyName_.empty()) {
            std::cout << "企业名称：" << companyName_ << "，发票抬头：" << invoiceTitle_ << std::endl;
        }
    }

    // 友元声明：允许建造者访问私有成员（或提供setter方法，这里用友元更简洁）
    template <typename T>
    friend class OrderBuilder;

private:
    // 辅助函数：获取当前时间（建造者中调用）
    std::string getCurrentTime() {
        time_t now = time(nullptr);
        char timeStr[26];
        ctime_s(timeStr, sizeof(timeStr), &now);
        return timeStr;
    }

    // 订单基础信息
    std::string orderId_;
    std::string userId_;
    double totalAmount_;
    std::string createTime_;

    // 支付信息
    std::string payType_;
    std::string payStatus_;

    // 物流信息
    std::string receiverName_;
    std::string receiverPhone_;
    std::string address_;
    bool isPriorityLogistics_ = false;

    // 商品信息
    std::vector<std::string> products_;

    // 优惠信息
    std::string couponCode_;
    bool isVip_ = false;

    // 企业订单专属信息
    std::string invoiceTitle_;
    std::string companyName_;
};

#endif // ORDER_H

3.1.2 抽象建造者与具体建造者

// OrderBuilder.h（抽象建造者与具体建造者）
#ifndef ORDER_BUILDER_H
#define ORDER_BUILDER_H

#include "Order.h"
#include <vector>
#include <string>

// 抽象建造者：定义订单构建的步骤
class IOrderBuilder {
public:
    virtual ~IOrderBuilder() = default;

    // 纯虚方法：构建步骤（每个步骤返回this，支持链式调用）
    virtual IOrderBuilder& buildBasicInfo(const std::string& orderId, const std::string& userId, double totalAmount) = 0;
    virtual IOrderBuilder& buildPayInfo(const std::string& payType, const std::string& payStatus) = 0;
    virtual IOrderBuilder& buildLogisticsInfo(const std::string& receiverName, const std::string& receiverPhone, const std::string& address) = 0;
    virtual IOrderBuilder& addProducts(const std::vector<std::string>& products) = 0;
    virtual IOrderBuilder& setCoupon(const std::string& couponCode) = 0;

    // 获取最终产品
    virtual Order getProduct() = 0;

protected:
    Order order_; // 待构建的产品
};

// 具体建造者1：普通订单建造者（无VIP标识，无企业信息）
class CommonOrderBuilder : public IOrderBuilder {
public:
    IOrderBuilder& buildBasicInfo(const std::string& orderId, const std::string& userId, double totalAmount) override {
        order_.orderId_ = orderId;
        order_.userId_ = userId;
        order_.totalAmount_ = totalAmount;
        order_.createTime_ = order_.getCurrentTime();
        order_.isVip_ = false; // 普通订单默认非VIP
        return *this;
    }

    IOrderBuilder& buildPayInfo(const std::string& payType, const std::string& payStatus) override {
        order_.payType_ = payType;
        order_.payStatus_ = payStatus;
        return *this;
    }

    IOrderBuilder& buildLogisticsInfo(const std::string& receiverName, const std::string& receiverPhone, const std::string& address) override {
        order_.receiverName_ = receiverName;
        order_.receiverPhone_ = receiverPhone;
        order_.address_ = address;
        order_.isPriorityLogistics_ = false; // 普通订单默认非优先物流
        return *this;
    }

    IOrderBuilder& addProducts(const std::vector<std::string>& products) override {
        order_.products_ = products;
        return *this;
    }

    IOrderBuilder& setCoupon(const std::string& couponCode) override {
        order_.couponCode_ = couponCode; // 普通订单支持优惠券（可选）
        return *this;
    }

    Order getProduct() override {
        return std::move(order_); // 转移所有权，避免拷贝
    }
};

// 具体建造者2：VIP订单建造者（有VIP标识、优先物流）
class VipOrderBuilder : public IOrderBuilder {
public:
    IOrderBuilder& buildBasicInfo(const std::string& orderId, const std::string& userId, double totalAmount) override {
        order_.orderId_ = orderId;
        order_.userId_ = userId;
        order_.totalAmount_ = totalAmount;
        order_.createTime_ = order_.getCurrentTime();
        order_.isVip_ = true; // VIP订单默认VIP
        return *this;
    }

    IOrderBuilder& buildPayInfo(const std::string& payType, const std::string& payStatus) override {
        order_.payType_ = payType;
        order_.payStatus_ = payStatus;
        return *this;
    }

    IOrderBuilder& buildLogisticsInfo(const std::string& receiverName, const std::string& receiverPhone, const std::string& address) override {
        order_.receiverName_ = receiverName;
        order_.receiverPhone_ = receiverPhone;
        order_.address_ = address;
        order_.isPriorityLogistics_ = true; // VIP订单默认优先物流
        return *this;
    }

    IOrderBuilder& addProducts(const std::vector<std::string>& products) override {
        order_.products_ = products;
        return *this;
    }

    IOrderBuilder& setCoupon(const std::string& couponCode) override {
        order_.couponCode_ = couponCode; // VIP订单必须有优惠券（业务约束）
        return *this;
    }

    Order getProduct() override {
        return std::move(order_);
    }
};

// 具体建造者3：企业订单建造者（包含企业信息、发票抬头）
class CompanyOrderBuilder : public IOrderBuilder {
public:
    // 新增企业信息设置方法（扩展步骤，不影响抽象建造者）
    CompanyOrderBuilder& setCompanyInfo(const std::string& companyName, const std::string& invoiceTitle) {
        order_.companyName_ = companyName;
        order_.invoiceTitle_ = invoiceTitle;
        return *this;
    }

    IOrderBuilder& buildBasicInfo(const std::string& orderId, const std::string& userId, double totalAmount) override {
        order_.orderId_ = orderId;
        order_.userId_ = userId;
        order_.totalAmount_ = totalAmount;
        order_.createTime_ = order_.getCurrentTime();
        order_.isVip_ = false; // 企业订单默认非VIP
        return *this;
    }

    IOrderBuilder& buildPayInfo(const std::string& payType, const std::string& payStatus) override {
        order_.payType_ = payType;
        order_.payStatus_ = payStatus;
        return *this;
    }

    IOrderBuilder& buildLogisticsInfo(const std::string& receiverName, const std::string& receiverPhone, const std::string& address) override {
        order_.receiverName_ = receiverName;
        order_.receiverPhone_ = receiverPhone;
        order_.address_ = address;
        order_.isPriorityLogistics_ = false; // 企业订单默认非优先物流
        return *this;
    }

    IOrderBuilder& addProducts(const std::vector<std::string>& products) override {
        order_.products_ = products;
        return *this;
    }

    IOrderBuilder& setCoupon(const std::string& couponCode) override {
        order_.couponCode_ = couponCode; // 企业订单支持优惠券（可选）
        return *this;
    }

    Order getProduct() override {
        return std::move(order_);
    }
};

#endif // ORDER_BUILDER_H

3.1.3 指挥者：控制构建流程

// OrderDirector.h（指挥者：控制构建流程）
#ifndef ORDER_DIRECTOR_H
#define ORDER_DIRECTOR_H

#include "OrderBuilder.h"
#include <vector>
#include <string>

// 指挥者：负责控制订单构建的顺序，不依赖具体建造者
class OrderDirector {
public:
    // 构建普通订单（固定流程：基础信息→支付信息→商品→物流→优惠券）
    Order constructCommonOrder(IOrderBuilder& builder,
                               const std::string& orderId, const std::string& userId, double totalAmount,
                               const std::string& payType, const std::string& payStatus,
                               const std::vector<std::string>& products,
                               const std::string& receiverName, const std::string& receiverPhone, const std::string& address,
                               const std::string& couponCode = "") {
        return builder
            .buildBasicInfo(orderId, userId, totalAmount)
            .buildPayInfo(payType, payStatus)
            .addProducts(products)
            .buildLogisticsInfo(receiverName, receiverPhone, address)
            .setCoupon(couponCode)
            .getProduct();
    }

    // 构建VIP订单（流程同上，建造者不同）
    Order constructVipOrder(IOrderBuilder& builder,
                            const std::string& orderId, const std::string& userId, double totalAmount,
                            const std::string& payType, const std::string& payStatus,
                            const std::vector<std::string>& products,
                            const std::string& receiverName, const std::string& receiverPhone, const std::string& address,
                            const std::string& couponCode) {
        // VIP订单必须有优惠券，这里可以加校验（指挥者负责流程约束）
        if (couponCode.empty()) {
            throw std::invalid_argument("VIP订单必须设置优惠券");
        }
        return builder
            .buildBasicInfo(orderId, userId, totalAmount)
            .buildPayInfo(payType, payStatus)
            .addProducts(products)
            .buildLogisticsInfo(receiverName, receiverPhone, address)
            .setCoupon(couponCode)
            .getProduct();
    }

    // 构建企业订单（扩展流程：基础信息→支付信息→商品→物流→企业信息→优惠券）
    Order constructCompanyOrder(CompanyOrderBuilder& builder,
                                const std::string& orderId, const std::string& userId, double totalAmount,
                                const std::string& payType, const std::string& payStatus,
                                const std::vector<std::string>& products,
                                const std::string& receiverName, const std::string& receiverPhone, const std::string& address,
                                const std::string& companyName, const std::string& invoiceTitle,
                                const std::string& couponCode = "") {
        return builder
            .buildBasicInfo(orderId, userId, totalAmount)
            .buildPayInfo(payType, payStatus)
            .addProducts(products)
            .buildLogisticsInfo(receiverName, receiverPhone, address)
            .setCompanyInfo(companyName, invoiceTitle) // 新增企业信息步骤
            .setCoupon(couponCode)
            .getProduct();
    }
};

#endif // ORDER_DIRECTOR_H

3.1.4 主函数：测试建造者模式

// main.cpp
#include <iostream>
#include "OrderDirector.h"
#include "OrderBuilder.h"

int main() {
    OrderDirector director;

    // 1. 构建普通订单
    std::cout << "=== 构建普通订单 ===" << std::endl;
    CommonOrderBuilder commonBuilder;
    std::vector<std::string> commonProducts = {"手机", "耳机"};
    Order commonOrder = director.constructCommonOrder(
        commonBuilder,
        "ORDER001", "USER100", 199.9,
        "微信支付", "已支付",
        commonProducts,
        "张三", "13800138000", "北京市海淀区XX街",
        "" // 普通订单无优惠券
    );
    commonOrder.printOrder();

    // 2. 构建VIP订单
    std::cout << "\n\n=== 构建VIP订单 ===" << std::endl;
    VipOrderBuilder vipBuilder;
    std::vector<std::string> vipProducts = {"笔记本电脑", "鼠标"};
    try {
        Order vipOrder = director.constructVipOrder(
            vipBuilder,
            "ORDER002", "USER101", 5999.9,
            "支付宝支付", "已支付",
            vipProducts,
            "李四", "13900139000", "上海市浦东新区XX路",
            "VIP2025" // VIP订单必须有优惠券
        );
        vipOrder.printOrder();
    } catch (const std::invalid_argument& e) {
        std::cerr << "VIP订单构建失败：" << e.what() << std::endl;
    }

    // 3. 构建企业订单
    std::cout << "\n\n=== 构建企业订单 ===" << std::endl;
    CompanyOrderBuilder companyBuilder;
    std::vector<std::string> companyProducts = {"办公电脑", "打印机"};
    Order companyOrder = director.constructCompanyOrder(
        companyBuilder,
        "ORDER003", "COMPANY200", 12999.9,
        "对公转账", "待支付",
        companyProducts,
        "王五", "13700137000", "广州市天河区XX大厦",
        "XX科技有限公司", "XX科技有限公司", // 企业信息
        "COMPANY500" // 企业订单优惠券
    );
    companyOrder.printOrder();

    // 4. 链式调用直接构建（不通过指挥者，灵活控制步骤）
    std::cout << "\n\n=== 链式调用构建订单 ===" << std::endl;
    CommonOrderBuilder chainBuilder;
    Order chainOrder = chainBuilder
        .buildBasicInfo("ORDER004", "USER102", 299.9)
        .buildPayInfo("银联支付", "已支付")
        .addProducts({"键盘", "鼠标垫"})
        .buildLogisticsInfo("赵六", "13600136000", "深圳市南山区XX路")
        .setCoupon("COMMON100")
        .getProduct();
    chainOrder.printOrder();

    return 0;
}

3.2 编译与运行说明

3.2.1 编译命令（GCC）

g++ -std=c++11 main.cpp -o order_builder_system
  • 依赖：C++11 及以上标准（支持移动语义、链式调用）；
  • 编译环境：Linux/GCC、Windows/MinGW、Mac/Clang 均可。

3.2.2 运行结果

=== 构建普通订单 ===
=== 订单信息 ===
订单号：ORDER001
创建时间：Mon May 20 15:30:00 2025

用户ID：USER100
总金额：199.9元
支付方式：微信支付，状态：已支付
收件人：张三，电话：13800138000
收货地址：北京市海淀区XX街
商品列表：手机 耳机 
VIP订单：否，优先物流：否


=== 构建VIP订单 ===
=== 订单信息 ===
订单号：ORDER002
创建时间：Mon May 20 15:30:00 2025

用户ID：USER101
总金额：5999.9元
支付方式：支付宝支付，状态：已支付
收件人：李四，电话：13900139000
收货地址：上海市浦东新区XX路
商品列表：笔记本电脑 鼠标 
优惠券：VIP2025
VIP订单：是，优先物流：是


=== 构建企业订单 ===
=== 订单信息 ===
订单号：ORDER003
创建时间：Mon May 20 15:30:00 2025

用户ID：COMPANY200
总金额：12999.9元
支付方式：对公转账，状态：待支付
收件人：王五，电话：13700137000
收货地址：广州市天河区XX大厦
商品列表：办公电脑 打印机 
优惠券：COMPANY500
VIP订单：否，优先物流：否
企业名称：XX科技有限公司，发票抬头：XX科技有限公司


=== 链式调用构建订单 ===
=== 订单信息 ===
订单号：ORDER004
创建时间：Mon May 20 15:30:00 2025

用户ID：USER102
总金额：299.9元
支付方式：银联支付，状态：已支付
收件人：赵六，电话：13600136000
收货地址：深圳市南山区XX路
商品列表：键盘 鼠标垫 
优惠券：COMMON100
VIP订单：否，优先物流：否

3.3 重构后的核心优势（对比反例）

重构后的代码完全符合建造者模式，解决了反例的所有问题：

  1. 告别构造函数爆炸：通过分步构建和链式调用，替代了十几个参数的构造函数，参数含义清晰，无需记忆顺序；
  2. 扩展灵活：新增订单类型（如企业订单）时，只需新增具体建造者，无需修改原有建造者、指挥者或产品类，符合开放封闭原则；
  3. 构建流程可控：指挥者统一控制构建顺序，避免步骤混乱（如先构建物流信息再构建基础信息），且可在指挥者中添加校验逻辑（如 VIP 订单必须有优惠券）；
  4. 可读性极强：builder.buildBasicInfo(...).buildPayInfo(...)的链式调用，让创建逻辑一目了然，别人看代码能快速理解构建过程；
  5. 复用性高：同一构建流程可通过不同建造者创建不同产品（如指挥者的constructCommonOrder流程，可通过CommonOrderBuilder和VipOrderBuilder创建普通和 VIP 订单）；
  6. 灵活度高：支持两种使用方式 —— 通过指挥者（固定流程）或直接链式调用（自定义流程），满足不同业务场景。

四、扩展实战：建造者模式的 3 个经典应用场景

建造者模式的核心价值是 “分步构建复杂对象”，在 C++ 开发中，凡是需要 “灵活组装复杂对象” 的场景，都能发挥其优势。下面通过 3 个真实场景，展示模式的灵活性。

4.1 场景 1：电脑配置组装（硬件定制）

需求：支持组装不同配置的电脑（办公本、游戏本、设计本），每种电脑的 CPU、内存、显卡、硬盘配置不同，组装流程固定（CPU→主板→内存→显卡→硬盘）。

建造者模式实现：

// 产品：电脑
class Computer {
public:
    void setCPU(const std::string& cpu) { cpu_ = cpu; }
    void setMotherboard(const std::string& motherboard) { motherboard_ = motherboard; }
    void setRAM(const std::string& ram) { ram_ = ram; }
    void setGPU(const std::string& gpu) { gpu_ = gpu; }
    void setHDD(const std::string& hdd) { hdd_ = hdd; }

    void showConfig() const {
        std::cout << "=== 电脑配置 ===" << std::endl;
        std::cout << "CPU：" << cpu_ << std::endl;
        std::cout << "主板：" << motherboard_ << std::endl;
        std::cout << "内存：" << ram_ << std::endl;
        std::cout << "显卡：" << gpu_ << std::endl;
        std::cout << "硬盘：" << hdd_ << std::endl;
    }

private:
    std::string cpu_;
    std::string motherboard_;
    std::string ram_;
    std::string gpu_;
    std::string hdd_;
};

// 抽象建造者
class IComputerBuilder {
public:
    virtual ~IComputerBuilder() = default;
    virtual IComputerBuilder& buildCPU() = 0;
    virtual IComputerBuilder& buildMotherboard() = 0;
    virtual IComputerBuilder& buildRAM() = 0;
    virtual IComputerBuilder& buildGPU() = 0;
    virtual IComputerBuilder& buildHDD() = 0;
    virtual Computer getComputer() = 0;

protected:
    Computer computer_;
};

// 具体建造者1：办公本建造者（低配置，无独立显卡）
class OfficeComputerBuilder : public IComputerBuilder {
public:
    IComputerBuilder& buildCPU() override {
        computer_.setCPU("Intel i5-1240P");
        return *this;
    }

    IComputerBuilder& buildMotherboard() override {
        computer_.setMotherboard("华硕B660M");
        return *this;
    }

    IComputerBuilder& buildRAM() override {
        computer_.setRAM("16GB DDR4");
        return *this;
    }

    IComputerBuilder& buildGPU() override {
        computer_.setGPU("集成显卡UHD 730");
        return *this;
    }

    IComputerBuilder& buildHDD() override {
        computer_.setHDD("512GB SSD");
        return *this;
    }

    Computer getComputer() override {
        return std::move(computer_);
    }
};

// 具体建造者2：游戏本建造者（高配置，独立显卡）
class GamingComputerBuilder : public IComputerBuilder {
public:
    IComputerBuilder& buildCPU() override {
        computer_.setCPU("Intel i7-13700HX");
        return *this;
    }

    IComputerBuilder& buildMotherboard() override {
        computer_.setMotherboard("微星Z790");
        return *this;
    }

    IComputerBuilder& buildRAM() override {
        computer_.setRAM("32GB DDR5");
        return *this;
    }

    IComputerBuilder& buildGPU() override {
        computer_.setGPU("NVIDIA RTX 4070");
        return *this;
    }

    IComputerBuilder& buildHDD() override {
        computer_.setHDD("1TB SSD + 2TB HDD");
        return *this;
    }

    Computer getComputer() override {
        return std::move(computer_);
    }
};

// 指挥者
class ComputerDirector {
public:
    Computer construct(IComputerBuilder& builder) {
        return builder
            .buildCPU()
            .buildMotherboard()
            .buildRAM()
            .buildGPU()
            .buildHDD()
            .getComputer();
    }
};

// 测试代码
int main() {
    ComputerDirector director;

    // 组装办公本
    OfficeComputerBuilder officeBuilder;
    Computer officePC = director.construct(officeBuilder);
    std::cout << "办公本配置：" << std::endl;
    officePC.showConfig();

    // 组装游戏本
    GamingComputerBuilder gamingBuilder;
    Computer gamingPC = director.construct(gamingBuilder);
    std::cout << "\n游戏本配置：" << std::endl;
    gamingPC.showConfig();

    return 0;
}

运行结果：

办公本配置：
=== 电脑配置 ===
CPU：Intel i5-1240P
主板：华硕B660M
内存：16GB DDR4
显卡：集成显卡UHD 730
硬盘：512GB SSD

游戏本配置：
=== 电脑配置 ===
CPU：Intel i7-13700HX
主板：微星Z790
内存：32GB DDR5
显卡：NVIDIA RTX 4070
硬盘：1TB SSD + 2TB HDD

优势：新增 “设计本” 时，只需新增DesignComputerBuilder，指挥者和产品无需修改，实现灵活扩展。

4.2 场景 2：文档生成器（多格式文档）

需求：生成不同格式的文档（HTML 文档、Markdown 文档），文档包含标题、段落、列表、图片，生成流程固定（标题→段落→列表→图片）。

建造者模式实现：

// 产品：文档
class Document {
public:
    void addElement(const std::string& element) {
        elements_.push_back(element);
    }

    void show() const {
        for (const auto& elem : elements_) {
            std::cout << elem << std::endl;
        }
    }

private:
    std::vector<std::string> elements_;
};

// 抽象建造者
class IDocumentBuilder {
public:
    virtual ~IDocumentBuilder() = default;
    virtual IDocumentBuilder& buildTitle(const std::string& title) = 0;
    virtual IDocumentBuilder& buildParagraph(const std::string& content) = 0;
    virtual IDocumentBuilder& buildList(const std::vector<std::string>& items) = 0;
    virtual IDocumentBuilder& buildImage(const std::string& path) = 0;
    virtual Document getDocument() = 0;

protected:
    Document doc_;
};

// 具体建造者1：HTML文档建造者
class HtmlDocumentBuilder : public IDocumentBuilder {
public:
    IDocumentBuilder& buildTitle(const std::string& title) override {
        doc_.addElement("<h1>" + title + "</h1>");
        return *this;
    }

    IDocumentBuilder& buildParagraph(const std::string& content) override {
        doc_.addElement("<p>" + content + "</p>");
        return *this;
    }

    IDocumentBuilder& buildList(const std::vector<std::string>& items) override {
        doc_.addElement("<ul>");
        for (const auto& item : items) {
            doc_.addElement("  <li>" + item + "</li>");
        }
        doc_.addElement("</ul>");
        return *this;
    }

    IDocumentBuilder& buildImage(const std::string& path) override {
        doc_.addElement("<img src=\"" + path + "\" alt=\"image\">");
        return *this;
    }

    Document getDocument() override {
        return std::move(doc_);
    }
};

// 具体建造者2：Markdown文档建造者
class MarkdownDocumentBuilder : public IDocumentBuilder {
public:
    IDocumentBuilder& buildTitle(const std::string& title) override {
        doc_.addElement("# " + title);
        return *this;
    }

    IDocumentBuilder& buildParagraph(const std::string& content) override {
        doc_.addElement(content);
        doc_.addElement(""); // 空行分隔
        return *this;
    }

    IDocumentBuilder& buildList(const std::vector<std::string>& items) override {
        for (const auto& item : items) {
            doc_.addElement("- " + item);
        }
        doc_.addElement(""); // 空行分隔
        return *this;
    }

    IDocumentBuilder& buildImage(const std::string& path) override {
        doc_.addElement("![image](" + path + ")");
        return *this;
    }

    Document getDocument() override {
        return std::move(doc_);
    }
};

// 指挥者
class DocumentDirector {
public:
    Document construct(IDocumentBuilder& builder,
                       const std::string& title,
                       const std::string& paragraph,
                       const std::vector<std::string>& listItems,
                       const std::string& imagePath) {
        return builder
            .buildTitle(title)
            .buildParagraph(paragraph)
            .buildList(listItems)
            .buildImage(imagePath)
            .getDocument();
    }
};

// 测试代码
int main() {
    DocumentDirector director;
    std::vector<std::string> listItems = {"设计模式", "建造者模式", "C++实战"};

    // 生成HTML文档
    std::cout << "=== HTML文档 ===" << std::endl;
    HtmlDocumentBuilder htmlBuilder;
    Document htmlDoc = director.construct(htmlBuilder, "建造者模式教程", "建造者模式用于分步构建复杂对象", listItems, "design_pattern.jpg");
    htmlDoc.show();

    // 生成Markdown文档
    std::cout << "\n=== Markdown文档 ===" << std::endl;
    MarkdownDocumentBuilder mdBuilder;
    Document mdDoc = director.construct(mdBuilder, "建造者模式教程", "建造者模式用于分步构建复杂对象", listItems, "design_pattern.jpg");
    mdDoc.show();

    return 0;
}

运行结果：

=== HTML文档 ===
<h1>建造者模式教程</h1>
<p>建造者模式用于分步构建复杂对象</p>
<ul>
  <li>设计模式</li>
  <li>建造者模式</li>
  <li>C++实战</li>
</ul>
<img src="design_pattern.jpg" alt="image">

=== Markdown文档 ===
# 建造者模式教程
建造者模式用于分步构建复杂对象

- 设计模式
- 建造者模式
- C++实战

![image](design_pattern.jpg)

优势：新增 “PDF 文档” 时，只需新增PdfDocumentBuilder，指挥者无需修改，实现多格式文档的统一生成流程。

4.3 场景 3：复杂消息构造（网络通信）

需求：构造不同类型的网络消息（登录消息、数据上报消息），消息包含头部（版本、类型、长度）、主体（业务数据）、尾部（校验码），构造流程固定（头部→主体→尾部）。

建造者模式实现：

#include <vector>
#include <string>
#include <iostream>
#include <cstdint>

// 产品：网络消息（二进制格式）
class NetworkMessage {
public:
    void setHeader(uint8_t version, uint8_t type, uint32_t length) {
        header_.version = version;
        header_.type = type;
        header_.length = length;
    }

    void setBody(const std::vector<uint8_t>& body) {
        body_ = body;
    }

    void setTail(uint16_t checksum) {
        tail_.checksum = checksum;
    }

    // 序列化消息（模拟）
    std::vector<uint8_t> serialize() const {
        std::vector<uint8_t> data;
        // 序列化头部
        data.push_back(header_.version);
        data.push_back(header_.type);
        data.insert(data.end(), reinterpret_cast<const uint8_t*>(&header_.length), reinterpret_cast<const uint8_t*>(&header_.length) + 4);
        // 序列化主体
        data.insert(data.end(), body_.begin(), body_.end());
        // 序列化尾部
        data.insert(data.end(), reinterpret_cast<const uint8_t*>(&tail_.checksum), reinterpret_cast<const uint8_t*>(&tail_.checksum) + 2);
        return data;
    }

    void print() const {
        std::cout << "消息版本：" << (int)header_.version << std::endl;
        std::cout << "消息类型：" << (int)header_.type << std::endl;
        std::cout << "消息长度：" << header_.length << std::endl;
        std::cout << "消息主体：";
        for (uint8_t byte : body_) {
            std::cout << std::hex << (int)byte << " ";
        }
        std::cout << std::endl;
        std::cout << "校验码：" << std::hex << tail_.checksum << std::endl;
    }

private:
    // 消息头部
    struct Header {
        uint8_t version;  // 版本号
        uint8_t type;     // 消息类型（1=登录，2=数据上报）
        uint32_t length;  // 消息总长度
    } header_;

    // 消息主体
    std::vector<uint8_t> body_;

    // 消息尾部
    struct Tail {
        uint16_t checksum; // CRC校验码
    } tail_;
};

// 抽象建造者
class IMessageBuilder {
public:
    virtual ~IMessageBuilder() = default;
    virtual IMessageBuilder& buildHeader(uint8_t version, uint8_t type) = 0;
    virtual IMessageBuilder& buildBody(const std::vector<uint8_t>& data) = 0;
    virtual IMessageBuilder& buildTail() = 0; // 自动计算校验码
    virtual NetworkMessage getMessage() = 0;

protected:
    NetworkMessage msg_;

    // 辅助函数：计算CRC校验码（简化）
    uint16_t calculateChecksum(const std::vector<uint8_t>& data) {
        uint16_t checksum = 0;
        for (uint8_t byte : data) {
            checksum += byte;
        }
        return checksum;
    }
};

// 具体建造者1：登录消息建造者
class LoginMessageBuilder : public IMessageBuilder {
public:
    IMessageBuilder& buildHeader(uint8_t version, uint8_t type) override {
        // 登录消息类型固定为1
        msg_.setHeader(version, 1, 0); // 长度后续计算
        return *this;
    }

    IMessageBuilder& buildBody(const std::vector<uint8_t>& data) override {
        // 登录消息主体：用户名+密码（简化为字节流）
        msg_.setBody(data);
        // 计算消息总长度（头部6字节 + 主体长度 + 尾部2字节）
        uint32_t totalLength = 6 + data.size() + 2;
        msg_.setHeader(msg_.header_.version, msg_.header_.type, totalLength);
        return *this;
    }

    IMessageBuilder& buildTail() override {
        // 序列化头部和主体，计算校验码
        std::vector<uint8_t> temp = msg_.serialize();
        temp.resize(temp.size() - 2); // 去掉尾部占位
        uint16_t checksum = calculateChecksum(temp);
        msg_.setTail(checksum);
        return *this;
    }

    NetworkMessage getMessage() override {
        return std::move(msg_);
    }
};

// 具体建造者2：数据上报消息建造者
class DataReportMessageBuilder : public IMessageBuilder {
public:
    IMessageBuilder& buildHeader(uint8_t version, uint8_t type) override {
        // 数据上报消息类型固定为2
        msg_.setHeader(version, 2, 0);
        return *this;
    }

    IMessageBuilder& buildBody(const std::vector<uint8_t>& data) override {
        // 数据上报主体：传感器数据（字节流）
        msg_.setBody(data);
        uint32_t totalLength = 6 + data.size() + 2;
        msg_.setHeader(msg_.header_.version, msg_.header_.type, totalLength);
        return *this;
    }

    IMessageBuilder& buildTail() override {
        std::vector<uint8_t> temp = msg_.serialize();
        temp.resize(temp.size() - 2);
        uint16_t checksum = calculateChecksum(temp);
        msg_.setTail(checksum);
        return *this;
    }

    NetworkMessage getMessage() override {
        return std::move(msg_);
    }
};

// 指挥者
class MessageDirector {
public:
    NetworkMessage construct(IMessageBuilder& builder,
                             uint8_t version,
                             const std::vector<uint8_t>& bodyData) {
        return builder
            .buildHeader(version, 0) // 类型由建造者固定
            .buildBody(bodyData)
            .buildTail()
            .getMessage();
    }
};

// 测试代码
int main() {
    MessageDirector director;

    // 构建登录消息
    std::cout << "=== 登录消息 ===" << std::endl;
    LoginMessageBuilder loginBuilder;
    std::vector<uint8_t> loginBody = {'u', 's', 'e', 'r', '1', '0', '0', 'p', 'a', 's', 's', '1', '2', '3'}; // 用户名user100，密码pass123
    NetworkMessage loginMsg = director.construct(loginBuilder, 1, loginBody);
    loginMsg.print();

    // 构建数据上报消息
    std::cout << "\n=== 数据上报消息 ===" << std::endl;
    DataReportMessageBuilder dataBuilder;
    std::vector<uint8_t> dataBody = {0x01, 0x02, 0x03, 0x04}; // 传感器数据
    NetworkMessage dataMsg = director.construct(dataBuilder, 1, dataBody);
    dataMsg.print();

    return 0;
}

运行结果：

=== 登录消息 ===
消息版本：1
消息类型：1
消息长度：22
消息主体：75 73 65 72 31 30 30 70 61 73 73 31 32 33 
校验码： 6d2

=== 数据上报消息 ===
消息版本：1
消息类型：2
消息长度：12
消息主体：1 2 3 4 
校验码： 12

优势：新增 “心跳消息” 时，只需新增HeartbeatMessageBuilder，指挥者和消息类无需修改，实现不同类型消息的统一构造流程。

五、C++ 实战避坑指南：建造者模式的 5 个常见误区

建造者模式看似简单，但在实际应用中容易因理解偏差导致 “过度设计” 或 “使用不当”。下面列出 5 个典型误区及避坑方案。

误区 1：滥用建造者模式，简单对象也用

比如创建一个只有 3 个成员变量的User类（id、name、age），也非要写抽象建造者、具体建造者、指挥者，导致代码复杂度远高于直接用构造函数或setter方法。

避坑方案：

  • 建造者模式只适用于 “复杂对象”（成员变量多、构建步骤多、配置灵活）；
  • 简单对象（成员变量≤5 个，无复杂构建逻辑）直接用构造函数或setter方法，无需过度设计。

误区 2：指挥者职责不清，耦合具体建造者

比如指挥者直接依赖CommonOrderBuilder而非IOrderBuilder，导致指挥者无法复用在其他建造者上，失去了建造者模式的灵活性。

避坑方案：

  • 指挥者必须依赖抽象建造者（接口），不依赖具体建造者；
  • 指挥者的核心职责是 “控制流程顺序”，不关心具体部件的实现，避免耦合产品细节。

误区 3：建造者步骤过多，接口臃肿

比如抽象建造者定义了 10 + 个步骤方法，每个具体建造者都要实现所有方法，即使某些方法对该建造者无用（如企业订单建造者不需要 “VIP 标识” 步骤）。

避坑方案：

  • 遵循 “接口单一职责”，抽象建造者只定义核心通用步骤；
  • 特殊步骤在具体建造者中扩展（如CompanyOrderBuilder的setCompanyInfo方法），不添加到抽象接口中。

误区 4：忽略链式调用，导致代码繁琐

比如建造者的步骤方法不返回this，导致无法链式调用，只能写一堆重复代码：

// 不好的写法
builder.buildBasicInfo(...);
builder.buildPayInfo(...);
builder.addProducts(...);

// 好的写法
builder.buildBasicInfo(...).buildPayInfo(...).addProducts(...);

避坑方案：

  • 建造者的每个步骤方法都返回IOrderBuilder&（抽象建造者引用），支持链式调用；
  • 链式调用能大幅简化代码，提高可读性，是建造者模式的常用技巧。

误区 5：混淆建造者模式与流畅接口（Fluent Interface）

很多人认为 “链式调用就是建造者模式”，但实际上：

  • 流畅接口只是一种代码风格（链式调用），用于简化setter方法；
  • 建造者模式的核心是 “分离构造与表示，控制构建流程”，链式调用只是其实现手段之一。

避坑方案：

  • 不要为了链式调用而写建造者模式；
  • 如果只是想简化setter，直接在产品类中实现链式setter即可，无需建造者和指挥者：
// 流畅接口（非建造者模式）
class User {
public:
    User& setId(int id) { this->id = id; return *this; }
    User& setName(const std::string& name) { this->name = name; return *this; }
    User& setAge(int age) { this->age = age; return *this; }
private:
    int id;
    std::string name;
    int age;
};

// 使用
User user = User().setId(100).setName("张三").setAge(25);

六、总结：建造者模式的核心与实战建议

6.1 核心要点提炼

  1. 核心思想：分离复杂对象的 “构造流程” 和 “部件实现”，让同一流程能创建不同表示；
  2. 4 个角色：产品（复杂对象）、抽象建造者（定义步骤）、具体建造者（实现步骤）、指挥者（控制流程）；
  3. 核心价值：解决构造函数爆炸、复杂对象创建逻辑分散、扩展困难等问题；
  4. 适用场景：复杂对象、多配置对象、需要控制构建流程的场景；
  5. 与工厂模式区别：工厂模式关注 “快速创建产品”，建造者模式关注 “分步构建产品过程”。

6.2 C++ 实战建议

  1. 抽象建造者设计：

    • 只定义核心通用步骤，避免步骤过多导致接口臃肿；
    • 步骤方法返回抽象建造者引用，支持链式调用；
    • 提供getProduct()方法，返回最终产品（用移动语义避免拷贝）。

  2. 具体建造者实现：

    • 每个具体建造者对应一种产品配置（如普通订单、VIP 订单）；
    • 特殊步骤在具体建造者中扩展，不修改抽象接口；
    • 建造者中可添加业务约束（如 VIP 订单必须有优惠券）。

  3. 指挥者使用：

    • 指挥者依赖抽象建造者，不耦合具体实现；
    • 控制构建流程顺序，可添加流程校验（如步骤执行顺序、参数合法性）；
    • 简单场景可省略指挥者，直接通过建造者链式调用构建（如示例中的链式构建订单）。

  4. 产品设计：

    • 产品可提供setter方法或通过友元让建造者访问私有成员；
    • 禁用默认构造，确保只能通过建造者创建，避免对象未完全初始化；
    • 产品不依赖建造者和指挥者，保持独立性。

6.3 最后一句话

建造者模式的本质，是 “分步构建 + 流程控制”。它不会让你的代码行数减少，但会让复杂对象的创建逻辑变得 “清晰、灵活、可扩展”—— 当你面对一个参数繁多、配置灵活的复杂对象时，建造者模式能让你摆脱 “构造函数爆炸” 的噩梦，写出优雅易维护的代码。

记住：设计模式的价值不是 “炫技”，而是 “解决实际问题”。选择设计模式时，先判断对象是否足够复杂，再决定是否使用建造者模式，避免过度设计。

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值