抽象工厂模式及其在自动驾驶中的应用举例(c++代码实现)

zhaoyqcsdn2025-04-24 23:05

模式定义

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，用于封装一组具有共同主题的独立对象创建过程。该模式通过提供统一接口创建相关对象家族，而无需指定具体实现类，特别适合需要保证系统组件兼容性的自动驾驶硬件平台适配场景。

自动驾驶应用场景

在自动驾驶硬件集成中常见的应用场景：

  1. 多传感器套件适配：兼容不同厂商的LiDAR+Camera+Radar组合
  2. 硬件平台移植：适配不同计算平台（NVIDIA vs 华为MDC）
  3. 仿真系统切换：切换真实硬件与仿真传感器组件

本文以自动驾驶计算平台适配为例进行实现。

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

cpp 复制代码 
#include <iostream>
#include <memory>

// ---------------------------- 抽象产品体系 ----------------------------
// 计算单元接口
class IComputeUnit {
public:
    virtual ~IComputeUnit() = default;
    virtual void processSensorData() = 0;
    virtual float getProcessingPower() const = 0;
};

// 内存管理接口
class IMemoryManager {
public:
    virtual ~IMemoryManager() = default;
    virtual void allocate(size_t size) = 0;
    virtual void release() = 0;
};

// 硬件加速接口
class IHardwareAccelerator {
public:
    virtual ~IHardwareAccelerator() = default;
    virtual void accelerateAI() = 0;
};

// ---------------------------- 具体产品实现（NVIDIA平台）---------------
class NvidiaGPU : public IComputeUnit {
public:
    void processSensorData() override {
        std::cout << "[NVIDIA] CUDA加速处理传感器数据" << std::endl;
    }

    float getProcessingPower() const override {
        return 32.8f;  // TFLOPS
    }
};

class NvidiaMemory : public IMemoryManager {
public:
    void allocate(size_t size) override {
        std::cout << "[NVIDIA] 使用CUDA统一内存分配" << size << "MB" << std::endl;
    }

    void release() override {
        std::cout << "[NVIDIA] 释放CUDA内存" << std::endl;
    }
};

class TensorRTAccelerator : public IHardwareAccelerator {
public:
    void accelerateAI() override {
        std::cout << "[TensorRT] 启动深度学习推理加速" << std::endl;
    }
};

// ---------------------------- 具体产品实现（华为MDC平台）---------------
class HuaweiNPU : public IComputeUnit {
public:
    void processSensorData() override {
        std::cout << "[华为MDC] 昇腾芯片处理传感器数据" << std::endl;
    }

    float getProcessingPower() const override {
        return 28.5f;  // TFLOPS
    }
};

class HuaweiMemory : public IMemoryManager {
public:
    void allocate(size_t size) override {
        std::cout << "[华为MDC] 分配DDR内存" << size << "MB" << std::endl;
    }

    void release() override {
        std::cout << "[华为MDC] 释放DDR内存" << std::endl;
    }
};

class MindSporeAccelerator : public IHardwareAccelerator {
public:
    void accelerateAI() override {
        std::cout << "[MindSpore] 启动AI模型推理" << std::endl;
    }
};

// ---------------------------- 抽象工厂接口 ----------------------------
class IHardwareFactory {
public:
    virtual ~IHardwareFactory() = default;
    
    virtual std::unique_ptr<IComputeUnit> createComputeUnit() = 0;
    virtual std::unique_ptr<IMemoryManager> createMemoryManager() = 0;
    virtual std::unique_ptr<IHardwareAccelerator> createAccelerator() = 0;
};

// ---------------------------- 具体工厂实现 ----------------------------
class NvidiaFactory : public IHardwareFactory {
public:
    std::unique_ptr<IComputeUnit> createComputeUnit() override {
        return std::make_unique<NvidiaGPU>();
    }

    std::unique_ptr<IMemoryManager> createMemoryManager() override {
        return std::make_unique<NvidiaMemory>();
    }

    std::unique_ptr<IHardwareAccelerator> createAccelerator() override {
        return std::make_unique<TensorRTAccelerator>();
    }
};

class HuaweiFactory : public IHardwareFactory {
public:
    std::unique_ptr<IComputeUnit> createComputeUnit() override {
        return std::make_unique<HuaweiNPU>();
    }

    std::unique_ptr<IMemoryManager> createMemoryManager() override {
        return std::make_unique<HuaweiMemory>();
    }

    std::unique_ptr<IHardwareAccelerator> createAccelerator() override {
        return std::make_unique<MindSporeAccelerator>();
    }
};

// ---------------------------- 系统集成 ----------------------------
class AutonomousSystem {
    std::unique_ptr<IHardwareFactory> factory_;
    
    std::unique_ptr<IComputeUnit> compute_;
    std::unique_ptr<IMemoryManager> memory_;
    std::unique_ptr<IHardwareAccelerator> accelerator_;

public:
    explicit AutonomousSystem(std::unique_ptr<IHardwareFactory> factory)
        : factory_(std::move(factory)) {
        initialize();
    }

    void initialize() {
        compute_ = factory_->createComputeUnit();
        memory_ = factory_->createMemoryManager();
        accelerator_ = factory_->createAccelerator();
    }

