C++抽象工厂模式：跨平台UI组件创建实战-嵌云网-嵌入式AI开发资源站

1. 抽象工厂模式的核心价值

抽象工厂模式是23种经典设计模式中创建型模式的集大成者。我在实际项目中最深刻的体会是：当系统需要支持多套产品族（比如不同风格的UI组件、跨平台的数据库访问接口），而客户端代码又不希望与具体实现类耦合时，抽象工厂就是那把瑞士军刀。

举个例子，我们开发跨平台图形编辑器时，Windows和macOS的按钮(Button)、文本框(Textbox)属于不同产品族。抽象工厂通过定义IGUIFactory接口，让WinFactory和MacFactory分别生产风格一致的控件，客户端只需切换工厂实例，所有控件自动保持同一系统风格。这种解耦带来的可维护性提升，在大型项目中尤为明显。

2. C++实现抽象工厂的完整方案

2.1 接口设计原则

抽象工厂的核心是接口隔离。在C++中我们通常采用纯虚基类定义抽象产品接口，例如：

cpp复制// 抽象产品A
class IButton {
public:
    virtual void render() = 0;
    virtual void onClick() = 0;
    virtual ~IButton() = default;
};

// 抽象产品B  
class ITextbox {
public:
    virtual void draw() = 0;
    virtual void setText(const std::string&) = 0;
    virtual ~ITextbox() = default;
};

关键点在于：

接口方法必须纯虚(=0)
必须声明虚析构函数（防止子类内存泄漏）
接口类命名建议加前缀"I"（业界常见约定）

2.2 具体工厂实现技巧

针对Windows和macOS的具体工厂实现：

cpp复制// Windows产品族
class WinButton : public IButton {
public:
    void render() override {
        std::cout << "Windows风格按钮渲染\n";
        // 调用Win32 API...
    }
    // ...其他实现
};

class WinTextbox : public ITextbox { /*...*/ };

// macOS产品族  
class MacButton : public IButton {
    void render() override {
        std::cout << "macOS风格按钮渲染\n";
        // 调用Cocoa API...
    }
    // ...其他实现
};

class MacTextbox : public ITextbox { /*...*/ };

工厂类的典型实现：

cpp复制class IGUIFactory {
public:
    virtual std::unique_ptr<IButton> createButton() = 0;
    virtual std::unique_ptr<ITextbox> createTextbox() = 0;
    virtual ~IGUIFactory() = default;
};

class WinFactory : public IGUIFactory {
public:
    std::unique_ptr<IButton> createButton() override {
        return std::make_unique<WinButton>();
    }
    // ...其他方法
};

class MacFactory : public IGUIFactory {
    // 类似实现...
};

关键技巧：使用std::unique_ptr管理产品对象生命周期，避免原始指针的内存管理负担。

2.3 客户端调用最佳实践

客户端代码应该只依赖抽象接口：

cpp复制class Application {
    std::unique_ptr<IGUIFactory> factory_;
    std::unique_ptr<IButton> button_;
    std::unique_ptr<ITextbox> textbox_;
    
public:
    explicit Application(std::unique_ptr<IGUIFactory> factory) 
        : factory_(std::move(factory)) {
        createUI();
    }
    
    void createUI() {
        button_ = factory_->createButton();
        textbox_ = factory_->createTextbox();
    }
    
    void run() {
        button_->render();
        textbox_->draw();
    }
};

// 使用示例
int main() {
    auto app = std::make_unique<Application>(
        std::make_unique<WinFactory>()  // 切换为MacFactory即可换肤
    );
    app->run();
}

3. 工业级实现的进阶考量

3.1 工厂单例化处理

实际项目中，工厂实例通常只需要一个：

cpp复制class WinFactory : public IGUIFactory {
    WinFactory() = default;
public:
    static IGUIFactory& instance() {
        static WinFactory inst;
        return inst;
    }
    // ...禁止拷贝等
};

3.2 产品注册机制

通过宏实现动态注册（简化版）：

