设计模式(C++)详解——建造者模式（2）

<摘要>
建造者模式是一种超级实用的创建型设计模式，它就像一位专业的乐高大师，能把复杂对象的构建过程分解成一个个清晰的步骤，让同样的搭建流程可以创造出不同风格的作品！本文将带你深入探索建造者模式的奇妙世界，从它的诞生背景到核心概念，从设计哲学到实战应用，用生动有趣的C++代码示例、精美的Mermaid图表和接地气的比喻，让你彻底掌握这个让代码变得优雅而灵活的神奇模式。无论你是编程新手还是资深开发者，都能在这场设计模式的盛宴中找到乐趣和收获！

<解析>

🏗️ 设计模式(C++)详解——建造者模式：像搭乐高一样写代码！

1. 🎯 背景与核心概念：建造者模式的"前世今生"

1.1 为什么需要建造者模式？一个让人头疼的编程场景

想象一下，你要组装一台高性能游戏电脑，需要选择：CPU、显卡、内存、硬盘、主板、散热器…每个部件都有多种选择。如果用一个构造函数来搞定，会是这样的噩梦：

// 可怕的"万能构造函数" - 千万不要学！
Computer computer("Intel i9", "RTX 4090", "32GB DDR5", "2TB NVMe", 
                  "Z690", "1000W", "水冷", "黑色", "ATX", ...); // 参数越来越多！

这种代码有三大致命问题：

1. 参数爆炸：一长串参数，看得眼花缭乱
2. 容易出错：记不住参数顺序，一不小心就传错了
3. 灵活性差：有些参数可选有些必选，构造函数无法优雅处理

这就好比你去餐厅点餐，服务员要求你一口气报出所有菜品和具体要求，连薯条要几根盐放多少都得一次性说完！😅

1.2 建造者模式的诞生：优雅的解决方案

GoF（四人帮，设计模式界的"摇滚明星"）在1994年提出了建造者模式，它的核心理念是：

“别一口气吃成胖子，一步步来！”

建造者模式把复杂对象的建造过程分解成多个步骤，让你可以像搭乐高积木一样，一步一步组装出最终产品。

1.3 核心概念：建造者模式的"四大天王"

建造者模式中有四个关键角色，它们各司其职，配合默契：

让我们用Mermaid图来直观展示它们的关系：

这个图就像一场精彩的建筑表演：

• 指挥者（Director） 是导演，喊"开始建造！"
• 建造者（Builder） 是剧本，规定要拍哪些场景
• 具体建造者（Concrete Builder） 是演员，具体表演每个场景
• 产品（Product） 是最终上映的电影

2. 💡 设计意图与考量：建造者模式的"智慧结晶"

2.1 核心设计目标：分离与解耦

建造者模式的智慧可以用一句话概括：

“让构建过程与表示分离，让同样的构建过程可以创建不同的表示。”

这就像同样的烹饪流程（切菜→炒菜→调味），可以做出川菜、粤菜等不同风味的菜肴！

2.2 为什么这种分离如此重要？

2.2.1 应对变化的需求

在软件开发中，唯一不变的就是变化。建造者模式让我们能够：

• 构建过程变化：只需修改指挥者
• 产品表示变化：只需增加或修改具体建造者
• 两者都变化：互不干扰！

2.2.2 提高代码可读性和可维护性

比较一下两种写法：

// 传统方式 - 一头雾水
Computer computer("i9", "RTX4090", "32GB", "2TB", "Z690", "1000W", "水冷", ...);

// 建造者模式 - 清晰明了
Computer computer = ComputerBuilder()
                    .withCPU("i9")
                    .withGPU("RTX4090")
                    .withRAM("32GB")
                    .withStorage("2TB")
                    .withMotherboard("Z690")
                    .withPowerSupply("1000W")
                    .withCooling("水冷")
                    .build();

第二种写法就像在讲故事，每一步都清晰自然！

2.3 设计时的关键考量

2.3.1 接口设计的艺术

建造者接口的设计需要把握"粒度"的平衡：

