建造者模式详解及其在自动驾驶场景的应用举例(以C++代码实现)

模式定义

建造者模式（Builder Pattern）是一种创建型设计模式，用于分步构造复杂对象。该模式将对象构建过程与其表示分离，支持通过相同构建过程生成不同表现形式，特别适合需要灵活配置的自动驾驶车辆系统搭建场景。

---

自动驾驶应用场景

典型的建造者模式应用场景包括：

1. 车辆配置管理：灵活组合传感器套件、计算单元和算法参数
2. 场景配置生成：构建不同测试场景（城市道路/高速公路/极端天气）
3. 系统参数包：创建包含多个子系统配置的参数集合

本文以自动驾驶车辆配置管理为例进行实现。

---

C++代码实现（含详细注释）

#include <iostream>
#include <memory>
#include <vector>
#include <unordered_map>

// ---------------------------- 产品类 ----------------------------
class VehicleConfig {
public:
    // 配置参数类型
    using ParameterMap = std::unordered_map<std::string, float>;
    
    void addSensor(const std::string& sensor) {
        sensors_.push_back(sensor);
    }

    void setComputeUnit(const std::string& unit) {
        compute_unit_ = unit;
    }

    void setAlgorithmParam(const std::string& key, float value) {
        algorithm_params_[key] = value;
    }

    void display() const {
        std::cout << "\n=== 车辆配置详情 ===" << std::endl;
        std::cout << "传感器系统：" << std::endl;
        for (const auto& sensor : sensors_) {
            std::cout << "  - " << sensor << std::endl;
        }

        std::cout << "\n计算单元：" << compute_unit_ << std::endl;
        
        std::cout << "\n算法参数：" << std::endl;
        for (const auto& [k, v] : algorithm_params_) {
            std::cout << "  " << k << " = " << v << std::endl;
        }
    }

private:
    std::vector<std::string> sensors_;    // 传感器列表
    std::string compute_unit_;            // 计算单元型号
    ParameterMap algorithm_params_;       // 算法参数集合
};

// ---------------------------- 抽象建造者 ----------------------------
class ConfigBuilder {
public:
    virtual ~ConfigBuilder() = default;
    
    virtual void reset() = 0;
    virtual void buildSensors() = 0;
    virtual void buildComputeUnit() = 0;
    virtual void buildAlgorithmParams() = 0;
    
    std::unique_ptr<VehicleConfig> getResult() {
        return std::move(config_);
    }

protected:
    std::unique_ptr<VehicleConfig> config_;  // 产品对象
};

// ---------------------------- 具体建造者 ----------------------------
// 豪华型配置建造者
class LuxuryBuilder : public ConfigBuilder {
public:
    void reset() override {
        config_ = std::make_unique<VehicleConfig>();
    }

    void buildSensors() override {
        config_->addSensor("128线激光雷达");
        config_->addSensor("800万像素双目相机");
        config_->addSensor("4D毫米波雷达");
        config_->addSensor("超声波雷达阵列（12个）");
    }

    void buildComputeUnit() override {
        config_->setComputeUnit("NVIDIA Orin X 2×");
    }

    void buildAlgorithmParams() override {
        config_->setAlgorithmParam("感知频率", 30.0f);
        config_->setAlgorithmParam("定位精度", 0.01f);
        config_->setAlgorithmParam("最大预测距离", 150.0f);
    }
};

// 经济型配置建造者
class EconomyBuilder : public ConfigBuilder {
public:
    void reset() override {
        config_ = std::make_unique<VehicleConfig>();
    }

    void buildSensors() override {
        config_->addSensor("64线激光雷达");
        config_->addSensor("200万像素单目相机");
        config_->addSensor("常规毫米波雷达");
        config_->addSensor("超声波雷达（8个）");
    }

    void buildComputeUnit() override {
        config_->setComputeUnit("华为MDC 610");
    }

    void buildAlgorithmParams() override {
        config_->setAlgorithmParam("感知频率", 15.0f);
        config_->setAlgorithmParam("定位精度", 0.1f);
        config_->setAlgorithmParam("最大预测距离", 100.0f);
    }
};

// ---------------------------- 指导者类 ----------------------------
class ConfigDirector {
public:
    void setBuilder(ConfigBuilder* builder) {
        builder_ = builder;
    }

