从‘耐克鞋厂’到现代C++：工厂模式的演进与最佳实践（C++17/20版）-编程阁

从经典到现代：C++工厂模式的演进与最佳实践（C++17/20版）

工厂模式作为面向对象设计中最常用的创建型模式之一，经历了从简单封装到类型安全再到编译期优化的演进过程。本文将带您穿越时空，从传统的"鞋子工厂"示例出发，逐步探索如何利用现代C++特性重构和优化这一经典模式。

1. 传统工厂模式的局限与挑战

让我们从一个经典的"鞋子工厂"示例开始。这个例子虽然直观，却暴露了传统实现中的诸多问题：

class Shoes { public: virtual ~Shoes() {} virtual void Show() = 0; }; class ShoesFactory { public: Shoes* CreateShoes(SHOES_TYPE type) { switch(type) { case NIKE: return new NiKeShoes(); case ADIDAS: return new AdidasShoes(); default: return nullptr; } } };

这种实现存在三个明显缺陷：

资源管理风险：返回原始指针要求调用者手动管理内存，极易导致泄漏
类型安全性差：依赖枚举值而非类型系统，运行时错误难以避免
扩展性受限：新增产品类型需要修改工厂类，违反开闭原则

2. 现代C++的基础改造

2.1 智能指针与资源管理

C++11引入的智能指针是解决资源管理问题的首选方案：

std::unique_ptr<Shoes> CreateShoes(SHOES_TYPE type) { switch(type) { case NIKE: return std::make_unique<NiKeShoes>(); case ADIDAS: return std::make_unique<AdidasShoes>(); default: return nullptr; } }

关键改进：

自动内存管理，消除泄漏风险
明确所有权语义，代码自文档化
零额外开销，与原始指针性能相当

2.2 类型安全的工厂注册

使用std::function和映射表替代switch-case：

class ShoesFactory { std::unordered_map<SHOES_TYPE, std::function<std::unique_ptr<Shoes>()>> creators_; public: ShoesFactory() { Register<NikeShoes>(NIKE); Register<AdidasShoes>(ADIDAS); } template<typename T> void Register(SHOES_TYPE type) { creators_[type] = [] { return std::make_unique<T>(); }; } std::unique_ptr<Shoes> Create(SHOES_TYPE type) { if(auto it = creators_.find(type); it != creators_.end()) return it->second(); return nullptr; } };

优势对比：

特性	传统实现	现代实现
类型安全性	低	高
扩展性	需修改工厂	动态注册
代码可维护性	差	优

3. 编译期工厂模式探索

C++17/20带来了更多可能性，让我们能够将部分逻辑移至编译期。

3.1 基于variant的类型安全工厂

using ShoeVariant = std::variant<NikeShoes, AdidasShoes>; template<typename... Ts> class ShoeFactory { public: template<typename T> static ShoeVariant Create() { static_assert((std::is_same_v<T, Ts> || ...), "Unregistered shoe type"); return T{}; } }; // 使用示例 using Factory = ShoeFactory<NikeShoes, AdidasShoes>; auto shoe = Factory::Create<NikeShoes>();

3.2 概念约束与模板工厂

C++20概念(concepts)可以进一步增强类型约束：

template<typename T> concept ShoeType = requires { std::is_base_of_v<Shoes, T>; T::AdSlogan; // 要求有静态广告语 }; template<ShoeType... Ts> class ConceptFactory { // 实现类似上述模板工厂 };

4. 现代工厂模式的最佳实践

4.1 依赖注入与工厂组合

现代设计更倾向于依赖注入而非直接使用工厂：

class ShoeStore { std::function<std::unique_ptr<Shoes>()> factory_; public: explicit ShoeStore(decltype(factory_) f) : factory_(std::move(f)) {} void Advertise() { auto shoe = factory_(); shoe->Show(); } }; // 使用lambda配置不同工厂 auto nikeStore = ShoeStore([]{ return std::make_unique<NikeShoes>(); });

4.2 性能优化技巧

对象池模式：对频繁创建销毁的对象使用对象池
小型对象优化：利用std::aligned_storage避免堆分配
多态分配器：C++17的pmr内存资源

class ShoePool { std::vector<std::unique_ptr<Shoes>> pool_; public: template<typename T, typename... Args> Shoes* Get(Args&&... args) { if(pool_.empty()) { pool_.push_back(std::make_unique<T>(std::forward<Args>(args)...)); } auto ptr = pool_.back().get(); pool_.pop_back(); return ptr; } void Return(Shoes* shoe) { pool_.emplace_back(shoe); } };

5. 实际工程中的应用案例

在大型项目中，工厂模式常与其它模式结合使用。例如在游戏开发中：

class GameObjectFactory { struct Creator { std::function<std::unique_ptr<GameObject>()> create; std::function<void(GameObject*)> initialize; }; std::unordered_map<std::string, Creator> creators_; public: template<typename T> void Register(const std::string& name) { creators_[name] = { [] { return std::make_unique<T>(); }, [](GameObject* obj) { dynamic_cast<T*>(obj)->Init(); } }; } std::unique_ptr<GameObject> Create(const std::string& name) { if(auto it = creators_.find(name); it != creators_.end()) { auto obj = it->second.create(); it->second.initialize(obj.get()); return obj; } return nullptr; } };

性能对比数据：