// 粒度过细 - 像微观管理
class MicroManagerBuilder {
public:
    virtual void addScrew(int size) = 0;      // 添加螺丝
    virtual void addNut(int size) = 0;        // 添加螺母
    virtual void addBolt(int size) = 0;       // 添加螺栓
    // ...无数个方法
};

// 粒度适中 - 恰到好处
class GoodBuilder {
public:
    virtual void buildFrame() = 0;           // 构建框架
    virtual void installEngine() = 0;        // 安装发动机
    virtual void addWheels() = 0;            // 添加车轮
    // 合理数量的方法
};

2.3.2 指挥者的角色定位

指挥者可以是"严格"的也可以是"灵活"的：

// 严格指挥者 - 固定流程
class StrictDirector {
public:
    void construct() {
        builder->buildFoundation(); // 必须第一步
        builder->buildWalls();      // 必须第二步
        builder->buildRoof();       // 必须第三步
    }
};

// 灵活指挥者 - 可配置流程
class FlexibleDirector {
public:
    void construct(vector<string> steps) {
        for (auto step : steps) {
            if (step == "foundation") builder->buildFoundation();
            else if (step == "walls") builder->buildWalls();
            // ...其他步骤
        }
    }
};

3. 🛠️ 实例与应用场景：动手搭建你的"代码乐高"

3.1 案例一：超级电脑组装工厂

3.1.1 场景描述：打造梦幻电脑

我们要创建一个电脑组装系统，能够组装两种风格的电脑：

1. 游戏战神：顶配CPU、旗舰显卡、超大内存
2. 办公能手：均衡配置、集成显卡、性价比高

3.1.2 完整代码实现

首先，定义我们的"产品"——电脑：

// computer.h - 我们的梦幻电脑
#ifndef COMPUTER_H
#define COMPUTER_H

#include <string>
#include <iostream>
using namespace std;

class Computer {
public:
    // 设置各个组件的方法
    void setCPU(const string& cpu) { m_cpu = cpu; }
    void setGPU(const string& gpu) { m_gpu = gpu; }
    void setRAM(const string& ram) { m_ram = ram; }
    void setStorage(const string& storage) { m_storage = storage; }
    
    // 展示电脑配置
    void show() const {
        cout << "✨ 电脑配置单 ✨" << endl;
        cout << "========================" << endl;
        cout << "  CPU: " << m_cpu << endl;
        cout << "  显卡: " << m_gpu << endl;
        cout << "  内存: " << m_ram << endl;
        cout << "  存储: " << m_storage << endl;
        cout << "========================" << endl;
        cout << endl;
    }

private:
    string m_cpu;
    string m_gpu;
    string m_ram;
    string m_storage;
};

#endif // COMPUTER_H

接下来，定义建造者接口：

// computer_builder.h - 组装说明书
#ifndef COMPUTER_BUILDER_H
#define COMPUTER_BUILDER_H

#include "computer.h"

// 抽象建造者接口 - 就像组装说明书的大纲
class ComputerBuilder {
public:
    virtual ~ComputerBuilder() {} // 虚析构函数，确保正确清理资源
    
    // 组装步骤
    virtual void buildCPU() = 0;    // 安装CPU
    virtual void buildGPU() = 0;    // 安装显卡
    virtual void buildRAM() = 0;    // 安装内存
    virtual void buildStorage() = 0;// 安装存储
    
    virtual Computer getResult() = 0; // 获取最终产品
};

#endif // COMPUTER_BUILDER_H

现在，实现两种具体建造者：

// concrete_builders.h - 两位技术大师
#ifndef CONCRETE_BUILDERS_H
#define CONCRETE_BUILDERS_H

#include "computer_builder.h"

// 游戏电脑建造者 - 追求极致性能
class GamingComputerBuilder : public ComputerBuilder {
public:
    GamingComputerBuilder() { 
        cout << "🎮 游戏电脑大师开始工作..." << endl;
        m_computer = Computer(); 
    }
    
    void buildCPU() override { 
        m_computer.setCPU("Intel i9-13900K - 超频版");
        cout << "  安装顶级CPU: Intel i9-13900K" << endl;
    }
    