cpp复制#define REGISTER_PRODUCT(factory, product) \
    factory::instance().registerCreator( \
        typeid(product).name(), \
        []{ return std::make_unique<product>(); } \
    )

// 使用示例
REGISTER_PRODUCT(WinFactory, WinButton);

3.3 跨DLL边界问题

Windows平台需注意：

cpp复制// 工厂接口声明需添加导出标记
class __declspec(dllexport) IGUIFactory {
    // ...
};

// 客户端代码用__declspec(dllimport)

4. 典型问题排查指南

4.1 内存泄漏检测

使用VLD工具检查：

bash复制# CMake配置
find_package(VLD)
if(VLD_FOUND)
    target_link_libraries(your_target PRIVATE VLD::VLD)
endif()

4.2 多线程安全实现

工厂方法加锁：

cpp复制std::unique_ptr<IButton> WinFactory::createButton() {
    static std::mutex mtx;
    std::lock_guard<std::mutex> lock(mtx);
    return std::make_unique<WinButton>();
}

4.3 性能优化策略

对象池技术应用：

cpp复制class ButtonPool {
    std::stack<std::unique_ptr<IButton>> pool_;
public:
    std::unique_ptr<IButton> acquire() {
        if(pool_.empty()) return createNew();
        auto obj = std::move(pool_.top());
        pool_.pop();
        return obj;
    }
    void release(std::unique_ptr<IButton> btn) {
        pool_.push(std::move(btn));
    }
};

5. 现代C++的改进实现

5.1 使用concept约束工厂

C++20风格：

cpp复制template<typename T>
concept GUIProduct = requires {
    { T::render() } -> std::same_as<void>;
};

template<GUIProduct T>
std::unique_ptr<T> createProduct();

5.2 变体工厂实现

基于std::variant：

cpp复制using AnyProduct = std::variant<
    std::unique_ptr<IButton>,
    std::unique_ptr<ITextbox>
>;

class VariantFactory {
public:
    AnyProduct create(const std::string& type) {
        if(type == "button") return createButton();
        // ...
    }
};

5.3 编译期工厂

利用constexpr：

cpp复制template<Platform P>
constexpr auto createFactory() {
    if constexpr (P == Platform::Windows) 
        return WinFactory{};
    else 
        return MacFactory{};
}

6. 测试方案设计

6.1 模拟对象测试

使用Google Mock：

cpp复制class MockButton : public IButton {
public:
    MOCK_METHOD(void, render, (), (override));
    MOCK_METHOD(void, onClick, (), (override));
};

TEST(GUITest, ButtonRender) {
    MockButton btn;
    EXPECT_CALL(btn, render()).Times(1);
    btn.render();
}

6.2 性能基准测试

Google Benchmark示例：

cpp复制static void BM_FactoryCreate(benchmark::State& state) {
    WinFactory factory;
    for(auto _ : state) {
        auto btn = factory.createButton();
        benchmark::DoNotOptimize(btn);
    }
}
BENCHMARK(BM_FactoryCreate);

6.3 异常安全测试

强制注入异常：

cpp复制class FaultyButton : public IButton {
    void render() override {
        throw std::runtime_error("模拟渲染失败");
    }
};

TEST(FailureTest, ExceptionSafety) {
    ASSERT_THROW(FaultyButton{}.render(), std::runtime_error);
}

7. 实际项目应用案例

7.1 游戏引擎中的资源管理

Unreal Engine风格的实现：

cpp复制class UMaterialFactory : public UFactory {
    UPROPERTY()
    TSubclassOf<UMaterial> MaterialClass;
    
    UMaterial* Create() override {
        return NewObject<UMaterial>(MaterialClass);
    }
};

7.2 金融系统中的交易接口

多交易所适配案例：

cpp复制class IExchangeFactory {
public:
    virtual std::unique_ptr<IOrderAPI> createOrderAPI() = 0;
    virtual std::unique_ptr<IMarketDataAPI> createMarketDataAPI() = 0;
};

