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

抽象工厂模式总结

核心价值：

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

适用场景：

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

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

相关推荐
Dann Hiroaki4 小时前
笔记分享: 哈尔滨工业大学CS31002编译原理——02. 语法分析
笔记·算法
KhalilRuan4 小时前
Unity-MMORPG内容笔记-其三
笔记
xiaolang_8616_wjl4 小时前
c++文字游戏_闯关打怪2.0(开源)
开发语言·c++·开源
夜月yeyue4 小时前
设计模式分析
linux·c++·stm32·单片机·嵌入式硬件
收破烂的小熊猫~5 小时前
《Java修仙传：从凡胎到码帝》第四章：设计模式破万法
java·开发语言·设计模式
kfepiza5 小时前
Debian的`/etc/network/interfaces`的`allow-hotplug`和`auto`对比讲解 笔记250704
linux·服务器·网络·笔记·debian
无妄-20245 小时前
软件架构升级中的“隐形地雷”：版本选型与依赖链风险
java·服务器·网络·经验分享
无小道5 小时前
c++-引用（包括完美转发，移动构造，万能引用）
c语言·开发语言·汇编·c++
FirstFrost --sy7 小时前
数据结构之二叉树
c语言·数据结构·c++·算法·链表·深度优先·广度优先
Tanecious.7 小时前
C++--map和set的使用
开发语言·c++
热门推荐
01集群聊天服务器---MySQL数据库的建立02Java学习第十五部分——MyBatis03Coze扣子平台完整体验和实践（附国内和国际版对比）04《深入设计模式》模式结构汇总05使用Ruby接入实时行情API教程06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07基于odoo17的设计模式详解---单例模式08基于odoo17的设计模式详解---装饰模式09DeepSeek各版本说明与优缺点分析10Everything文件检索工具 几秒检索几百G的文件