    void buildGPU() override { 
        m_computer.setGPU("NVIDIA RTX 4090 - 24GB显存");
        cout << "  安装旗舰显卡: RTX 4090" << endl;
    }
    
    void buildRAM() override { 
        m_computer.setRAM("64GB DDR5 - 高频内存");
        cout << "  安装超大内存: 64GB DDR5" << endl;
    }
    
    void buildStorage() override { 
        m_computer.setStorage("2TB NVMe SSD + 4TB HDD");
        cout << "  安装混合存储: 2TB SSD + 4TB HDD" << endl;
    }
    
    Computer getResult() override { 
        cout << "✅ 游戏电脑组装完成！" << endl;
        return m_computer; 
    }

private:
    Computer m_computer;
};

// 办公电脑建造者 - 追求稳定经济
class OfficeComputerBuilder : public ComputerBuilder {
public:
    OfficeComputerBuilder() { 
        cout << "💼 办公电脑专家开始工作..." << endl;
        m_computer = Computer(); 
    }
    
    void buildCPU() override { 
        m_computer.setCPU("Intel i5-12400 - 节能版");
        cout << "  安装高效CPU: Intel i5-12400" << endl;
    }
    
    void buildGPU() override { 
        m_computer.setGPU("集成显卡 - 节能高效");
        cout << "  使用集成显卡" << endl;
    }
    
    void buildRAM() override { 
        m_computer.setRAM("16GB DDR4 - 标准频率");
        cout << "  安装足够内存: 16GB DDR4" << endl;
    }
    
    void buildStorage() override { 
        m_computer.setStorage("512GB SSD");
        cout << "  安装快速存储: 512GB SSD" << endl;
    }
    
    Computer getResult() override { 
        cout << "✅ 办公电脑组装完成！" << endl;
        return m_computer; 
    }

private:
    Computer m_computer;
};

#endif // CONCRETE_BUILDERS_H

现在，请出我们的"项目经理"——指挥者：

// director.h - 聪明的项目经理
#ifndef DIRECTOR_H
#define DIRECTOR_H

#include "computer_builder.h"

// 指挥者 - 控制组装流程的项目经理
class ComputerDirector {
public:
    // 设置使用哪位建造者
    void setBuilder(ComputerBuilder* builder) {
        m_builder = builder;
        cout << "👨‍💼 项目经理已就位，准备指导建造..." << endl;
    }
    
    // 构建电脑的固定流程
    void construct() {
        cout << "🛠️ 开始按照标准流程组装电脑..." << endl;
        m_builder->buildCPU();     // 第一步：安装CPU
        m_builder->buildRAM();     // 第二步：安装内存
        m_builder->buildStorage(); // 第三步：安装存储
        m_builder->buildGPU();     // 第四步：安装显卡
        cout << "📋 标准组装流程完成" << endl;
    }

private:
    ComputerBuilder* m_builder; // 指向当前建造者的指针
};

#endif // DIRECTOR_H

最后，来看看我们的主程序：

// main.cpp - 电脑组装演示
#include <iostream>
#include "director.h"
#include "concrete_builders.h"

int main() {
    cout << "🏭 欢迎来到电脑组装工厂！" << endl;
    cout << "==========================================" << endl;
    
    // 创建我们的项目经理
    ComputerDirector director;
    
    // 创建两位技术大师
    GamingComputerBuilder gamingBuilder;
    OfficeComputerBuilder officeBuilder;
    
    // 组装游戏电脑
    cout << endl << "1. 开始组装游戏电脑：" << endl;
    cout << "------------------------------------------" << endl;
    director.setBuilder(&gamingBuilder);
    director.construct();
    Computer gamingPC = gamingBuilder.getResult();
    gamingPC.show();
    
    // 组装办公电脑
    cout << "2. 开始组装办公电脑：" << endl;
    cout << "------------------------------------------" << endl;
    director.setBuilder(&officeBuilder);
    director.construct();
    Computer officePC = officeBuilder.getResult();
    officePC.show();
    
    cout << "==========================================" << endl;
    cout << "🎉 所有电脑组装完成！感谢使用我们的服务！" << endl;
    
    return 0;
}

