抽象工厂模式及其在自动驾驶中的应用举例(c++代码实现)
模式定义抽象工厂模式（Abstract Factory Pattern）是一种创建型计划模式，用于封装一组具有共同主题的独立对象创建过程。该模式通过提供统一接口创建相关对象家属，而无需指定具体实现类，特殊得当必要保证体系组件兼容性的自动驾驶硬件平台适配场景。
自动驾驶应用场景
在自动驾驶硬件集成中常见的应用场景：
[*]多传感器套件适配：兼容不同厂商的LiDAR+Camera+Radar组合
[*]硬件平台移植：适配不同盘算平台（NVIDIA vs 华为MDC）
[*]仿真体系切换：切换真实硬件与仿真传感器组件
本文以自动驾驶盘算平台适配为例举行实现。
C++代码实现（含详细解释）
#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 << " CUDA加速处理传感器数据" << std::endl;
}
float getProcessingPower() const override {
return 32.8f;// TFLOPS
}
};
class NvidiaMemory : public IMemoryManager {
public:
void allocate(size_t size) override {
std::cout << " 使用CUDA统一内存分配" << size << "MB" << std::endl;
}
void release() override {
std::cout << " 释放CUDA内存" << std::endl;
}
};
class TensorRTAccelerator : public IHardwareAccelerator {
public:
void accelerateAI() override {
std::cout << " 启动深度学习推理加速" << 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 << " 启动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. 产品体系计划
class IComputeUnit { /*...*/ };// 抽象产品
class NvidiaGPU : public IComputeUnit { /*...*/ };// 具体产品
[*]接口隔离：每个硬件组件定义独立接口
[*]多态支持：统一接口访问不同平台实现
2. 工厂体系实现
class IHardwareFactory { /*...*/ };// 抽象工厂
class NvidiaFactory : public IHardwareFactory { /*...*/ };// 具体工厂
[*]家属封装：每个工厂生产配套硬件组件
[*]兼容保证：确保同一工厂创建的组件可协同工作
3. 体系集成
class AutonomousSystem {
void initialize() {
compute_ = factory_->createComputeUnit();
// 创建其他组件...
}
};
[*]依靠注入：通过构造函数传入具体工厂
[*]统一生命周期：智能指针自动管理组件
运行结果
=== 启动自动驾驶系统 ===
使用CUDA统一内存分配4096MB
CUDA加速处理传感器数据
启动深度学习推理加速
计算性能: 32.8 TFLOPS
=== 启动自动驾驶系统 ===
[华为MDC] 分配DDR内存4096MB
[华为MDC] 昇腾芯片处理传感器数据
启动AI模型推理
计算性能: 28.5 TFLOPS
模式优势分析
在自动驾驶中的价值
[*] 平台兼容性
[*]确保盘算单元+内存管理+加快器的硬件兼容
[*]快速切换硬件平台（更换工厂即可）
[*] 组件一致性
[*]防止混用不同平台组件（如NVIDIA加快器配华为内存）
[*]尺度化硬件访问接口
[*] 可维护性
[*]新增硬件平台只需扩展工厂和产品类
[*]核心业务逻辑保持稳定
扩展改进发起
1. 动态配置加载
std::unique_ptr<IHardwareFactory> createFactory(const PlatformConfig& config) {
if(config.platform == "NVIDIA") return std::make_unique<NvidiaFactory>();
// 其他平台判断...
}
2. 混合硬件支持
class HybridFactory : public IHardwareFactory {
// 组合不同厂商组件（需保证兼容性）
};
3. 资源监控
class MonitoredMemory : public IMemoryManager {
// 添加内存使用监控功能
};
抽象工厂模式总结
核心价值：
[*]封装相关对象创建过程
[*]确保产品家属兼容性
[*]提高体系可配置性
适用场景：
[*]自动驾驶多硬件平台适配
[*]传感器套件兼容性保障
[*]仿真体系与真实体系切换
本实现展示了抽象工厂模式在自动驾驶硬件集成中的典型应用，通过严酷的产品家属管理和接口尺度化，为构建可移植、易扩展的自动驾驶体系提供了可靠的架构底子。
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]