设计模式-工厂模式

simple factory

优点：
简化客户端代码。
封装了创建对象的过程。
缺点：
如果产品类增加，工厂类也需要修改，违反了开闭原则（Open - Closed Principle）。
工厂类过于复杂，难以维护。
代码示例

class Product
{
public:

    virtual ~Product() {};
};
class ProductA :public Product
{
public:
    ProductA()
    {
        std::cout << "ProductA Concrete" << std::endl;
    }
};
class ProductB :public Product
{
public:
    ProductB()
    {
        std::cout << "ProductB Concrete" << std::endl;
    }

};

class SimpleFactory
{
public:
    static std::unique_ptr<Product> createProduct(int type)
    {
        switch (type)
        {
        case 1:
            return std::make_unique<ProductA>();
        case 2:
            return std::make_unique<ProductB>();
        default:
            throw std::runtime_error("Invalid product type");
        }
    }
};
int main()
{
    auto product = SimpleFactory::createProduct(1);
}

factory method

工厂方法模式是 GoF 设计模式之一，它定义了一个创建对象的接口，但让子类决定实例化哪一个类。工厂方法让类的实例化延迟到子类。
优点
符合开闭原则，当增加新的产品时，无须修改原有的工厂逻辑。解耦合，客户端不需要知道具体的产品类是如何创建的。
缺点
每增加一个产品就需要增加一个相应的类。

class Product
{
public:

    virtual ~Product() {};
};
class ProductA :public Product
{
public:
    ProductA()
    {
        std::cout << "ProductA Concrete" << std::endl;
    }
};
class ProductB :public Product
{
public:
    ProductB()
    {
        std::cout << "ProductB Concrete" << std::endl;
    }

};

class AbstractFactory
{
public:
    virtual std::unique_ptr<Product> createProduct() = 0;
};

class ConcreteFactoryA : public AbstractFactory
{
public:
    std::unique_ptr<Product> createProduct() override
    {
        return std::make_unique<ProductA>();
    }
};

class ConcreteFactoryB : public AbstractFactory
{
public:
    std::unique_ptr<Product> createProduct() override
    {
        return std::make_unique<ProductB>();
    }
};

int main()
{
    auto factory = new ConcreteFactoryA();
    auto product = factory->createProduct();
    // 使用 product
    delete factory;
    return 0;
}

AbstractFactory

抽象工厂模式同样是 GoF 设计模式之一，它提供了一个创建一系列相关或依赖对象的接口，而无需指定它们具体的类。抽象工厂模式比工厂方法模式更进一步，它可以创建一组相关的对象，而不是单一的对象。

优点
当一组相关的对象被设计成一起工作时，它能保证得到一致性的结果。
符合开闭原则，增加新的产品族时，只需增加相应的具体工厂类。
缺点
产品族扩展困难，增加新的产品族需要修改现有代码。

#include <iostream>
#include <memory>

class Button
{
public:
    virtual ~Button() {};
    virtual void paint() {};
};

// 抽象产品类 - TextBox
class TextBox
{
public:
    virtual ~TextBox() {};
    virtual void paint() {};
};

// 具体产品类 - WindowsButton
class WindowsButton : public Button
{
public:
    void paint()  
    {
        std::cout << "Painting Windows Button" << std::endl;
    }
};

// 具体产品类 - MacOSButton
class MacOSButton : public Button
{
public:
    void paint()  
    {
        std::cout << "Painting MacOS Button" << std::endl;
    }
};

// 具体产品类 - WindowsTextBox
class WindowsTextBox : public TextBox
{
public:
    void paint()  
    {
        std::cout << "Painting Windows TextBox" << std::endl;
    }
};
// 具体产品类 - MacOSTextBox
class MacOSTextBox : public TextBox
{
public:
    void paint()  
    {
        std::cout << "Painting MacOS TextBox" << std::endl;
    }
};

// 抽象工厂类 - GUIFactory
class GUIFactory
{
public:
    virtual std::unique_ptr<Button> createButton() const = 0;
    virtual std::unique_ptr<TextBox> createTextBox() const = 0;
};

// 具体工厂类 - WindowsFactory
class WindowsFactory : public GUIFactory
{
public:
    std::unique_ptr<Button> createButton() const override
    {
        return std::make_unique<WindowsButton>();
    }

    std::unique_ptr<TextBox> createTextBox() const override
    {
        return std::make_unique<WindowsTextBox>();
    }
};

// 具体工厂类 - MacOSFactory
class MacOSFactory : public GUIFactory
{
public:
    std::unique_ptr<Button> createButton() const override
    {
        return std::make_unique<MacOSButton>();
    }

    std::unique_ptr<TextBox> createTextBox() const override
    {
        return std::make_unique<MacOSTextBox>();
    }
};

// 客户端代码
void paintGUI(const GUIFactory& factory)
{
    auto button = factory.createButton();
    auto textBox = factory.createTextBox();

    button->paint();
    textBox->paint();
}

int main()
{
    // 创建 Windows 风格的 GUI 组件
    {
        GUIFactory* windowsFactory = new WindowsFactory();
        paintGUI(*windowsFactory);
        delete windowsFactory;
    }

    // 创建 MacOS 风格的 GUI 组件
    {
        GUIFactory* macosFactory = new MacOSFactory();
        paintGUI(*macosFactory);
        delete macosFactory;
    }

    return 0;
}