3.1.3 Makefile 编译配置

# Makefile for Computer Builder Example
CXX = g++
CXXFLAGS = -std=c++11 -Wall -Wextra

TARGET = computer_factory
SOURCES = main.cpp
HEADERS = computer.h computer_builder.h concrete_builders.h director.h

$(TARGET): $(SOURCES) $(HEADERS)
	$(CXX) $(CXXFLAGS) -o $(TARGET) $(SOURCES)

clean:
	rm -f $(TARGET)

.PHONY: clean

3.1.4 编译与运行

# 编译程序
make

# 运行程序
./computer_factory

3.1.5 运行结果与解说

运行程序后，你会看到如下输出：

🏭 欢迎来到电脑组装工厂！
==========================================

1. 开始组装游戏电脑：
------------------------------------------
🎮 游戏电脑大师开始工作...
👨‍💼 项目经理已就位，准备指导建造...
🛠️ 开始按照标准流程组装电脑...
  安装顶级CPU: Intel i9-13900K
  安装超大内存: 64GB DDR5
  安装混合存储: 2TB SSD + 4TB HDD
  安装旗舰显卡: RTX 4090
📋 标准组装流程完成
✅ 游戏电脑组装完成！
✨ 电脑配置单 ✨
========================
  CPU: Intel i9-13900K - 超频版
  显卡: NVIDIA RTX 4090 - 24GB显存
  内存: 64GB DDR5 - 高频内存
  存储: 2TB NVMe SSD + 4TB HDD
========================

2. 开始组装办公电脑：
------------------------------------------
💼 办公电脑专家开始工作...
👨‍💼 项目经理已就位，准备指导建造...
🛠️ 开始按照标准流程组装电脑...
  安装高效CPU: Intel i5-12400
  安装足够内存: 16GB DDR4
  安装快速存储: 512GB SSD
  使用集成显卡
📋 标准组装流程完成
✅ 办公电脑组装完成！
✨ 电脑配置单 ✨
========================
  CPU: Intel i5-12400 - 节能版
  显卡: 集成显卡 - 节能高效
  内存: 16GB DDR4 - 标准频率
  存储: 512GB SSD
========================

==========================================
🎉 所有电脑组装完成！感谢使用我们的服务！

代码解说：

这个例子完美展示了建造者模式的精髓：

1. 同样的构建过程，不同的表示：指挥者(ComputerDirector)使用相同的construct()方法，但通过不同的建造者产生了完全不同的电脑配置。

2. 分离关注点：

   • 指挥者关心"如何构建"（流程顺序）
   • 建造者关心"构建什么"（具体配置）
   • 产品只是最终结果

3. 易于扩展：如果想增加一种新的电脑类型（如服务器电脑），只需要创建一个新的具体建造者，完全不用修改现有代码。

让我们用Mermaid序列图来可视化这个构建过程：

这个流程图清晰展示了建造者模式的工作方式：客户端通过指挥者指导建造者一步步构建产品，最后从建造者获取最终产品。

3.2 案例二：美味汉堡制作工坊

3.2.1 场景描述：定制你的梦幻汉堡

我们要创建一个汉堡制作系统，允许客户定制不同风格的汉堡：

1. 经典牛肉汉堡：牛肉饼、生菜、番茄、芝士
2. 素食健康汉堡：素食饼、新鲜蔬菜、特制酱料

3.2.2 完整代码实现

首先，定义汉堡产品：

// burger.h
#ifndef BURGER_H
#define BURGER_H

#include <string>
#include <vector>
#include <iostream>
using namespace std;

class Burger {
public:
    void setPatty(const string& patty) { m_patty = patty; }
    void addTopping(const string& topping) { m_toppings.push_back(topping); }
    void setSauce(const string& sauce) { m_sauce = sauce; }
    void setBun(const string& bun) { m_bun = bun; }
    