class BinanceFactory : public IExchangeFactory {
    // 实现币安接口
};

7.3 物联网设备抽象层

跨设备通信示例：

cpp复制class IDeviceFactory {
public:
    virtual std::unique_ptr<ISensor> createSensor() = 0;
    virtual std::unique_ptr<IActuator> createActuator() = 0;
};

class ModbusFactory : public IDeviceFactory {
    // 实现Modbus协议设备
};

8. 设计模式组合应用

8.1 结合建造者模式

复杂对象构造：

cpp复制class UIBuilder {
    IGUIFactory& factory_;
public:
    explicit UIBuilder(IGUIFactory& f) : factory_(f) {}
    
    std::unique_ptr<UIComponent> build() {
        auto comp = std::make_unique<UIComponent>();
        comp->addButton(factory_.createButton());
        comp->addTextbox(factory_.createTextbox());
        return comp;
    }
};

8.2 组合原型模式

对象克隆优化：

cpp复制class PrototypeFactory : public IGUIFactory {
    std::unique_ptr<IButton> protoButton_;
public:
    std::unique_ptr<IButton> createButton() override {
        return protoButton_->clone();
    }
};

8.3 策略模式动态切换

运行时配置：

cpp复制class DynamicFactory {
    std::function<std::unique_ptr<IButton>()> btnStrategy_;
public:
    void setButtonStrategy(auto&& strat) {
        btnStrategy_ = std::forward<decltype(strat)>(strat);
    }
    std::unique_ptr<IButton> createButton() {
        return btnStrategy_();
    }
};

9. 源码工程化建议

9.1 目录结构规范

推荐布局：

code复制gui_framework/
├── include/
│   ├── factories/
│   │   ├── IGUIFactory.h
│   │   ├── WinFactory.h
│   │   └── MacFactory.h
│   └── products/
│       ├── IButton.h
│       └── ITextbox.h
└── src/
    ├── factories/
    └── products/

9.2 现代构建系统

CMake配置示例：

cmake复制add_library(gui_framework STATIC
    src/factories/WinFactory.cpp
    src/products/WinButton.cpp
    # ...
)

target_include_directories(gui_framework PUBLIC
    ${CMAKE_CURRENT_SOURCE_DIR}/include
)

9.3 文档生成规范

Doxygen注释示例：

cpp复制/**
 * @brief 抽象GUI工厂接口
 * @ingroup factories
 * 
 * 该接口定义了创建跨平台UI组件的通用方法
 */
class IGUIFactory {
    // ...
};

10. 性能调优实战

10.1 内存分配优化

自定义内存池：

cpp复制class ButtonMemoryPool {
    static constexpr size_t POOL_SIZE = 100;
    std::array<std::byte, sizeof(WinButton)*POOL_SIZE> buffer_;
    std::stack<void*> freeList_;
    
public:
    ButtonMemoryPool() {
        for(size_t i=0; i<POOL_SIZE; ++i) {
            freeList_.push(buffer_.data() + i*sizeof(WinButton));
        }
    }
    
    void* allocate() {
        auto ptr = freeList_.top();
        freeList_.pop();
        return ptr;
    }
    
    void deallocate(void* p) {
        freeList_.push(p);
    }
};

10.2 缓存友好设计

数据局部性优化：

cpp复制class GUIBatch {
    std::vector<std::unique_ptr<IButton>> buttons_;
    std::vector<std::unique_ptr<ITextbox>> textboxes_;
    
public:
    void renderAll() {
        // 连续内存访问
        for(auto& btn : buttons_) btn->render();
        for(auto& txt : textboxes_) txt->draw();
    }
};

10.3 异步加载方案

后台预加载：

cpp复制class AsyncFactory {
    std::future<std::unique_ptr<IButton>> createButtonAsync() {
        return std::async(std::launch::async, []{
            return std::make_unique<WinButton>();
        });
    }
};

11. 跨平台开发技巧

11.1 条件编译处理

