工厂模式在C++中怎样应用 抽象工厂与简单工厂实现对比

#include <iostream>
#include <string>
#include <memory> // For std::unique_ptr

// 抽象产品基类
class Product {
public:
    virtual void use() const = 0;
    virtual ~Product() = default;
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void use() const override {
        std::cout << "Using ConcreteProductA." << std::endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void use() const override {
        std::cout << "Using ConcreteProductB." << std::endl;
    }
};

// 简单工厂类
class SimpleProductFactory {
public:
    // 使用智能指针管理内存，避免手动delete
    static std::unique_ptr<Product> createProduct(const std::string& type) {
        if (type == "A") {
            return std::make_unique<ConcreteProductA>();
        } else if (type == "B") {
            return std::make_unique<ConcreteProductB>();
        } else {
            std::cout << "Unknown product type: " << type << std::endl;
            return nullptr;
        }
    }
};

/*
// 客户端代码示例
int main() {
    std::unique_ptr<Product> product1 = SimpleProductFactory::createProduct("A");
    if (product1) {
        product1->use();
    }

    std::unique_ptr<Product> product2 = SimpleProductFactory::createProduct("B");
    if (product2) {
        product2->use();
    }

    std::unique_ptr<Product> product3 = SimpleProductFactory::createProduct("C"); // 尝试创建不存在的产品
    if (product3) {
        product3->use();
    }

    return 0;
}
*/

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

// 抽象产品A (例如：按钮)
class AbstractButton {
public:
    virtual void render() const = 0;
    virtual ~AbstractButton() = default;
};

// 抽象产品B (例如：复选框)
class AbstractCheckbox {
public:
    virtual void check() const = 0;
    virtual ~AbstractCheckbox() = default;
};

// 具体产品：Windows风格的按钮和复选框
class WindowsButton : public AbstractButton {
public:
    void render() const override {
        std::cout << "Rendering Windows Button." << std::endl;
    }
};

class WindowsCheckbox : public AbstractCheckbox {
public:
    void check() const override {
        std::cout << "Checking Windows Checkbox." << std::endl;
    }
};

// 具体产品：Mac风格的按钮和复选框
class MacButton : public AbstractButton {
public:
    void render() const override {
        std::cout << "Rendering Mac Button." << std::endl;
    }
};

class MacCheckbox : public AbstractCheckbox {
public:
    void check() const override {
        std::cout << "Checking Mac Checkbox." << std::endl;
    }
};

// 抽象工厂接口
class AbstractUIFactory {
public:
    virtual std::unique_ptr<AbstractButton> createButton() const = 0;
    virtual std::unique_ptr<AbstractCheckbox> createCheckbox() const = 0;
    virtual ~AbstractUIFactory() = default;
};

// 具体工厂：Windows UI 工厂
class WindowsUIFactory : public AbstractUIFactory {
public:
    std::unique_ptr<AbstractButton> createButton() const override {
        return std::make_unique<WindowsButton>();
    }
    std::unique_ptr<AbstractCheckbox> createCheckbox() const override {
        return std::make_unique<WindowsCheckbox>();
    }
};

// 具体工厂：Mac UI 工厂
class MacUIFactory : public AbstractUIFactory {
public:
    std::unique_ptr<AbstractButton> createButton() const override {
        return std::make_unique<MacButton>();
    }
    std::unique_ptr<AbstractCheckbox> createCheckbox() const override {
        return std::make_unique<MacCheckbox>();
    }
};

/*
// 客户端代码示例
int main() {
    // 使用Windows UI工厂
    std::unique_ptr<AbstractUIFactory> winFactory = std::make_unique<WindowsUIFactory>();
    std::unique_ptr<AbstractButton> winButton = winFactory->createButton();
    std::unique_ptr<AbstractCheckbox> winCheckbox = winFactory->createCheckbox();

    winButton->render();
    winCheckbox->check();

    std::cout << "---" << std::endl;

    // 使用Mac UI工厂
    std::unique_ptr<AbstractUIFactory> macFactory = std::make_unique<MacUIFactory>();
    std::unique_ptr<AbstractButton> macButton = macFactory->createButton();
    std::unique_ptr<AbstractCheckbox> macCheckbox = macFactory->createCheckbox();

    macButton->render();
    macCheckbox->check();

    return 0;
}
*/