1. 工厂方法模式深度解析
工厂方法模式（Factory Method Pattern）是面向对象设计中最为常用的创建型模式之一。它的核心思想是将对象的创建过程延迟到子类中完成，让子类决定实例化哪个具体类。这种设计方式完美体现了"依赖倒置原则"（DIP）——高层模块不应该依赖低层模块，二者都应该依赖抽象。
1.1 模式本质与价值
工厂方法模式的本质在于定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。这种设计带来了几个关键优势：
- 解耦客户端与具体产品：客户端代码只需要知道抽象产品接口，无需关心具体实现类
- 符合开闭原则：新增产品类型时只需添加新的工厂子类，无需修改现有代码
- 提高代码可维护性：创建逻辑集中在工厂类中，便于统一管理和修改
在实际工程中，工厂方法模式特别适合以下场景：
- 框架设计：让框架用户能够扩展框架内部的对象创建
- 跨平台开发：不同平台需要创建不同的实现类
- 插件系统：动态加载和创建插件对象
1.2 模式结构详解
工厂方法模式的标准UML结构包含以下关键角色：
- Product（抽象产品）：定义产品的接口，是工厂方法创建对象的超类型
- ConcreteProduct（具体产品）：实现Product接口的具体类
- Creator（抽象工厂）：声明工厂方法，返回Product类型对象
- ConcreteCreator（具体工厂）：重写工厂方法，返回具体的ConcreteProduct实例
在C++实现中，这些角色通常表现为：
- 抽象产品：纯虚基类
- 具体产品：继承自抽象产品的具体类
- 抽象工厂：包含纯虚工厂方法的基类
- 具体工厂：实现工厂方法的具体子类
2. C++实现细节与最佳实践
2.1 基础实现模板
让我们先看一个完整的C++实现模板，这是理解工厂方法模式的基础：
cpp复制// 抽象产品
class Product {
public:
virtual ~Product() = default;
virtual void operation() = 0;
};
// 具体产品A
class ConcreteProductA : public Product {
public:
void operation() override {
std::cout << "ConcreteProductA operation\n";
}
};
// 具体产品B
class ConcreteProductB : public Product {
public:
void operation() override {
std::cout << "ConcreteProductB operation\n";
}
};
// 抽象工厂
class Creator {
public:
virtual ~Creator() = default;
virtual std::unique_ptr<Product> createProduct() = 0;
void someOperation() {
auto product = createProduct();
product->operation();
}
};
// 具体工厂A
class ConcreteCreatorA : public Creator {
public:
std::unique_ptr<Product> createProduct() override {
return std::make_unique<ConcreteProductA>();
}
};
// 具体工厂B
class ConcreteCreatorB : public Creator {
public:
std::unique_ptr<Product> createProduct() override {
return std::make_unique<ConcreteProductB>();
}
};
2.2 现代C++特性应用
现代C++提供了许多特性可以让工厂方法实现更加优雅和安全：
1. 智能指针管理生命周期
使用std::unique_ptr自动管理产品对象的生命周期，避免内存泄漏：
cpp复制virtual std::unique_ptr<Product> createProduct() = 0;
2. override关键字
明确标记重写的虚函数，让编译器帮助检查签名是否正确：
cpp复制void operation() override {
// ...
}
3. final关键字
对于不希望被进一步重写的函数或类，使用final明确禁止：
cpp复制class ConcreteProductA final : public Product {
// ...
};
4. constexpr工厂
对于编译期已知的类型，可以使用constexpr工厂函数：
cpp复制template<typename T>
constexpr std::unique_ptr<Product> create() {
return std::make_unique<T>();
}
2.3 关键实现注意事项
在实现工厂方法模式时，有几个关键点需要特别注意：
1. 虚析构函数必不可少
基类必须有虚析构函数，否则通过基类指针删除派生类对象会导致未定义行为：
cpp复制virtual ~Product() = default; // 必须要有
2. 工厂方法的返回类型
工厂方法通常返回抽象产品类型的指针或智能指针。在现代C++中，优先使用std::unique_ptr而非裸指针。
3. 对象所有权明确
明确工厂创建的对象所有权转移给调用者，避免所有权混乱导致的资源管理问题。
4. 异常安全
工厂方法应该提供基本的异常安全保证，通常至少是强异常安全保证。
3. 高级应用与变体
3.1 注册表式工厂
对于动态扩展的场景，可以使用注册表模式实现更灵活的工厂：
cpp复制class ProductRegistry {
public:
using CreatorFunc = std::function<std::unique_ptr<Product>()>;
static ProductRegistry& instance() {
static ProductRegistry registry;
return registry;
}
void registerCreator(const std::string& name, CreatorFunc creator) {
creators_[name] = std::move(creator);
}
std::unique_ptr<Product> create(const std::string& name) {
auto it = creators_.find(name);
if (it == creators_.end()) {
throw std::runtime_error("Unknown product: " + name);
}
return it->second();
}
private:
std::unordered_map<std::string, CreatorFunc> creators_;
};
// 注册产品
struct ProductRegistrar {
ProductRegistrar(const std::string& name,
ProductRegistry::CreatorFunc creator) {
ProductRegistry::instance().registerCreator(name, std::move(creator));
}
};
// 宏简化注册
#define REGISTER_PRODUCT(name, type) \
static ProductRegistrar registrar_##type( \
name, []{ return std::make_unique<type>(); })
这种实现允许在运行时动态注册新的产品类型，非常适合插件系统。
3.2 模板工厂
对于类型安全的工厂，可以使用模板方法：
cpp复制template<typename ProductType>
class GenericCreator {
public:
std::unique_ptr<Product> createProduct() {
return std::make_unique<ProductType>();
}
};
// 使用
using MyCreator = GenericCreator<ConcreteProductA>;
3.3 多态拷贝（原型模式结合）
结合原型模式实现对象的克隆：
cpp复制class Product {
public:
virtual ~Product() = default;
virtual std::unique_ptr<Product> clone() const = 0;
// ...
};
class ConcreteProductA : public Product {
public:
std::unique_ptr<Product> clone() const override {
return std::make_unique<ConcreteProductA>(*this);
}
// ...
};
4. 工程实践中的经验与陷阱
4.1 性能考量
工厂方法模式引入的间接层会带来一定的性能开销，主要体现在：
- 虚函数调用开销：工厂方法和产品方法的调用通常都是虚函数
- 对象创建开销：多了一次工厂方法调用
- 内存局部性：分散的对象创建可能影响缓存利用率
在性能关键路径上，可以考虑以下优化：
- 使用模板减少虚函数调用
- 对象池技术复用对象
- 批量创建减少分配次数
4.2 测试策略
工厂方法模式会影响单元测试的方式：
- 测试具体产品：可以直接实例化具体产品类测试
- 测试工厂：需要验证工厂创建的对象类型和属性
- 模拟工厂：在测试客户端代码时可以使用模拟工厂
使用Google Test的测试示例：
cpp复制TEST(FactoryMethodTest, CreatesCorrectType) {
ConcreteCreatorA creator;
auto product = creator.createProduct();
EXPECT_NE(dynamic_cast<ConcreteProductA*>(product.get()), nullptr);
}
TEST(FactoryMethodTest, OperationWorks) {
ConcreteCreatorB creator;
auto product = creator.createProduct();
testing::internal::CaptureStdout();
product->operation();
std::string output = testing::internal::GetCapturedStdout();
EXPECT_EQ(output, "ConcreteProductB operation\n");
}
4.3 常见陷阱与规避
- 对象切片问题
当工厂方法返回基类对象而非指针/引用时，会发生对象切片：
cpp复制// 错误示例：会发生切片
Product createProduct() {
return ConcreteProductA();
}
正确做法：始终返回指针或智能指针。
- 循环依赖
工厂和产品之间容易出现循环依赖：
code复制factory.h → product.h → factory.h
解决方案：前向声明和分离接口。
- 过度设计
不是所有情况都需要工厂方法模式。简单场景直接使用构造函数可能更合适。
判断标准：如果对象创建逻辑简单且不会变化，可能不需要工厂模式。
5. 与其他模式的关系
5.1 工厂方法 vs 简单工厂
简单工厂（静态工厂）使用一个静态方法封装对象创建：
cpp复制class SimpleFactory {
public:
static std::unique_ptr<Product> create(const std::string& type) {
if (type == "A") return std::make_unique<ConcreteProductA>();
if (type == "B") return std::make_unique<ConcreteProductB>();
return nullptr;
}
};
对比：
- 简单工厂：修改工厂类来扩展（违反开闭原则）
- 工厂方法：通过新增子类来扩展（符合开闭原则）
5.2 工厂方法 vs 抽象工厂
抽象工厂模式创建的是产品族（多个相关产品），而工厂方法创建的是单个产品。
关系：
- 抽象工厂通常使用多个工厂方法来实现
- 工厂方法可以看作是抽象工厂的特例（只创建一个产品）
5.3 工厂方法 vs 依赖注入
依赖注入（DI）是一种实现控制反转的方式，可以看作是工厂方法的一种替代方案：
cpp复制// 通过构造函数注入
class Client {
public:
explicit Client(std::unique_ptr<Product> product)
: product_(std::move(product)) {}
private:
std::unique_ptr<Product> product_;
};
选择依据：
- 工厂方法：当对象创建需要复杂逻辑或运行时决定时
- 依赖注入：当依赖关系明确且由外部控制时
6. 现代C++中的演进
6.1 使用std::function作为工厂
现代C++可以使用std::function实现更灵活的工厂：
cpp复制using ProductFactory = std::function<std::unique_ptr<Product>()>;
ProductFactory createAFactory() {
return [] { return std::make_unique<ConcreteProductA>(); };
}
void useProduct(ProductFactory factory) {
auto product = factory();
product->operation();
}
6.2 可变参数工厂
支持传递构造参数的通用工厂：
cpp复制template<typename Base, typename... Args>
class GenericFactory {
public:
using Creator = std::function<std::unique_ptr<Base>(Args...)>;
template<typename T>
void registerType(const std::string& name) {
creators_[name] = [](Args... args) {
return std::make_unique<T>(std::forward<Args>(args)...);
};
}
std::unique_ptr<Base> create(const std::string& name, Args... args) {
auto it = creators_.find(name);
if (it == creators_.end()) {
throw std::runtime_error("Unknown type");
}
return it->second(std::forward<Args>(args)...);
}
private:
std::unordered_map<std::string, Creator> creators_;
};
6.3 编译期工厂
利用C++17的if constexpr实现编译期工厂：
cpp复制template<typename T>
std::unique_ptr<Product> create() {
if constexpr (std::is_same_v<T, ConcreteProductA>) {
return std::make_unique<ConcreteProductA>();
}
else if constexpr (std::is_same_v<T, ConcreteProductB>) {
return std::make_unique<ConcreteProductB>();
}
else {
static_assert(false, "Unknown product type");
}
}
7. 实际案例：跨平台GUI组件工厂
让我们看一个实际的跨平台GUI组件工厂实现：
cpp复制// 抽象产品：按钮
class Button {
public:
virtual ~Button() = default;
virtual void render() = 0;
virtual void onClick() = 0;
};
// Windows按钮
class WindowsButton : public Button {
public:
void render() override {
std::cout << "Windows风格按钮渲染\n";
}
void onClick() override {
std::cout << "Windows按钮点击处理\n";
}
};
// MacOS按钮
class MacOSButton : public Button {
public:
void render() override {
std::cout << "MacOS风格按钮渲染\n";
}
void onClick() override {
std::cout << "MacOS按钮点击处理\n";
}
};
// 抽象工厂
class GUIFactory {
public:
virtual ~GUIFactory() = default;
virtual std::unique_ptr<Button> createButton() = 0;
};
// Windows工厂
class WindowsFactory : public GUIFactory {
public:
std::unique_ptr<Button> createButton() override {
return std::make_unique<WindowsButton>();
}
};
// MacOS工厂
class MacOSFactory : public GUIFactory {
public:
std::unique_ptr<Button> createButton() override {
return std::make_unique<MacOSButton>();
}
};
// 客户端代码
class Application {
public:
explicit Application(std::unique_ptr<GUIFactory> factory)
: factory_(std::move(factory)) {}
void createUI() {
auto button = factory_->createButton();
button->render();
button->onClick();
}
private:
std::unique_ptr<GUIFactory> factory_;
};
// 根据当前平台创建合适工厂
std::unique_ptr<GUIFactory> createFactory() {
#ifdef _WIN32
return std::make_unique<WindowsFactory>();
#elif __APPLE__
return std::make_unique<MacOSFactory>();
#else
throw std::runtime_error("Unsupported platform");
#endif
}
这个例子展示了工厂方法模式在跨平台开发中的典型应用，每个平台有自己的具体工厂和产品实现，但客户端代码只依赖抽象接口。
8. 设计决策与替代方案
8.1 何时选择工厂方法模式
选择工厂方法模式的典型场景包括：
- 类无法预知它需要创建的对象类型：由子类决定创建什么对象
- 类希望其子类指定它创建的对象：将创建责任委托给子类
- 需要解耦创建逻辑和使用逻辑：遵循单一职责原则
- 需要灵活的扩展机制：支持未来添加新产品类型
8.2 替代方案评估
在某些场景下，可以考虑以下替代方案：
1. 构造函数直接创建
- 优点：简单直接
- 缺点：缺乏灵活性，违反开闭原则
2. 原型模式
- 优点：通过克隆现有对象创建新对象
- 缺点：需要实现克隆接口
3. 依赖注入
- 优点：解耦更彻底
- 缺点：需要外部容器管理生命周期
4. 服务定位器模式
- 优点：全局访问点
- 缺点：隐藏依赖关系
8.3 设计权衡
在设计工厂方法时需要考虑以下权衡：
- 复杂度 vs 灵活性：工厂方法增加了设计复杂度，但提供了更好的扩展性
- 编译时依赖 vs 运行时依赖：工厂方法将部分依赖从编译时转移到了运行时
- 代码分散 vs 集中：创建逻辑分散在各个具体工厂中，但使用逻辑集中在抽象工厂
9. 反模式与误用
9.1 常见误用场景
- 过度使用工厂：简单对象创建也使用工厂，导致代码冗余
- 巨型工厂：一个工厂类负责创建太多不相关的产品
- 违反单一职责：工厂类除了创建对象还承担其他职责
- 忽略对象生命周期：工厂创建的对象生命周期管理混乱
9.2 反模式示例
1. 全能工厂
cpp复制// 反模式：一个工厂创建所有东西
class GodFactory {
public:
std::unique_ptr<A> createA();
std::unique_ptr<B> createB();
std::unique_ptr<C> createC();
// ...越来越多的创建方法
};
改进方案：按职责划分多个工厂类。
2. 忽略内存管理
cpp复制// 反模式：返回裸指针，所有权不明确
Product* create() {
return new ConcreteProduct();
}
改进方案：使用智能指针明确所有权。
3. 过度嵌套工厂
cpp复制// 反模式：过度复杂的工厂层次
class AbstractFactory {
virtual IntermediateFactory* createFactory() = 0;
};
class IntermediateFactory {
virtual Product* createProduct() = 0;
};
改进方案：简化设计，避免不必要的间接层。
10. 性能优化技巧
10.1 对象池技术
对于创建成本高的对象，可以结合对象池技术：
cpp复制class ProductPool {
public:
virtual ~ProductPool() {
for (auto* p : pool_) {
delete p;
}
}
Product* acquire() {
if (pool_.empty()) {
return createProduct();
}
auto* p = pool_.back();
pool_.pop_back();
return p;
}
void release(Product* p) {
pool_.push_back(p);
}
protected:
virtual Product* createProduct() = 0;
private:
std::vector<Product*> pool_;
};
10.2 热路径优化
对于性能关键路径，可以：
- 使用模板替代虚函数
- 预创建常用对象
- 使用内存池分配器
10.3 编译期工厂
对于类型已知的场景，可以使用模板实现编译期工厂：
cpp复制template<typename ProductType>
class TypedCreator {
public:
std::unique_ptr<Product> create() {
return std::make_unique<ProductType>();
}
};
这种实现完全消除了运行时多态开销。
11. 测试与调试技巧
11.1 单元测试策略
- 测试具体工厂：验证每个工厂创建的对象类型正确
- 测试产品行为：确保产品对象符合预期行为
- 测试异常情况：测试工厂对无效请求的处理
11.2 调试技巧
- 工厂日志：在工厂方法中添加日志记录创建的对象类型
- 运行时类型信息：使用typeid或dynamic_cast检查对象类型
- 断点策略：在工厂方法和产品构造函数设置断点
11.3 Mock对象测试
使用Google Mock创建mock对象测试工厂：
cpp复制class MockProduct : public Product {
public:
MOCK_METHOD(void, operation, (), (override));
};
class MockFactory : public Creator {
public:
MOCK_METHOD(std::unique_ptr<Product>, createProduct, (), (override));
};
TEST(FactoryTest, CreatesMockProduct) {
MockFactory factory;
auto mockProduct = std::make_unique<MockProduct>();
EXPECT_CALL(factory, createProduct())
.WillOnce(Return(ByMove(std::move(mockProduct))));
auto product = factory.createProduct();
EXPECT_NE(product, nullptr);
}
12. 扩展与变体
12.1 参数化工厂方法
工厂方法可以接受参数来决定创建的对象类型：
cpp复制class ParametricCreator {
public:
virtual std::unique_ptr<Product> create(ProductType type) = 0;
};
12.2 惰性初始化
结合代理模式实现惰性初始化：
cpp复制class LazyProductProxy : public Product {
public:
explicit LazyProductProxy(std::function<std::unique_ptr<Product>()> factory)
: factory_(std::move(factory)) {}
void operation() override {
if (!product_) {
product_ = factory_();
}
product_->operation();
}
private:
std::function<std::unique_ptr<Product>()> factory_;
std::unique_ptr<Product> product_;
};
12.3 多语言支持
工厂方法可以用于实现多语言资源创建：
cpp复制class LocaleSpecificFactory : public Creator {
public:
explicit LocaleSpecificFactory(const std::string& locale)
: locale_(locale) {}
std::unique_ptr<Product> createProduct() override {
if (locale_ == "zh-CN") {
return std::make_unique<ChineseProduct>();
} else if (locale_ == "en-US") {
return std::make_unique<EnglishProduct>();
}
return std::make_unique<DefaultProduct>();
}
private:
std::string locale_;
};
13. 现代C++20特性应用
13.1 概念约束工厂
使用C++20概念约束工厂创建的产品类型：
cpp复制template<typename T>
concept ProductType = std::is_base_of_v<Product, T>;
template<ProductType T>
std::unique_ptr<Product> create() {
return std::make_unique<T>();
}
13.2 协程支持
工厂方法可以与协程结合实现异步创建：
cpp复制cppcoro::task<std::unique_ptr<Product>> createAsync() {
// 模拟异步操作
co_await cppcoro::sleep_for(std::chrono::seconds(1));
co_return std::make_unique<ConcreteProductA>();
}
13.3 三路比较支持
为产品实现三路比较：
cpp复制class ComparableProduct : public Product {
public:
virtual std::strong_ordering operator<=>(const ComparableProduct&) const = 0;
};
14. 设计模式组合应用
14.1 工厂方法+单例
确保工厂实例唯一：
cpp复制class SingletonFactory : public Creator {
public:
static SingletonFactory& instance() {
static SingletonFactory instance;
return instance;
}
std::unique_ptr<Product> createProduct() override {
return std::make_unique<ConcreteProductA>();
}
private:
SingletonFactory() = default;
};
14.2 工厂方法+观察者
产品创建通知观察者：
cpp复制class ObservableFactory : public Creator {
public:
void addObserver(Observer* o) {
observers_.push_back(o);
}
std::unique_ptr<Product> createProduct() override {
auto product = std::make_unique<ConcreteProductA>();
for (auto* o : observers_) {
o->onProductCreated(product.get());
}
return product;
}
private:
std::vector<Observer*> observers_;
};
14.3 工厂方法+策略
动态切换创建策略：
cpp复制class StrategyFactory : public Creator {
public:
explicit StrategyFactory(std::function<std::unique_ptr<Product>()> strategy)
: strategy_(std::move(strategy)) {}
std::unique_ptr<Product> createProduct() override {
return strategy_();
}
void setStrategy(std::function<std::unique_ptr<Product>()> strategy) {
strategy_ = std::move(strategy);
}
private:
std::function<std::unique_ptr<Product>()> strategy_;
};
15. 领域特定应用案例
15.1 游戏开发中的应用
在游戏开发中，工厂方法常用于创建不同类型的游戏实体：
cpp复制class GameEntityFactory {
public:
virtual std::unique_ptr<Entity> createEnemy() = 0;
virtual std::unique_ptr<Entity> createNPC() = 0;
virtual std::unique_ptr<Entity> createItem() = 0;
};
class FantasyGameFactory : public GameEntityFactory {
public:
std::unique_ptr<Entity> createEnemy() override {
return std::make_unique<Dragon>();
}
// ...其他实现
};
class SciFiGameFactory : public GameEntityFactory {
public:
std::unique_ptr<Entity> createEnemy() override {
return std::make_unique<Alien>();
}
// ...其他实现
};
15.2 GUI框架中的应用
如前面跨平台GUI示例所示，工厂方法在GUI框架中用于创建平台特定的控件。
15.3 数据库访问层
创建不同类型的数据库连接：
cpp复制class DbConnectionFactory {
public:
virtual std::unique_ptr<DbConnection> createConnection() = 0;
};
class MySqlConnectionFactory : public DbConnectionFactory {
public:
std::unique_ptr<DbConnection> createConnection() override {
return std::make_unique<MySqlConnection>();
}
};
class SqliteConnectionFactory : public DbConnectionFactory {
public:
std::unique_ptr<DbConnection> createConnection() override {
return std::make_unique<SqliteConnection>();
}
};
16. 代码生成与元编程
16.1 自动生成工厂代码
使用模板元编程自动生成工厂代码：
cpp复制template<typename Base, typename... Args>
class AutoRegisterFactory {
public:
template<typename T>
void registerType(const std::string& name) {
creators_[name] = &createFunc<T, Args...>;
}
std::unique_ptr<Base> create(const std::string& name, Args... args) {
auto it = creators_.find(name);
if (it == creators_.end()) {
throw std::runtime_error("Unknown type");
}
return it->second(std::forward<Args>(args)...);
}
private:
template<typename T, typename... CtorArgs>
static std::unique_ptr<Base> createFunc(CtorArgs... args) {
return std::make_unique<T>(std::forward<CtorArgs>(args)...);
}
std::unordered_map<std::string, std::function<std::unique_ptr<Base>(Args...)>> creators_;
};
16.2 反射支持
结合反射机制实现更动态的工厂：
cpp复制class ReflectiveFactory {
public:
std::unique_ptr<void> create(const std::string& typeName) {
auto it = registry_.find(typeName);
if (it == registry_.end()) {
return nullptr;
}
return it->second();
}
template<typename T>
void registerType(const std::string& typeName) {
registry_[typeName] = [] { return std::make_unique<T>(); };
}
private:
std::unordered_map<std::string, std::function<std::unique_ptr<void>()>> registry_;
};
17. 多线程环境下的考量
17.1 线程安全工厂
确保工厂在多线程环境下安全使用：
cpp复制class ThreadSafeFactory {
public:
std::unique_ptr<Product> createProduct() {
std::lock_guard<std::mutex> lock(mutex_);
return std::make_unique<ConcreteProduct>();
}
private:
std::mutex mutex_;
};
17.2 双重检查锁定
优化线程安全工厂性能：
cpp复制class SingletonFactory {
public:
static SingletonFactory& instance() {
static SingletonFactory instance;
return instance;
}
std::unique_ptr<Product> createProduct() {
std::unique_ptr<Product> product;
{
std::lock_guard<std::mutex> lock(mutex_);
if (!product_) {
product_ = std::make_unique<ConcreteProduct>();
}
product = std::move(product_);
}
return product;
}
private:
std::mutex mutex_;
std::unique_ptr<Product> product_;
};
17.3 无锁设计
对于高性能场景，可以考虑无锁设计：
cpp复制class LockFreeFactory {
public:
std::unique_ptr<Product> createProduct() {
static std::atomic<int> counter{0};
return std::make_unique<ConcreteProduct>(counter.fetch_add(1));
}
};
18. 跨语言互操作
18.1 C接口工厂
提供C兼容接口：
cpp复制extern "C" {
typedef void* product_handle;
product_handle create_product() {
try {
auto product = std::make_unique<ConcreteProduct>();
return product.release();
} catch (...) {
return nullptr;
}
}
void destroy_product(product_handle p) {
delete static_cast<Product*>(p);
}
}
18.2 Python绑定
使用pybind11创建Python绑定：
cpp复制PYBIND11_MODULE(factory, m) {
py::class_<Product, std::unique_ptr<Product>>(m, "Product")
.def("operation", &Product::operation);
py::class_<ConcreteCreator>(m, "ConcreteCreator")
.def(py::init<>())
.def("create_product", &ConcreteCreator::createProduct);
}
18.3 WebAssembly支持
编译为WebAssembly在浏览器中运行：
cpp复制EMSCRIPTEN_BINDINGS(factory) {
emscripten::class_<Product>("Product")
.function("operation", &Product::operation);
emscripten::class_<ConcreteCreator>("ConcreteCreator")
.constructor<>()
.function("createProduct", &ConcreteCreator::createProduct);
}
19. 工具与库支持
19.1 Boost.Factory
Boost库提供了工厂模式的工具支持：
cpp复制#include <boost/functional/factory.hpp>
auto factory = boost::factory<std::unique_ptr<ConcreteProduct>>();
auto product = factory();
19.2 DI框架集成
与依赖注入框架集成：
cpp复制class ProductModule : public di::module {
public:
void configure() override {
bind<Product>().to<ConcreteProduct>().in<di::singleton>();
bind<Creator>().to<ConcreteCreator>();
}
};
19.3 代码生成工具
使用工具自动生成工厂代码，如Clang的AST matchers或模板代码生成器。
20. 未来演进与趋势
20.1 编译期反射
未来C++可能引入编译期反射，进一步简化工厂模式实现：
cpp复制template<typename T>
std::unique_ptr<T> create() {
if constexpr (requires { T::create(); }) {
return T::create();
} else {
return std::make_unique<T>();
}
}
20.2 模式识别与自动应用
IDE和工具链可能自动识别适合工厂模式的场景并建议重构。
20.3 函数式编程影响
函数式编程风格可能影响工厂模式的实现方式，更多使用高阶函数和闭包。
工厂方法模式作为经典的设计模式，在现代C++中仍然具有重要价值，但随着语言特性的演进，其实现方式和应用场景也在不断发展。理解其核心思想并灵活应用，是每个C++开发者必备的技能。