平台检测宏：

cpp复制#if defined(_WIN32)
    using NativeFactory = WinFactory;
#elif defined(__APPLE__)
    using NativeFactory = MacFactory;
#endif

auto factory = std::make_unique<NativeFactory>();

11.2 系统API封装

统一接口层：

cpp复制class PlatformAPI {
public:
    virtual void* createNativeWindow() = 0;
    // ...
};

// Windows实现
class WinAPI : public PlatformAPI {
    void* createNativeWindow() override {
        // 调用CreateWindowEx...
    }
};

11.3 资源管理策略

平台特定资源：

cpp复制class IResourceLoader {
public:
    virtual std::vector<char> loadBinary(const std::string& path) = 0;
};

class WinResourceLoader : public IResourceLoader {
    std::vector<char> loadBinary(const std::string& path) override {
        // 使用Win32文件API...
    }
};

12. 设计模式对比分析

12.1 与工厂方法对比

关键差异：

特性	抽象工厂	工厂方法
产品维度	多个相关产品族	单个产品类型
扩展性	增加新产品族容易	增加新产品类型容易
典型应用	跨平台UI系统	日志记录器

12.2 与建造者模式对比

协同关系：

抽象工厂：关注产品族创建
建造者：关注复杂对象构造过程
常见组合：用抽象工厂创建组件，用建造者组装

12.3 与原型模式对比

适用场景：

抽象工厂：需要严格控制产品类型
原型模式：需要动态克隆现有对象

13. 可测试性设计

13.1 依赖注入方案

构造函数注入：

cpp复制class Client {
    std::shared_ptr<IGUIFactory> factory_;
public:
    explicit Client(std::shared_ptr<IGUIFactory> f) 
        : factory_(std::move(f)) {}
};

13.2 模拟对象配置

测试专用工厂：

cpp复制class MockFactory : public IGUIFactory {
public:
    MOCK_METHOD(std::unique_ptr<IButton>, createButton, (), (override));
};

13.3 契约测试验证

接口一致性测试：

cpp复制template<typename T>
void testFactoryContract() {
    T factory;
    auto btn = factory.createButton();
    ASSERT_TRUE(dynamic_cast<IButton*>(btn.get()));
}

14. 安全考量

14.1 防止注入攻击

输入验证：

cpp复制std::unique_ptr<IProduct> SafeFactory::create(const std::string& type) {
    const std::set<std::string> validTypes = {"button", "textbox"};
    if(!validTypes.count(type)) throw InvalidProductType();
    // ...
}

14.2 线程安全工厂

双重检查锁：

cpp复制IGUIFactory& getFactory() {
    static IGUIFactory* instance = nullptr;
    static std::mutex mtx;
    
    if(!instance) {
        std::lock_guard<std::mutex> lock(mtx);
        if(!instance) {
            instance = createPlatformFactory();
        }
    }
    return *instance;
}

14.3 异常安全保证

RAII包装：

cpp复制class FactoryHandle {
    std::unique_ptr<IGUIFactory> factory_;
public:
    explicit FactoryHandle(std::unique_ptr<IGUIFactory> f) 
        : factory_(std::move(f)) {}
    ~FactoryHandle() {
        if(factory_) factory_->cleanup();
    }
};

15. 扩展性设计

15.1 插件式架构

动态加载：

cpp复制class PluginFactory : public IGUIFactory {
    std::vector<std::shared_ptr<IPlugin>> plugins_;
public:
    void loadPlugin(const std::string& path) {
        auto plugin = std::make_shared<DllPlugin>(path);
        plugins_.push_back(plugin);
    }
};

15.2 元编程扩展

CRTP应用：

cpp复制template<typename Derived>
class FactoryExtension : public IGUIFactory {
    std::unique_ptr<IButton> createButton() override {
        return static_cast<Derived*>(this)->createConcreteButton();
    }
};

