C++ 抽象工厂模式详解-CSDN博客

本文链接：https://blog.csdn.net/qq_57049935/article/details/147683686

抽象工厂模式是一种创建型设计模式，它提供了一种方式来封装一组具有共同主题的独立工厂，而不需要指定它们的具体类。

概念解析

抽象工厂模式的核心思想是：

提供一个接口用于创建相关或依赖对象的家族，而不需要明确指定具体类
将对象的创建与使用分离
支持产品家族的创建，确保创建的产品是兼容的

主要组成部分

抽象工厂（Abstract Factory）：声明创建抽象产品对象的接口

具体工厂（Concrete Factory）：实现创建具体产品对象的操作

抽象产品（Abstract Product）：为一类产品对象声明接口

具体产品（Concrete Product）：定义具体工厂创建的产品对象，实现抽象产品接口

客户端（Client）：仅使用由抽象工厂和抽象产品类声明的接口

代码示例

#include <iostream>
#include <memory>
#include <string>

// 抽象产品A：按钮接口
class Button {
public:
    virtual void render() = 0;
    virtual void onClick() = 0;
    virtual ~Button() = default;
};

// 抽象产品B：复选框接口
class CheckBox {
public:
    virtual void render() = 0;
    virtual void onCheck() = 0;
    virtual ~CheckBox() = default;
};

// 具体产品A1：Windows按钮
class WindowsButton : public Button {
public:
    void render() override {
        std::cout << "渲染一个Windows风格的按钮" << std::endl;
    }
    
    void onClick() override {
        std::cout << "Windows按钮点击事件处理" << std::endl;
    }
};

// 具体产品A2：MacOS按钮
class MacOSButton : public Button {
public:
    void render() override {
        std::cout << "渲染一个MacOS风格的按钮" << std::endl;
    }
    
    void onClick() override {
        std::cout << "MacOS按钮点击事件处理" << std::endl;
    }
};

// 具体产品B1：Windows复选框
class WindowsCheckBox : public CheckBox {
public:
    void render() override {
        std::cout << "渲染一个Windows风格的复选框" << std::endl;
    }
    
    void onCheck() override {
        std::cout << "Windows复选框选中事件处理" << std::endl;
    }
};

// 具体产品B2：MacOS复选框
class MacOSCheckBox : public CheckBox {
public:
    void render() override {
        std::cout << "渲染一个MacOS风格的复选框" << std::endl;
    }
    
    void onCheck() override {
        std::cout << "MacOS复选框选中事件处理" << std::endl;
    }
};

// 抽象工厂接口
class GUIFactory {
public:
    virtual std::unique_ptr<Button> createButton() = 0;
    virtual std::unique_ptr<CheckBox> createCheckBox() = 0;
    virtual ~GUIFactory() = default;
};

// 具体工厂1：Windows工厂
class WindowsFactory : public GUIFactory {
public:
    std::unique_ptr<Button> createButton() override {
        return std::make_unique<WindowsButton>();
    }
    
    std::unique_ptr<CheckBox> createCheckBox() override {
        return std::make_unique<WindowsCheckBox>();
    }
};

// 具体工厂2：MacOS工厂
class MacOSFactory : public GUIFactory {
public:
    std::unique_ptr<Button> createButton() override {
        return std::make_unique<MacOSButton>();
    }
    
    std::unique_ptr<CheckBox> createCheckBox() override {
        return std::make_unique<MacOSCheckBox>();
    }
};

// 客户端代码
class Application {
private:
    std::unique_ptr<GUIFactory> factory_;
    std::unique_ptr<Button> button_;
    std::unique_ptr<CheckBox> checkbox_;
    
public:
    // 构造函数接收一个抽象工厂
    explicit Application(std::unique_ptr<GUIFactory> factory) 
        : factory_(std::move(factory)) {}
    
    // 创建UI组件
    void createUI() {
        button_ = factory_->createButton();
        checkbox_ = factory_->createCheckBox();
    }
    
    // 渲染UI
    void render() {
        if (button_ && checkbox_) {
            button_->render();
            checkbox_->render();
        }
    }
    
    // 模拟用户交互
    void simulateUserActions() {
        if (button_ && checkbox_) {
            button_->onClick();
            checkbox_->onCheck();
        }
    }
};

// 根据配置创建适当的工厂
std::unique_ptr<GUIFactory> createFactory(const std::string& os_type) {
    if (os_type == "Windows") {
        return std::make_unique<WindowsFactory>();
    } else if (os_type == "MacOS") {
        return std::make_unique<MacOSFactory>();
    }
    throw std::runtime_error("未知的操作系统类型");
}

int main() {
    std::cout << "请选择操作系统类型 (Windows/MacOS): ";
    std::string os_type;
    std::cin >> os_type;
    
    try {
        // 创建对应操作系统的工厂
        auto factory = createFactory(os_type);
        
        // 创建应用并配置工厂
        Application app(std::move(factory));
        
        // 创建UI
        app.createUI();
        
        // 渲染UI
        app.render();
        
        // 模拟用户交互
        app.simulateUserActions();
    } catch (const std::exception& e) {
        std::cerr << "错误: " << e.what() << std::endl;
        return 1;
    }
    
    return 0;
}