创建型设计模式之工厂模式

简单工厂：通过一个工厂类集中管理对象的创建逻辑，将对象的创建与使用解耦，特点->静态创建方法

工厂方法：将对象的创建逻辑延迟到子类中实现。通过定义抽象工厂接口和具体工厂子类，每个工厂子类负责创建特定的产品对象，实现解耦对象创建与使用

抽象工厂：创建一组相关或依赖的对象（产品族），而无需指定其具体类。它通过定义 抽象工厂接口 和 具体工厂实现，确保产品族内对象的 兼容性 和 一致性

#include <iostream>
#include <mutex>
#include <string>
using namespace std;

/*-----------------------------------------------------------简单工厂------------------------------------------------------------------*/
class Product // 先将产品抽象出来
{
public:
    virtual ~Product() {}; // 析构函数必须是虚函数，这样在析构的时候，才会把子类也析构了
    virtual void operation() = 0;
};

class ProductA : public Product // 具体产品A
{
public:
    void operation() override
    {
        std::cout << "generate product a" << '\n';
    }

    ProductA()
    {
        std::cout << "A" << '\n';
    }

    ~ProductA()
    {
        std::cout << "~A" << '\n';
    }
};

class ProductB : public Product // 具体产品B
{
public:
    void operation() override
    {
        std::cout << "generate product b" << '\n';
    }

    ProductB()
    {
        std::cout << "B" << '\n';
    }

    ~ProductB()
    {
        std::cout << "~B" << '\n';
    }
};

class SimpleFactory : public ProductA, public ProductB
{
public:
    static Product *generate_product(string &product_type) // 利用参数控制工厂
    {
        if ("A" == product_type)
        {
            return new ProductA;
        }
        else if ("B" == product_type)
        {
            return new ProductB;
        }
        else
        {
            return nullptr;
        }
    }
};
/*-----------------------------------------------------------工厂方法------------------------------------------------------------------*/
class Document // 将产品抽象出来
{
public:
    virtual ~Document() = default; // 析构函数必须是虚函数，这样在析构的时候，才会把子类也析构了
    virtual void serialize() const = 0;
};

class PdfDocument : public Document // 具体pdf产品
{
public:
    void serialize() const override
    {
        cout << "PdfDocument serialize" << '\n';
    }
};

class TxtDocument : public Document // 具体TXT产品
{
public:
    void serialize() const override
    {
        cout << "TxtDocument serialize" << '\n';
    }
};

class Factor // 将工厂抽象出来
{
public:
    virtual ~Factor() = default; // 析构函数必须是虚函数，这样在析构的时候，才会把子类也析构了
    virtual Document *CreateDocument() const = 0;
    void work()
    {
        auto ptr = CreateDocument();
        ptr->serialize();
    }
};

class PdfFactor : public Factor // 具体PDF工厂
{
    Document *CreateDocument() const override
    {
        return new PdfDocument;
    }
};

class TxtFactor : public Factor // 具体TXT工厂
{
    Document *CreateDocument() const override
    {
        return new TxtDocument;
    }
};

/*-----------------------------------------------------------抽象工厂------------------------------------------------------------------*/
class Button // 抽象一个产品Button
{
public:
    virtual ~Button() = default; // 析构函数必须是虚函数，这样在析构的时候，才会把子类也析构了
    virtual void render() = 0;
};

class TextBox // 抽象一个产品TextBox
{
public:
    virtual ~TextBox() = default;
    virtual void render() = 0;
};

class WindowsButton : public Button // 具体产品WindowsButton
{
public:
    void render() override
    {
        cout << "WindowsButton" << '\n';
    }
};

class WindowsTextBox : public TextBox // 具体产品WindowsTextBox
{
public:
    void render() override
    {
        cout << "WindowsTextBox" << '\n';
    }
};

class GuiFactory // 抽象工厂
{
public:
    virtual ~GuiFactory() = default; // 析构函数必须是虚函数，这样在析构的时候，才会把子类也析构了
    virtual WindowsButton *CreateGuiButton() = 0;
    virtual WindowsTextBox *CreateGuiTextBox() = 0;
};

class WindowsFactory : public GuiFactory // 具体工厂
{
public:
    WindowsButton *CreateGuiButton()
    {
        return new WindowsButton;
    }

    WindowsTextBox *CreateGuiTextBox()
    {
        return new WindowsTextBox;
    }
};

int main(int argc, char *argv[])
{
    /*简单工厂*/
    string type = "A";
    Product *pa = SimpleFactory::generate_product(type);
    type = "B";
    Product *pb = SimpleFactory::generate_product(type);

    /*工厂方法*/
    Factor *pdf = new PdfFactor;
    pdf->work();

    Factor *txt = new TxtFactor;
    txt->work();

    /*抽象工厂*/
    GuiFactory *pfactory = new WindowsFactory;
    WindowsButton *wb = pfactory->CreateGuiButton();
    WindowsTextBox *wt = pfactory->CreateGuiTextBox();
    wb->render();
    wt->render();
    return 0;
}