class ExtendedFactory : public FactoryExtension<ExtendedFactory> {
    friend class FactoryExtension<ExtendedFactory>;
    std::unique_ptr<IButton> createConcreteButton() {
        return std::make_unique<FancyButton>();
    }
};

15.3 配置驱动工厂

JSON配置示例：

json复制{
    "factories": {
        "windows": "WinFactory.dll",
        "mac": "MacFactory.dylib"
    }
}

16. 调试技巧

16.1 工厂追踪日志

调试输出：

cpp复制class LoggingProxy : public IGUIFactory {
    IGUIFactory& realFactory_;
public:
    std::unique_ptr<IButton> createButton() override {
        std::cout << "Creating button...";
        auto btn = realFactory_.createButton();
        std::cout << "Done\n";
        return btn;
    }
};

16.2 对象生命周期追踪

自定义删除器：

cpp复制template<typename T>
struct DebugDeleter {
    void operator()(T* p) {
        std::cout << "Deleting " << typeid(T).name() << "\n";
        delete p;
    }
};

using DebugButtonPtr = std::unique_ptr<IButton, DebugDeleter<IButton>>;

16.3 运行时类型检查

dynamic_cast验证：

cpp复制void validateButton(IButton* btn) {
    if(auto winBtn = dynamic_cast<WinButton*>(btn)) {
        // Windows特有操作
    }
}

17. 代码生成优化

17.1 模板元编程

编译期工厂：

cpp复制template<typename Factory>
auto createUI() {
    Factory f;
    return std::make_pair(f.createButton(), f.createTextbox());
}

17.2 宏辅助生成

减少样板代码：

cpp复制#define DECLARE_PRODUCT(name) \
    class name : public I##name { \
    public: \
        void render() override; \
    }

DECLARE_PRODUCT(Button);
DECLARE_PRODUCT(Textbox);

17.3 IDE代码模板

CLion模板示例：

code复制live template: af_interface
template text:
class I$NAME$ {
public:
    virtual ~I$NAME$() = default;
    $END$
};

18. 质量保证措施

18.1 静态分析集成

CLang-Tidy配置：

yaml复制Checks: >
    modernize-*,
    -modernize-use-trailing-return-type,
    cppcoreguidelines-*
WarningsAsErrors: true

18.2 单元测试覆盖

GTest示例：

cpp复制TEST(AbstractFactory, InterfaceIntegrity) {
    static_assert(std::is_abstract_v<IGUIFactory>);
    static_assert(std::has_virtual_destructor_v<IGUIFactory>);
}

18.3 性能回归测试

基准对比：

cpp复制BENCHMARK_TEMPLATE(BM_FactoryCreate, WinFactory);
BENCHMARK_TEMPLATE(BM_FactoryCreate, MacFactory);

19. 团队协作规范

19.1 代码审查要点

检查清单：

所有工厂接口是否包含虚析构函数
产品类是否实现了全部纯虚方法
是否使用了智能指针管理生命周期
跨平台代码是否有条件编译保护

19.2 文档编写标准

接口文档要求：

markdown复制## `IGUIFactory`

**职责**：创建跨平台UI组件的抽象工厂

### 方法
- `createButton()`: 创建平台特定的按钮实例
  - **返回**：`std::unique_ptr<IButton>`
  - **异常**：可能抛出`FactoryCreationError`

19.3 分支策略

Git工作流：

code复制feature/
  abstract_factory/
    impl/      # 实现代码
    tests/     # 单元测试
    docs/      # 设计文档

20. 演进路线规划

20.1 短期优化

引入对象池减少内存分配
添加移动语义支持
完善异常处理体系

20.2 中期规划

支持动态插件加载
实现配置驱动工厂选择
集成性能监控系统

20.3 长期愿景

代码生成工具链
AI驱动的自动工厂适配
量子计算环境适配

21. 替代方案评估

21.1 基于配置的方案

yaml复制# ui_factories.yaml
windows:
  button: WinButton
  textbox: WinTextbox
mac:
  button: MacButton
  textbox: MacTextbox

21.2 服务定位器模式

