C++工厂模式详解：从基础到高级应用

1. 工厂模式基础与核心价值工厂模式是面向对象设计中应用最广泛的创建型模式之一其核心在于将对象的实例化过程封装起来使客户端代码与具体类解耦。在C这种强类型语言中工厂模式的价值尤为突出类型安全通过静态类型检查避免运行时类型错误扩展便利新增产品类时无需修改客户端代码逻辑集中将复杂的对象创建条件判断集中管理接口统一所有产品遵循同一抽象接口典型的简单工厂实现如下class Product { public: virtual void operation() 0; virtual ~Product() default; }; class ConcreteProductA : public Product { public: void operation() override { /*...*/ } }; class Factory { public: static std::unique_ptrProduct createProduct(int type) { switch(type) { case 1: return std::make_uniqueConcreteProductA(); // 其他产品类型... default: throw std::invalid_argument(Unknown product type); } } };2. 工厂方法模式进阶实现工厂方法模式通过引入抽象工厂类进一步解耦了具体产品的创建过程。这种模式特别适合以下场景产品类具有层次结构需要运行时动态决定创建哪种产品不同环境下需要创建不同产品一个标准的C工厂方法实现示例// 抽象产品 class Document { public: virtual void open() 0; virtual void save() 0; virtual ~Document() default; }; // 具体产品 class TextDocument : public Document { /*...*/ }; class SpreadsheetDocument : public Document { /*...*/ }; // 抽象工厂 class Application { public: virtual std::unique_ptrDocument createDocument() 0; void newDocument() { auto doc createDocument(); doc-open(); // 添加到文档集合... } }; // 具体工厂 class TextApplication : public Application { public: std::unique_ptrDocument createDocument() override { return std::make_uniqueTextDocument(); } };提示在C中实现工厂方法时建议使用智能指针管理产品对象生命周期避免内存泄漏。3. 抽象工厂模式实战应用抽象工厂模式用于创建相关或依赖对象的家族而不需要明确指定具体类。在游戏开发、UI框架等场景中尤为常见// 抽象产品族 class Button { public: virtual void render() 0; virtual ~Button() default; }; class Checkbox { public: virtual void toggle() 0; virtual ~Checkbox() default; }; // 具体产品族 - Windows风格 class WinButton : public Button { /*...*/ }; class WinCheckbox : public Checkbox { /*...*/ }; // 抽象工厂 class GUIFactory { public: virtual std::unique_ptrButton createButton() 0; virtual std::unique_ptrCheckbox createCheckbox() 0; virtual ~GUIFactory() default; }; // 具体工厂 class WinFactory : public GUIFactory { public: std::unique_ptrButton createButton() override { return std::make_uniqueWinButton(); } std::unique_ptrCheckbox createCheckbox() override { return std::make_uniqueWinCheckbox(); } };4. 模板工厂模式实现技巧C的模板特性可以实现更灵活的工厂模式这种技术常用于库开发中template typename ProductType class GenericFactory { public: template typename... Args static std::unique_ptrProductType create(Args... args) { return std::make_uniqueProductType(std::forwardArgs(args)...); } }; // 使用示例 class CustomProduct { public: CustomProduct(int param1, double param2) { /*...*/ } }; auto product GenericFactoryCustomProduct::create(42, 3.14);这种实现方式的优势在于编译时类型检查完美转发参数无需修改工厂即可支持新产品类型5. 原型模式与工厂的结合原型模式通过克隆现有对象来创建新对象与工厂模式结合可以产生强大的效果class Prototype { public: virtual std::unique_ptrPrototype clone() const 0; virtual ~Prototype() default; }; class ConcretePrototype : public Prototype { int data; public: std::unique_ptrPrototype clone() const override { return std::make_uniqueConcretePrototype(*this); } }; class PrototypeFactory { std::unordered_mapint, std::unique_ptrPrototype prototypes; public: void registerPrototype(int id, std::unique_ptrPrototype proto) { prototypes[id] std::move(proto); } std::unique_ptrPrototype create(int id) const { auto it prototypes.find(id); if (it ! prototypes.end()) { return it-second-clone(); } throw std::invalid_argument(Unknown prototype ID); } };6. 依赖注入框架中的工厂模式现代C依赖注入框架通常内置工厂模式的实现例如class Service { public: virtual void execute() 0; virtual ~Service() default; }; class ServiceFactory { public: virtual std::unique_ptrService create() 0; virtual ~ServiceFactory() default; }; class DIContainer { std::unordered_mapstd::type_index, std::functionstd::unique_ptrvoid() creators; public: template typename T void registerFactory(std::functionstd::unique_ptrT() factory) { creators[typeid(T)] [factory]() - std::unique_ptrvoid { return factory(); }; } template typename T std::unique_ptrT resolve() { auto it creators.find(typeid(T)); if (it ! creators.end()) { return std::unique_ptrT(static_castT*(it-second().release())); } throw std::runtime_error(Service not registered); } };7. 性能优化与线程安全考量在实现工厂模式时性能与线程安全是需要重点考虑的因素对象池技术template typename T class ObjectPool { std::queuestd::unique_ptrT pool; std::mutex mtx; public: template typename... Args void preallocate(size_t count, Args... args) { std::lock_guardstd::mutex lock(mtx); for (size_t i 0; i count; i) { pool.push(std::make_uniqueT(std::forwardArgs(args)...)); } } std::unique_ptrT acquire() { std::lock_guardstd::mutex lock(mtx); if (pool.empty()) return nullptr; auto obj std::move(pool.front()); pool.pop(); return obj; } void release(std::unique_ptrT obj) { std::lock_guardstd::mutex lock(mtx); pool.push(std::move(obj)); } };线程安全工厂class ThreadSafeFactory { static std::mutex instanceMutex; static std::unique_ptrThreadSafeFactory instance; ThreadSafeFactory() default; public: ThreadSafeFactory(const ThreadSafeFactory) delete; ThreadSafeFactory operator(const ThreadSafeFactory) delete; static ThreadSafeFactory getInstance() { std::lock_guardstd::mutex lock(instanceMutex); if (!instance) { instance std::make_uniqueThreadSafeFactory(); } return *instance; } template typename T, typename... Args std::unique_ptrT create(Args... args) { return std::make_uniqueT(std::forwardArgs(args)...); } };8. 现代C特性在工厂模式中的应用C17/20的新特性可以让工厂模式实现更加优雅使用std::variant实现类型安全工厂using ProductVariant std::variant std::unique_ptrConcreteProductA, std::unique_ptrConcreteProductB ; class ModernFactory { public: ProductVariant createProduct(int type) { switch(type) { case 1: return std::make_uniqueConcreteProductA(); case 2: return std::make_uniqueConcreteProductB(); default: throw std::invalid_argument(Unknown type); } } };使用concept约束工厂产品类型template typename T concept ProductConcept requires(T t) { { t.operation() } - std::same_asvoid; }; template ProductConcept T class ConceptFactory { public: std::unique_ptrT create() { return std::make_uniqueT(); } };9. 工厂模式在Qt框架中的实践Qt框架大量使用了工厂模式的思想特别是在对象创建和元对象系统中// Qt风格的工厂方法示例 class QtProduct { public: virtual QString name() const 0; virtual ~QtProduct() default; }; class QtFactory { public: virtual QtProduct* create(QWidget* parent nullptr) 0; virtual ~QtFactory() default; }; // 使用QMap注册工厂 class QtFactoryManager { QMapQString, QtFactory* factories; public: void registerFactory(const QString id, QtFactory* factory) { factories[id] factory; } QtProduct* create(const QString id, QWidget* parent nullptr) { if (factories.contains(id)) { return factories[id]-create(parent); } return nullptr; } };10. 设计模式组合应用案例在实际项目中工厂模式常与其他模式组合使用工厂策略模式class CompressionStrategy { public: virtual void compress(const std::string file) 0; virtual ~CompressionStrategy() default; }; class ZipStrategy : public CompressionStrategy { /*...*/ }; class RarStrategy : public CompressionStrategy { /*...*/ }; class CompressionFactory { public: static std::unique_ptrCompressionStrategy createStrategy(const std::string type) { if (type zip) return std::make_uniqueZipStrategy(); if (type rar) return std::make_uniqueRarStrategy(); throw std::invalid_argument(Unknown compression type); } };工厂装饰器模式class DataStream { public: virtual void write(const std::string data) 0; virtual ~DataStream() default; }; class FileStream : public DataStream { /*...*/ }; class NetworkStream : public DataStream { /*...*/ }; class StreamDecorator : public DataStream { protected: std::unique_ptrDataStream wrapped; public: StreamDecorator(std::unique_ptrDataStream stream) : wrapped(std::move(stream)) {} }; class EncryptedStream : public StreamDecorator { /*...*/ }; class CompressedStream : public StreamDecorator { /*...*/ }; class StreamFactory { public: enum class StreamType { File, Network }; enum class DecoratorType { None, Encrypted, Compressed }; static std::unique_ptrDataStream createStream( StreamType type, DecoratorType decorator DecoratorType::None ) { std::unique_ptrDataStream stream; switch(type) { case StreamType::File: stream std::make_uniqueFileStream(); break; case StreamType::Network: stream std::make_uniqueNetworkStream(); break; } switch(decorator) { case DecoratorType::Encrypted: return std::make_uniqueEncryptedStream(std::move(stream)); case DecoratorType::Compressed: return std::make_uniqueCompressedStream(std::move(stream)); default: return stream; } } };11. 工厂模式在游戏开发中的特殊应用游戏引擎通常需要高效地创建大量游戏对象这时工厂模式的变体显得尤为重要基于组件的对象工厂class GameObject { std::unordered_mapstd::type_index, std::unique_ptrvoid components; public: template typename T, typename... Args T addComponent(Args... args) { auto ptr std::make_uniqueT(std::forwardArgs(args)...); T ref *ptr; components[typeid(T)] std::move(ptr); return ref; } template typename T T* getComponent() { auto it components.find(typeid(T)); if (it ! components.end()) { return static_castT*(it-second.get()); } return nullptr; } }; class PrefabFactory { std::unordered_mapstd::string, std::functionvoid(GameObject) prefabs; public: void registerPrefab(const std::string name, auto configurator) { prefabs[name] std::forwarddecltype(configurator)(configurator); } GameObject create(const std::string name) { GameObject obj; if (prefabs.count(name)) { prefabs[name](obj); } return obj; } };12. 工厂模式的最佳实践与反模式在实际项目中使用工厂模式时需要注意以下实践要点最佳实践优先使用智能指针管理对象生命周期为工厂类定义清晰的接口契约考虑使用依赖注入替代硬编码的工厂对性能敏感的场景使用对象池技术在多线程环境中确保工厂的线程安全常见反模式上帝工厂单个工厂类负责创建过多不同类型的对象过度抽象为简单对象创建引入不必要的工厂层次循环依赖工厂与产品之间存在双向依赖忽略异常安全工厂方法可能抛出异常导致资源泄漏// 良好的工厂接口设计示例 class WellDesignedFactory { public: // 使用std::expected替代异常处理 std::expectedstd::unique_ptrProduct, ErrorCode createProduct(ProductType type) { switch(type) { case ProductType::A: return std::make_uniqueProductA(); case ProductType::B: return std::make_uniqueProductB(); default: return std::unexpected(ErrorCode::InvalidType); } } // 支持批量创建 std::vectorstd::unique_ptrProduct createProducts(std::spanconst ProductType types) { std::vectorstd::unique_ptrProduct products; products.reserve(types.size()); for (auto type : types) { if (auto product createProduct(type)) { products.push_back(std::move(*product)); } } return products; } };