    void constructStandardConfig() {
        builder_->reset();
        builder_->buildSensors();
        builder_->buildComputeUnit();
        builder_->buildAlgorithmParams();
    }

    void constructCustomConfig(bool high_end_sensor) {
        builder_->reset();
        if(high_end_sensor) {
            builder_->buildSensors();
        } else {
            // 自定义传感器配置...
        }
        builder_->buildComputeUnit();
        builder_->buildAlgorithmParams();
    }

private:
    ConfigBuilder* builder_ = nullptr;
};

// ---------------------------- 客户端使用 ----------------------------
int main() {
    ConfigDirector director;
    
    // 构建豪华型配置
    LuxuryBuilder luxury_builder;
    director.setBuilder(&luxury_builder);
    director.constructStandardConfig();
    auto luxury_config = luxury_builder.getResult();
    luxury_config->display();

    // 构建经济型配置
    EconomyBuilder economy_builder;
    director.setBuilder(&economy_builder);
    director.constructStandardConfig();
    auto economy_config = economy_builder.getResult();
    economy_config->display();

    // 构建自定义配置
    director.setBuilder(&luxury_builder);
    director.constructCustomConfig(true);
    auto custom_config = luxury_builder.getResult();
    custom_config->display();

    return 0;
}

---

代码解析

1. 产品类设计

class VehicleConfig { /*...*/ };

• 配置存储：使用容器存储传感器列表和算法参数
• 显示方法：提供配置可视化接口

2. 建造者体系

class ConfigBuilder { /*...*/ };  // 抽象接口
class LuxuryBuilder : public ConfigBuilder { /*...*/ }; // 具体实现

• 分步构建：明确划分传感器、计算单元、算法参数配置步骤
• 灵活扩展：新增配置类型只需添加新建造者

3. 指导者类

class ConfigDirector { /*...*/ };

• 构建流程控制：封装标准配置流程
• 支持自定义：提供特殊配置流程接口

---

运行结果

=== 车辆配置详情 ===
传感器系统：
  - 128线激光雷达
  - 800万像素双目相机
  - 4D毫米波雷达
  - 超声波雷达阵列（12个）

计算单元：NVIDIA Orin X 2×

算法参数：
  感知频率 = 30
  定位精度 = 0.01
  最大预测距离 = 150

=== 车辆配置详情 ===
传感器系统：
  - 64线激光雷达
  - 200万像素单目相机
  - 常规毫米波雷达
  - 超声波雷达（8个）

计算单元：华为MDC 610

算法参数：
  感知频率 = 15
  定位精度 = 0.1
  最大预测距离 = 100

=== 车辆配置详情 ===
...（自定义配置输出）

---

模式优势分析

在自动驾驶中的价值

1. 配置灵活性

   • 支持快速切换不同配置方案（豪华型/经济型/测试型）
   • 允许部分配置覆盖（如仅升级传感器套件）

2. 构建过程可控

   • 确保必要配置项完整（如必须包含定位传感器）
   • 支持配置参数校验

3. 代码可维护性

   • 隔离复杂配置逻辑与业务代码
   • 新增配置类型不影响现有系统

---

扩展改进建议

1. 配置校验机制

void validateConfig() {
    if (sensors_.empty()) {
        throw std::runtime_error("必须配置至少一个传感器");
    }
    // 其他校验规则...
}

2. 配置持久化

void saveToFile(const std::string& path) {
    // 将配置保存为JSON/YAML文件
}

3. 动态配置加载

class DynamicBuilder : public ConfigBuilder {
    void buildSensors() override {
        // 从配置文件加载传感器配置
    }
};

---

建造者模式总结

核心价值：

• 分步构建复杂配置对象
• 隔离构建过程与最终表示
• 支持多种配置变体生成

适用场景：

• 自动驾驶车辆多版本配置管理
• 测试场景参数组合生成
• 动态系统参数包构建

本实现展示了建造者模式在自动驾驶配置管理中的典型应用，通过将复杂配置对象的构建过程模块化，为创建灵活可扩展的自动驾驶系统提供了可靠的架构支持。该模式是构建复杂参数化系统的关键设计手段，特别适合需要支持多配置方案的自动驾驶开发场景。