全局访问点：

cpp复制class ServiceLocator {
    static std::map<std::type_index, void*> services_;
public:
    template<typename T>
    static T& get() {
        return *static_cast<T*>(services_[typeid(T)]);
    }
};

21.3 依赖注入容器

自动化装配：

cpp复制ContainerBuilder builder;
builder.registerType<WinFactory>().as<IGUIFactory>();
auto container = builder.build();
auto factory = container.resolve<IGUIFactory>();

22. 硬件加速集成

22.1 GPU加速渲染

工厂扩展：

cpp复制class GPUButton : public IButton {
    void render() override {
        glDrawElements(GL_TRIANGLES, ...);
    }
};

class GPUFactory : public IGUIFactory {
    std::unique_ptr<IButton> createButton() override {
        return std::make_unique<GPUButton>();
    }
};

22.2 多核并行创建

任务分发：

cpp复制class ParallelFactory {
    std::unique_ptr<IButton> createButton() {
        return parallel_execute([]{
            return std::make_unique<WinButton>();
        });
    }
};

22.3 内存映射优化

零拷贝设计：

cpp复制class SharedMemoryButton : public IButton {
    void* sharedMem_;
public:
    explicit SharedMemoryButton(void* mem) : sharedMem_(mem) {}
};

23. 领域特定语言

23.1 内部DSL示例

流畅接口：

cpp复制auto ui = UIBuilder::create()
    .withFactory<WinFactory>()
    .addButton()
    .addTextbox()
    .build();

23.2 外部DSL集成

解析器示例：

cpp复制class UIDSLParser {
    std::unique_ptr<IGUIFactory> parse(const std::string& script) {
        // 解析DSL生成对应工厂
    }
};

23.3 代码生成器

模板引擎：

cpp复制template<typename Factory>
std::string generateCode() {
    return fmt::format(R"(
        class {0}Button : public IButton {{
        public:
            void render() override {{ /* {0} specific */ }}
        }};)", Factory::name());
}

24. 历史兼容方案

24.1 遗留系统适配

适配器模式：

cpp复制class LegacyButtonAdapter : public IButton {
    LegacyButton* legacyBtn_;
public:
    void render() override {
        legacyBtn_->draw();
    }
};

24.2 版本化接口

多版本支持：

cpp复制class IFactoryV2 : public IFactoryV1 {
public:
    virtual std::unique_ptr<ITouchControl> createTouchControl() = 0;
};

24.3 废弃API处理

弃用标记：

cpp复制class [[deprecated]] OldFactory : public IGUIFactory {
    // ...
};

25. 行业最佳实践

25.1 Google编码规范

遵循要点：

工厂接口类以"Interface"后缀命名
禁用protected数据成员
所有虚函数必须明确override

25.2 Microsoft实现模式

推荐实践：

使用COM风格QueryInterface
实现引用计数
支持聚合

25.3 游戏行业技巧

性能优化：

预生成对象池
使用数据导向设计
避免虚函数调用热路径

26. 工具链集成

26.1 CLion智能提示

配置技巧：

xml复制<template name="factory" value="class $NAME$Factory : public IFactory {&#10;public:&#10;    std::unique_ptr&lt;IProduct&gt; create() override {&#10;        return std::make_unique&lt;$NAME$Product&gt;();&#10;    }&#10;};" />

26.2 Visual Studio调试

Natvis可视化：

xml复制<DisplayString>{{ {IFactory} }}</DisplayString>
<Expand>
    <Item Name="[type]">Interface</Item>
</Expand>

26.3 编译加速方案

预编译头：

cpp复制// stdafx.h
#include <memory>
#include <string>
#include <vector>

27. 持续集成方案

27.1 GitHub Actions

工作流示例：

yaml复制jobs:
  build:
    steps:
      - run: cmake -B build -DUSE_ABSTRACT_FACTORY=ON
      - run: cmake --build build --target test_factories

27.2 代码覆盖率

LCOV集成：