    void serve() const {
        cout << "🍔 您的汉堡已准备好！" << endl;
        cout << "=========================" << endl;
        cout << "  面饼: " << m_bun << endl;
        cout << "  肉饼: " << m_patty << endl;
        cout << "  酱料: " << m_sauce << endl;
        cout << "  配料: ";
        for (size_t i = 0; i < m_toppings.size(); ++i) {
            if (i > 0) cout << ", ";
            cout << m_toppings[i];
        }
        cout << endl;
        cout << "=========================" << endl;
        cout << "😋 请慢慢享用！" << endl << endl;
    }

private:
    string m_bun;
    string m_patty;
    vector<string> m_toppings;
    string m_sauce;
};

#endif // BURGER_H

定义建造者接口：

// burger_builder.h
#ifndef BURGER_BUILDER_H
#define BURGER_BUILDER_H

#include "burger.h"

class BurgerBuilder {
public:
    virtual ~BurgerBuilder() {}
    virtual void prepareBun() = 0;
    virtual void cookPatty() = 0;
    virtual void addToppings() = 0;
    virtual void addSauce() = 0;
    virtual Burger getBurger() = 0;
};

#endif // BURGER_BUILDER_H

实现具体建造者：

// concrete_burger_builders.h
#ifndef CONCRETE_BURGER_BUILDERS_H
#define CONCRETE_BURGER_BUILDERS_H

#include "burger_builder.h"

// 经典牛肉汉堡建造者
class BeefBurgerBuilder : public BurgerBuilder {
public:
    BeefBurgerBuilder() { 
        cout << "👨‍🍳 开始制作经典牛肉汉堡..." << endl;
        m_burger = Burger(); 
    }
    
    void prepareBun() override {
        m_burger.setBun("烤芝麻面包");
        cout << "  准备烤芝麻面包" << endl;
    }
    
    void cookPatty() override {
        m_burger.setPatty("100%纯牛肉饼");
        cout << "  煎制多汁牛肉饼" << endl;
    }
    
    void addToppings() override {
        m_burger.addTopping("新鲜生菜");
        m_burger.addTopping("多汁番茄");
        m_burger.addTopping("切达芝士");
        cout << "  添加生菜、番茄和芝士" << endl;
    }
    
    void addSauce() override {
        m_burger.setSauce("特制汉堡酱");
        cout << "  淋上特制酱料" << endl;
    }
    
    Burger getBurger() override {
        cout << "✅ 经典牛肉汉堡制作完成！" << endl;
        return m_burger;
    }

private:
    Burger m_burger;
};

// 素食汉堡建造者
class VeggieBurgerBuilder : public BurgerBuilder {
public:
    VeggieBurgerBuilder() { 
        cout << "👨‍🍳 开始制作健康素食汉堡..." << endl;
        m_burger = Burger(); 
    }
    
    void prepareBun() override {
        m_burger.setBun("全麦面包");
        cout << "  准备全麦面包" << endl;
    }
    
    void cookPatty() override {
        m_burger.setPatty("黑豆素食饼");
        cout << "  烘烤黑豆素食饼" << endl;
    }
    
    void addToppings() override {
        m_burger.addTopping("新鲜菠菜");
        m_burger.addTopping("牛油果");
        m_burger.addTopping("洋葱圈");
        cout << "  添加菠菜、牛油果和洋葱" << endl;
    }
    
    void addSauce() override {
        m_burger.setSauce("酸奶黄瓜酱");
        cout << "  淋上酸奶黄瓜酱" << endl;
    }
    
    Burger getBurger() override {
        cout << "✅ 健康素食汉堡制作完成！" << endl;
        return m_burger;
    }

private:
    Burger m_burger;
};

#endif // CONCRETE_BURGER_BUILDERS_H

实现指挥者：

// burger_director.h
#ifndef BURGER_DIRECTOR_H
#define BURGER_DIRECTOR_H

#include "burger_builder.h"

class BurgerDirector {
public:
    void setBuilder(BurgerBuilder* builder) {
        m_builder = builder;
    }
    
    void makeBurger() {
        cout << "📋 按照标准流程制作汉堡..." << endl;
        m_builder->prepareBun();
        m_builder->cookPatty();
        m_builder->addToppings();
        m_builder->addSauce();
        cout << "🎯 汉堡制作流程完成" << endl;
    }

private:
    BurgerBuilder* m_builder;
};

