工厂模式~

1. 简单工厂

         它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。在简单工厂模式中，增加新的产品需要修改工厂类，这违反了开闭原则（对扩展开放，对修改封闭）。

class Product {
public:
    virtual void Operation() = 0;
};

class ConcreteProductA : public Product {
public:
    void Operation() override {
        // 实现A产品的操作
    }
};

class ConcreteProductB : public Product {
public:
    void Operation() override {
        // 实现B产品的操作
    }
};

class SimpleFactory {
public:
    static Product* CreateProduct(const std::string& type) {
        if (type == "A") {
            return new ConcreteProductA();
        } else if (type == "B") {
            return new ConcreteProductB();
        }
        return nullptr;
    }
};

2. 工厂方法

        所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类

class Product {
public:
    virtual void Operation() = 0;
};

class ConcreteProductA : public Product {
public:
    void Operation() override {
        // 实现A产品的操作
    }
};

class ConcreteProductB : public Product {
public:
    void Operation() override {
        // 实现B产品的操作
    }
};

class Creator {
public:
    virtual Product* FactoryMethod() = 0;
};

class ConcreteCreatorA : public Creator {
public:
    Product* FactoryMethod() override {
        return new ConcreteProductA();
    }
};

class ConcreteCreatorB : public Creator {
public:
    Product* FactoryMethod() override {
        return new ConcreteProductB();
    }
};

3. 抽象工厂

        抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

class AbstractProductA {
public:
    virtual void OperationA() = 0;
};

class AbstractProductB {
public:
    virtual void OperationB() = 0;
};

class ConcreteProductA1 : public AbstractProductA {
public:
    void OperationA() override {
        // 实现产品A1的操作
    }
};

class ConcreteProductA2 : public AbstractProductA {
public:
    void OperationA() override {
        // 实现产品A2的操作
    }
};

class ConcreteProductB1 : public AbstractProductB {
public:
    void OperationB() override {
        // 实现产品B1的操作
    }
};

class ConcreteProductB2 : public AbstractProductB {
public:
    void OperationB() override {
        // 实现产品B2的操作
    }
};

class AbstractFactory {
public:
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};

class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() override {
        return new ConcreteProductA1();
    }

    AbstractProductB* CreateProductB() override {
        return new ConcreteProductB1();
    }
};

class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() override {
        return new ConcreteProductA2();
    }

    AbstractProductB* CreateProductB() override {
        return new ConcreteProductB2();
    }
};

4. 工厂方法和抽象工厂方法的区别

        先让我们通过比喻来理解一下他们的区别，想象你去了一家快餐店。你可以把“工厂方法”想象成是快餐店里的一个单品菜单（比如只卖汉堡的菜单），而“抽象工厂”则像是套餐菜单，套餐里包含了多个不同的食品（比如汉堡、薯条和可乐）。

工厂方法

        在工厂方法中，每一个"工厂"负责制作一种产品。例如，如果你想要一个汉堡，你会去汉堡工厂；如果你想要一包薯条，你会去薯条工厂。每个工厂都有一个方法来“制作”它专门的产品。

        - 汉堡工厂：制作汉堡的方法。
        - 薯条工厂：制作薯条的方法。

你只能从每个工厂得到一种类型的产品。

抽象工厂

        而在**抽象工厂**中，每一个"工厂"可以制作多种相关的产品。例如，你有一个快餐工厂，这个工厂可以同时制作汉堡、薯条和可乐。

        - 快餐工厂：
          - 制作汉堡的方法。
          - 制作薯条的方法。
          - 制作可乐的方法。

你可以从一个工厂获取一系列相互关联的产品。

        总体来说，就是

   工厂方法：一种工厂对应一种产品。它是一个创建单一产品的方法。

   抽象工厂：一种工厂对应多种产品。它是一个创建产品家族的方法。

        想象一个具体的需求场景可以帮助理解：

          - 如果你在开发一个应用，需要根据不同的操作系统环境创建不同的UI元素，比如按钮和窗口：
          - 使用工厂方法：你会为每种元素（按钮、窗口）创建一个工厂，每个工厂负责创建在不同操作系统中该元素的具体实例。
          - 使用抽象工厂：你会创建一个工厂，这个工厂能够创建所有需要的UI元素（按钮、窗口），并且这些元素在不同操作系统中有不同的实现。以下是按钮的代码例子。

        4.1 工厂方法模式

        在工厂方法模式中，我们为每种产品定义了一个创建方法。假设我们有两种类型的UI元素：`Button`和`Window`，我们将为每种元素创建一个工厂。

