抽象工厂模式及其在自动驾驶中的应用举例(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 {
    // 添加内存使用监控功能
};

抽象工厂模式总结

核心价值：

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

适用场景：

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

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

相关推荐
姜行运2 分钟前
数据结构【红黑树】
数据结构·c++·c#
君鼎16 分钟前
Effective C++ 条款10：令operator=返回一个reference to *this
c++
就是帅我不改32 分钟前
深入实战工厂模式与观察者模式：工厂模式与观察者模式在电商系统中的应用
后端·设计模式
鬼魅-95271 小时前
VS+Qt中使用QCustomPlot绘制曲线标签（附源码）
c++·qt
Star在努力1 小时前
15-C语言：第15~16天笔记
c语言·笔记·算法
xdlka2 小时前
C++初学者4——标准数据类型
开发语言·c++·算法
ZY小袁2 小时前
MGRE综合实验
服务器·网络·笔记·网络安全·学习方法·信息与通信·p2p
一位搞嵌入式的 genius2 小时前
暑期自学嵌入式——Day10（C语言阶段）
linux·笔记·学习·嵌入式c语言
被遗忘的旋律.2 小时前
Linux驱动开发笔记（五）——设备树（上）
linux·驱动开发·笔记
云边有个稻草人3 小时前
【C++】第十九节—一文万字详解 | AVL树实现
数据结构·c++·avl树·avl树的插入·avl树的旋转·avl树实现·avl树的结构
热门推荐
01Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code02全球最强模型Grok4，国内已可免费使用！（附教程）03Coze 开源了，送上保姆级私有化部署方案【建议收藏】04扣子开源本地部署教程 丨Coze智能体小白喂饭级指南05KGG转MP3工具|非KGM文件|解密音频06腾讯还是太全面了，限时免费！超全CodeBuddy IDE保姆级教程！（附案例）07【手把手攻略】国家育儿补贴正式开领！一键算清你能拿多少钱？附补贴领取计算器0801-开源版COZE-字节 Coze Studio 重磅开源！保姆级本地安装教程，手把手带你体验09干翻 Typora！MilkUp：完全免费的桌面端 Markdown 编辑器！10coze 开源版本地部署及踩过的坑【喂饭级教程】