#endif // BURGER_DIRECTOR_H

主程序：

// main_burger.cpp
#include <iostream>
#include "burger_director.h"
#include "concrete_burger_builders.h"

int main() {
    cout << "🍟 欢迎来到美味汉堡工坊！" << endl;
    cout << "==========================================" << endl;
    
    BurgerDirector director;
    BeefBurgerBuilder beefBuilder;
    VeggieBurgerBuilder veggieBuilder;
    
    // 制作牛肉汉堡
    cout << endl << "1. 制作经典牛肉汉堡：" << endl;
    cout << "------------------------------------------" << endl;
    director.setBuilder(&beefBuilder);
    director.makeBurger();
    Burger beefBurger = beefBuilder.getBurger();
    beefBurger.serve();
    
    // 制作素食汉堡
    cout << "2. 制作健康素食汉堡：" << endl;
    cout << "------------------------------------------" << endl;
    director.setBuilder(&veggieBuilder);
    director.makeBurger();
    Burger veggieBurger = veggieBuilder.getBurger();
    veggieBurger.serve();
    
    cout << "==========================================" << endl;
    cout << "🙏 感谢光临美味汉堡工坊！" << endl;
    
    return 0;
}

3.2.3 运行结果与解说

运行程序后，你会看到如下输出：

🍟 欢迎来到美味汉堡工坊！
==========================================

1. 制作经典牛肉汉堡：
------------------------------------------
👨‍🍳 开始制作经典牛肉汉堡...
📋 按照标准流程制作汉堡...
  准备烤芝麻面包
  煎制多汁牛肉饼
  添加生菜、番茄和芝士
  淋上特制酱料
🎯 汉堡制作流程完成
✅ 经典牛肉汉堡制作完成！
🍔 您的汉堡已准备好！
=========================
  面饼: 烤芝麻面包
  肉饼: 100%纯牛肉饼
  酱料: 特制汉堡酱
  配料: 新鲜生菜, 多汁番茄, 切达芝士
=========================
😋 请慢慢享用！

2. 制作健康素食汉堡：
------------------------------------------
👨‍🍳 开始制作健康素食汉堡...
📋 按照标准流程制作汉堡...
  准备全麦面包
  烘烤黑豆素食饼
  添加菠菜、牛油果和洋葱
  淋上酸奶黄瓜酱
🎯 汉堡制作流程完成
✅ 健康素食汉堡制作完成！
🍔 您的汉堡已准备好！
=========================
  面饼: 全麦面包
  肉饼: 黑豆素食饼
  酱料: 酸奶黄瓜酱
  配料: 新鲜菠菜, 牛油果, 洋葱圈
=========================
😋 请慢慢享用！

==========================================
🙏 感谢光临美味汉堡工坊！

代码解说：

这个汉堡工坊例子展示了建造者模式的另一个美妙之处：

1. 固定流程，可变内容：无论是牛肉汉堡还是素食汉堡，都遵循相同的制作流程（准备面包→烹饪肉饼→添加配料→添加酱料），但每个步骤的具体实现不同。

2. 易于定制：如果顾客想要特殊定制（比如多加一份芝士），只需要在具体建造者中调整即可。

3. 流程一致性：指挥者确保每个汉堡都按照标准流程制作，保证产品质量一致。

让我们用Mermaid流程图来展示汉堡制作过程：

这个流程图清晰展示了"同样的流程，不同的实现"的概念，这正是建造者模式的核心思想。

4. 🚀 高级技巧与最佳实践

4.1 流畅接口（Fluent Interface）模式

现代C++中，建造者模式经常与流畅接口结合，让代码更加优雅：

// fluent_burger_builder.h
#ifndef FLUENT_BURGER_BUILDER_H
#define FLUENT_BURGER_BUILDER_H

#include "burger.h"

class FluentBurgerBuilder {
public:
    FluentBurgerBuilder() { m_burger = Burger(); }
    
    // 返回自身引用，支持链式调用
    FluentBurgerBuilder& withBun(const string& bun) {
        m_burger.setBun(bun);
        return *this;
    }
    