    void run() {
        std::cout << "\n=== 启动自动驾驶系统 ===" << std::endl;
        memory_->allocate(4096);  // 分配4GB内存
        compute_->processSensorData();
        accelerator_->accelerateAI();
        std::cout << "计算性能: " << compute_->getProcessingPower() << " TFLOPS\n";
    }

    ~AutonomousSystem() {
        memory_->release();
    }
};

// ---------------------------- 场景演示 ----------------------------
int main() {
    // 创建NVIDIA平台系统
    AutonomousSystem nvidiaSystem(std::make_unique<NvidiaFactory>());
    nvidiaSystem.run();

    // 创建华为平台系统
    AutonomousSystem huaweiSystem(std::make_unique<HuaweiFactory>());
    huaweiSystem.run();

    return 0;
}

代码解析

1. 产品体系设计
cpp 复制代码 
class IComputeUnit { /*...*/ };  // 抽象产品
class NvidiaGPU : public IComputeUnit { /*...*/ };  // 具体产品
  • 接口隔离：每个硬件组件定义独立接口
  • 多态支持：统一接口访问不同平台实现
2. 工厂体系实现
cpp 复制代码 
class IHardwareFactory { /*...*/ };  // 抽象工厂
class NvidiaFactory : public IHardwareFactory { /*...*/ };  // 具体工厂
  • 家族封装：每个工厂生产配套硬件组件
  • 兼容保证：确保同一工厂创建的组件可协同工作
3. 系统集成
cpp 复制代码 
class AutonomousSystem {
    void initialize() {
        compute_ = factory_->createComputeUnit();
        // 创建其他组件...
    }
};
  • 依赖注入：通过构造函数传入具体工厂
  • 统一生命周期：智能指针自动管理组件

运行结果

复制代码 
=== 启动自动驾驶系统 ===
[NVIDIA] 使用CUDA统一内存分配4096MB
[NVIDIA] CUDA加速处理传感器数据
[TensorRT] 启动深度学习推理加速
计算性能: 32.8 TFLOPS

=== 启动自动驾驶系统 ===
[华为MDC] 分配DDR内存4096MB
[华为MDC] 昇腾芯片处理传感器数据
[MindSpore] 启动AI模型推理
计算性能: 28.5 TFLOPS

模式优势分析

在自动驾驶中的价值

  1. 平台兼容性

    • 确保计算单元+内存管理+加速器的硬件兼容
    • 快速切换硬件平台（更换工厂即可）

  2. 组件一致性

    • 防止混用不同平台组件（如NVIDIA加速器配华为内存）
    • 标准化硬件访问接口

  3. 可维护性

    • 新增硬件平台只需扩展工厂和产品类
    • 核心业务逻辑保持稳定

扩展改进建议

1. 动态配置加载
cpp 复制代码 
std::unique_ptr<IHardwareFactory> createFactory(const PlatformConfig& config) {
    if(config.platform == "NVIDIA") return std::make_unique<NvidiaFactory>();
    // 其他平台判断...
}
2. 混合硬件支持
cpp 复制代码 
class HybridFactory : public IHardwareFactory {
    // 组合不同厂商组件（需保证兼容性）
};
3. 资源监控
cpp 复制代码 
class MonitoredMemory : public IMemoryManager {
    // 添加内存使用监控功能
};

抽象工厂模式总结

核心价值：

  • 封装相关对象创建过程
  • 确保产品家族兼容性
  • 提高系统可配置性

适用场景：

  • 自动驾驶多硬件平台适配
  • 传感器套件兼容性保障
  • 仿真系统与真实系统切换

本实现展示了抽象工厂模式在自动驾驶硬件集成中的典型应用，通过严格的产品家族管理和接口标准化，为构建可移植、易扩展的自动驾驶系统提供了可靠的架构基础。

相关推荐
Pasregret5 分钟前
迭代器模式：统一数据遍历方式的设计模式
设计模式·迭代器模式
不当菜虚困6 分钟前
JAVA设计模式——（二）组合模式
java·设计模式·组合模式
ptu小鹏8 分钟前
类和对象（中）
开发语言·c++
大刘讲IT1 小时前
数据治理体系的“三驾马车”：质量、安全与价值挖掘
大数据·运维·经验分享·学习·安全·制造·零售
Rey_family2 小时前
CSS学习笔记
css·笔记·学习
CHQIUU2 小时前
Java 设计模式心法之第4篇 - 单例 (Singleton) 的正确打开方式与避坑指南
java·单例模式·设计模式
碎梦归途2 小时前
23种设计模式-结构型模式之享元模式（Java版本）
java·开发语言·jvm·设计模式·享元模式
明月看潮生2 小时前
青少年编程与数学 02-018 C++数据结构与算法 06课题、树
数据结构·c++·算法·青少年编程·编程与数学
宇柔2 小时前
JavaEE学习笔记（第二课）
笔记·学习·java-ee
小指纹2 小时前
动态规划（一）【背包】
c++·算法·动态规划
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03我决定放弃搞 Java 了04✨分享我在飞书多维表格中使用DeepSeek的经历✨05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06苍穹外卖面试总结07TS 高级类型：Partial 使用及实现原理08yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记09DeepSeek各版本说明与优缺点分析10如何在WPS和Word/Excel中直接使用DeepSeek功能