#include <iostream>
#include <string>

// "Product"抽象类
class Button {
public:
    virtual ~Button()    virtual std::string Draw() const = 0;
};

// "ConcreteProduct" 类
class WindowsButton : public Button {
public:
    std::string Draw() const override {
        return "Drawing Windows button";
    }
};

class LinuxButton : public Button {
public:
    std::string Draw() const override {
        return "Drawing Linux button";
    }
};

// "Creator" 抽象类
class ButtonFactory {
public:
    virtual ~ButtonFactory()    virtual Button* CreateButton() const = 0;
};

// "ConcreteCreator" 类
class WindowsButtonFactory : public ButtonFactory {
public:
    Button* CreateButton() const override {
        return new WindowsButton();
    }
};

class LinuxButtonFactory : public ButtonFactory {
public:
    Button* CreateButton() const override {
        return new LinuxButton();
    }
};

// 客户端代码
void ClientCode(const ButtonFactory& factory) {
    Button* button = factory.CreateButton();
    std::cout << button->Draw() << std::endl;
    delete button;
}

int main() {
    WindowsButtonFactory* windowsFactory = new WindowsButtonFactory();
    ClientCode(*windowsFactory);
    delete windowsFactory;

    LinuxButtonFactory* linuxFactory = new LinuxButtonFactory();
    ClientCode(*linuxFactory);
    delete linuxFactory;
}

        在这个工厂方法模式的示例中，我们有一个 `Button` 产品和两个具体产品 `WindowsButton` 和 `LinuxButton`。`ButtonFactory` 是创建者抽象类，而 `WindowsButtonFactory` 和 `LinuxButtonFactory` 是具体的创建者，它们分别创建不同类型的按钮。

4.2 抽象工厂模式

        抽象工厂模式为一系列相关或相互依赖的对象创建接口，而不指定它们具体的类。抽象工厂允许客户端使用不同的产品系列，而不必依赖于具体类的实例化。

```cpp
#include <iostream>
#include <string>

// 抽象产品类Button
class Button {
public:
    virtual ~Button()    virtual std::string Draw() const = 0;
};

// 抽象产品类Window
class Window {
public:
    virtual ~Window()    virtual std::string Draw() const = 0;
};

// 具体产品类WindowsButton
class WindowsButton : public Button {
public:
    std::string Draw() const override {
        return "Drawing Windows button";
    }
};

// 具体产品类LinuxButton
class LinuxButton : public Button {
public:
    std::string Draw() const override {
        return "Drawing Linux button";
    }
};

// 具体产品类WindowsWindow
class WindowsWindow : public Window {
public:
    std::string Draw() const override {
        return "Drawing Windows window";
    }
};

// 具体产品类LinuxWindow
class LinuxWindow : public Window {
public:
    std::string Draw() const override {
        return "Drawing Linux window";
    }
};

// 抽象工厂类GUIFactory
class GUIFactory {
public:
    virtual ~GUIFactory()    virtual Button* CreateButton() const = 0;
    virtual Window* CreateWindow() const = 0;
};

// 具体工厂类WindowsFactory
class WindowsFactory : public GUIFactory {
public:
    Button* CreateButton() const override {
        return new WindowsButton();
    }
    Window* CreateWindow() const override {
        return new WindowsWindow();
    }
};

// 具体工厂类LinuxFactory
class LinuxFactory : public GUIFactory {
public:
    Button* CreateButton() const override {
        return new LinuxButton();
    }
    Window* CreateWindow() const override {
        return new LinuxWindow();
    }
};

// 客户端代码
void ClientCode(const GUIFactory& factory) {
    Button* button = factory.CreateButton();
    Window* window = factory.CreateWindow();
    std::cout << button->Draw() << std::endl;
    std::cout << window->Draw() << std::endl;
    delete button;
    delete window;
}

int main() {
    WindowsFactory* windowsFactory = new WindowsFactory();
    ClientCode(*windowsFactory);
    delete windowsFactory;

    LinuxFactory* linuxFactory = new LinuxFactory();
    ClientCode(*linuxFactory);
    delete linuxFactory;
}
```

        在这个抽象工厂模式的示例中，`GUIFactory` 是一个可以创建按钮和窗口的抽象工厂。`WindowsFactory` 和 `LinuxFactory` 是具体工厂，它们分别创建Windows风格和Linux风格的按钮和窗口。