    FluentBurgerBuilder& withPatty(const string& patty) {
        m_burger.setPatty(patty);
        return *this;
    }
    
    FluentBurgerBuilder& withTopping(const string& topping) {
        m_burger.addTopping(topping);
        return *this;
    }
    
    FluentBurgerBuilder& withSauce(const string& sauce) {
        m_burger.setSauce(sauce);
        return *this;
    }
    
    Burger build() {
        return m_burger;
    }

private:
    Burger m_burger;
};

#endif // FLUENT_BURGER_BUILDER_H

使用方式：

// 使用流畅接口建造者
Burger customBurger = FluentBurgerBuilder()
                     .withBun("全麦面包")
                     .withPatty("鸡肉饼")
                     .withTopping("生菜")
                     .withTopping("番茄")
                     .withSauce("蜂蜜芥末酱")
                     .build();

customBurger.serve();

这种写法更加直观和灵活，特别适合需要大量可选参数的场景。

4.2 带验证的建造者

我们可以为建造者添加验证逻辑，确保构建的产品是有效的：

// validated_burger_builder.h
#ifndef VALIDATED_BURGER_BUILDER_H
#define VALIDATED_BURGER_BUILDER_H

#include "burger.h"
#include <stdexcept>

class ValidatedBurgerBuilder {
public:
    ValidatedBurgerBuilder() { m_burger = Burger(); }
    
    ValidatedBurgerBuilder& withBun(const string& bun) {
        if (bun.empty()) throw invalid_argument("面包类型不能为空");
        m_burger.setBun(bun);
        return *this;
    }
    
    ValidatedBurgerBuilder& withPatty(const string& patty) {
        if (patty.empty()) throw invalid_argument("肉饼类型不能为空");
        m_burger.setPatty(patty);
        return *this;
    }
    
    Burger build() {
        // 构建前的最终验证
        if (/* 验证条件 */) {
            throw runtime_error("汉堡配置无效");
        }
        return m_burger;
    }

private:
    Burger m_burger;
};

#endif // VALIDATED_BURGER_BUILDER_H

5. 📊 建造者模式与其他模式的比较

5.1 建造者模式 vs. 工厂模式

5.2 何时选择建造者模式

选择建造者模式当：

• ✅ 对象需要多个步骤构建
• ✅ 同样的构建过程需要产生不同表示
• ✅ 需要精细控制对象的构建过程
• ✅ 想要避免构造函数参数过多

不选择建造者模式当：

• ❌ 对象很简单，不需要多个构建步骤
• ❌ 构建过程没有变化，总是创建相同对象
• ❌ 产品接口不稳定，经常变化

6. 💎 总结与展望

6.1 建造者模式的核心价值

建造者模式就像一位智慧的 architect（建筑师），它教会我们：

1. 分解复杂问题：将复杂对象的构建分解为多个 manageable（可管理的）步骤
2. 分离关注点：让构建过程与表示分离，提高代码的灵活性和可维护性
3. 提供统一接口：为不同的构建实现提供一致的接口，便于扩展和替换

6.2 实际应用建议

在实际项目中使用建造者模式时：

1. 识别复杂对象：只有当对象真正复杂，需要多个步骤构建时，才使用建造者模式
2. 设计合适接口：建造者接口的粒度要适中，既不能太细也不能太粗
3. 考虑流畅接口：对于需要大量可选参数的场景，考虑使用流畅接口风格
4. 添加验证逻辑：在建造者中添加验证，确保构建的产品是有效的

6.3 未来发展趋势

随着现代C++的发展，建造者模式也在进化：

1. 与现代C++特性结合：使用constexpr、模板元编程等现代特性增强建造者模式
2. 编译时验证：利用静态断言和概念检查，在编译时验证建造参数的有效性
3. 并发安全建造者：设计线程安全的建造者，支持多线程环境下的对象构建

建造者模式是一个强大而灵活的工具，正确使用它可以让你的代码更加优雅、可维护和可扩展。就像搭乐高积木一样，享受构建的乐趣吧！🎉

记住：好的代码不是一下子写出来的，而是一步步构建出来的——这正是建造者模式教给我们的智慧！