bash复制gcovr --exclude-unreachable-branches --xml-pretty -o coverage.xml

27.3 静态分析

SonarQube配置：

properties复制sonar.cxx.file.suffixes=.cpp,.h
sonar.cxx.abstractfactory.interface=.*I[A-Z][a-zA-Z]*

28. 设计模式反模式

28.1 过度设计警告

典型症状：

只有单一产品类型却用抽象工厂
工厂仅有一个具体实现
产品之间无实际关联

28.2 生命周期问题

常见错误：

工厂析构时产品仍在使用
跨DLL边界内存管理
循环引用导致泄漏

28.3 性能陷阱

优化建议：

避免高频创建销毁
警惕虚函数调用开销
注意缓存一致性

29. 未来演进方向

29.1 异构计算支持

GPU工厂示例：

cpp复制class CudaFactory : public IGUIFactory {
    std::unique_ptr<IButton> createButton() override {
        return std::make_unique<CudaButton>();
    }
};

29.2 AI智能生成

神经网络应用：

python复制# 训练模型预测最佳工厂
model.predict(features, target_factory='WinFactory')

29.3 量子计算适配

Qubit抽象：

cpp复制class QuantumButton : public IButton {
    Qubit& qubit_;
public:
    void render() override {
        qubit_.applyGate(Hadamard);
    }
};

30. 完整实现源码

30.1 核心接口定义

IFactory.h：

cpp复制#pragma once
#include <memory>

class IButton {
public:
    virtual ~IButton() = default;
    virtual void render() = 0;
    virtual void onClick() = 0;
};

class ITextbox {
public:
    virtual ~ITextbox() = default;
    virtual void draw() = 0;
    virtual void setText(const std::string&) = 0;
};

class IGUIFactory {
public:
    virtual ~IGUIFactory() = default;
    virtual std::unique_ptr<IButton> createButton() = 0;
    virtual std::unique_ptr<ITextbox> createTextbox() = 0;
};

30.2 Windows实现

WinFactory.h：

cpp复制#pragma once
#include "IFactory.h"

class WinButton : public IButton {
public:
    void render() override;
    void onClick() override;
};

class WinTextbox : public ITextbox {
public:
    void draw() override;
    void setText(const std::string&) override;
};

class WinFactory : public IGUIFactory {
public:
    std::unique_ptr<IButton> createButton() override;
    std::unique_ptr<ITextbox> createTextbox() override;
};

WinFactory.cpp：

cpp复制#include "WinFactory.h"
#include <iostream>

void WinButton::render() {
    std::cout << "Render Windows style button\n";
    // Win32 API calls...
}

std::unique_ptr<IButton> WinFactory::createButton() {
    return std::make_unique<WinButton>();
}

// 其他实现类似...

30.3 macOS实现

MacFactory.h：

cpp复制#pragma once
#include "IFactory.h"

class MacButton : public IButton {
public:
    void render() override;
    void onClick() override;
};

class MacTextbox : public ITextbox {
public:
    void draw() override;
    void setText(const std::string&) override;
};

class MacFactory : public IGUIFactory {
public:
    std::unique_ptr<IButton> createButton() override;
    std::unique_ptr<ITextbox> createTextbox() override;
};

30.4 客户端示例

main.cpp：

cpp复制#include "IFactory.h"
#include "WinFactory.h"
#include "MacFactory.h"
#include <memory>

class Application {
    std::unique_ptr<IGUIFactory> factory_;
public:
    explicit Application(std::unique_ptr<IGUIFactory> f) 
        : factory_(std::move(f)) {}
    
    void run() {
        auto btn = factory_->createButton();
        auto txt = factory_->createTextbox();
        
        btn->render();
        txt->draw();
    }
};

int main() {
#ifdef _WIN32
    auto app = Application(std::make_unique<WinFactory>());
#else
    auto app = Application(std::make_unique<MacFactory>());
#endif
    app.run();
}

30.5 CMake构建配置

CMakeLists.txt：

cmake复制cmake_minimum_required(VERSION 3.15)
project(AbstractFactoryDemo)

set(CMAKE_CXX_STANDARD 17)

add_library(GUIFramework STATIC
    src/IFactory.cpp
    src/WinFactory.cpp
    src/MacFactory.cpp
)

add_executable(Demo
    src/main.cpp
)

target_link_libraries(Demo PRIVATE GUIFramework)

if(WIN32)
    target_compile_definitions(GUIFramework PRIVATE _WIN32)
endif()

31. 性能优化补充

31.1 内存池实现

ObjectPool.h：

cpp复制template<typename T, size_t BlockSize = 1024>
class ObjectPool {
    struct Block {
        std::array<T, BlockSize> objects;
        std::bitset<BlockSize> used;
    };
    std::list<Block> blocks_;
    
public:
    template<typename... Args>
    T* construct(Args&&... args) {
        for(auto& block : blocks_) {
            for(size_t i=0; i<BlockSize; ++i) {
                if(!block.used[i]) {
                    block.used[i] = true;
                    return new (&block.objects[i]) T(std::forward<Args>(args)...);
                }
            }
        }
        blocks_.emplace_back();
        return construct(args...);
    }
    
    void destroy(T* obj) {
        for(auto& block : blocks_) {
            if(obj >= &block.objects[0] && obj < &block.objects[BlockSize]) {
                size_t index = obj - &block.objects[0];
                block.used[index] = false;
                obj->~T();
                return;
            }
        }
        throw std::runtime_error("Object not from pool");
    }
};

31.2 缓存优化策略

数据局部性示例：

cpp复制class UIComponentCache {
    std::vector<std::byte> buffer_;
    size_t buttonOffset_;
    size_t textboxOffset_;
    
public:
    UIComponentCache() {
        buffer_.resize(sizeof(WinButton) + sizeof(WinTextbox));
        buttonOffset_ = 0;
        textboxOffset_ = sizeof(WinButton);
    }
    
    IButton* getButton() {
        return reinterpret_cast<IButton*>(buffer_.data() + buttonOffset_);
    }
    
    ITextbox* getTextbox() {
        return reinterpret_cast<ITextbox*>(buffer_.data() + textboxOffset_);
    }
};

31.3 并行创建加速

OpenMP应用：

cpp复制class ParallelUILoader {
    std::vector<std::unique_ptr<IButton>> buttons_;
    std::vector<std::unique_ptr<ITextbox>> textboxes_;
    
public:
    void load(size_t count) {
        buttons_.resize(count);
        textboxes_.resize(count);
        
        #pragma omp parallel for
        for(int i=0; i<count; ++i) {
            buttons_[i] = factory_->createButton();
            textboxes_[i] = factory_->createTextbox();
        }
    }
};

32. 异常处理增强

32.1 创建失败处理

异常安全工厂：

cpp复制std::unique_ptr<IButton> SafeFactory::createButton() {
    try {
        auto btn = impl_->createButton();
        if(!btn) throw FactoryCreationError("Null button");
        return btn;
    } catch(const std::bad_alloc&) {
        throw FactoryCreationError("Memory allocation failed");
    }
}

32.2 资源清理保障

RAII包装器：

cpp复制class FactoryResource {
    IGUIFactory& factory_;
    std::unique_ptr<IButton> btn_;
    std::unique_ptr<ITextbox> txt_;
    
public:
    explicit FactoryResource(IGUIFactory& f) 
        : factory_(f),
          btn_(f.createButton()),
          txt_(f.createTextbox()) {}
          
    ~FactoryResource() {
        try {
            btn_->cleanup();
            txt_->cleanup();
        } catch(...) {
            // 记录日志但避免异常传播
        }
    }
};

32.3 错误码替代方案

状态感知接口：

cpp复制class StatusFactory {
public:
    struct Result {
        std::unique_ptr<IButton> button;
        std::error_code ec;
    };
    
    Result createButton() noexcept {
        try