总结 ：

个人理解：
工厂方法模式就是在简单工程模式的基础下将工厂类抽象出来。如果不抽象工厂类 ，每一次创建一个新的算法，都要修改原来的工厂类，这不符合 开放–封闭原则
将工厂类给抽象出来，让具体的算法去实现一个工厂 ，然后工厂内部添加算法的具体实现。这样就能不影响原来的类。 比如加法工厂去继承工厂类 ，然后我们直接去调用加法工厂然后创建相关的操作。

定义工厂方法模式

定义一个用于创建对象的接口。让子类决定实例化那一个类。工厂方法是一个类的实例化延迟到其子类

原来的简单工厂模式就可以写成下面的架构：

以后修改代码的时候 也不用去修改原来的工厂类 而是直接去声明其子类（具体的工厂） 新的添加不会影响其他的子类
修改后的代码

#include <iostream>  
#include <memory> // 引入智能指针的头文件  

using namespace std;

// 操作基类  
class Operate {
public:
    Operate() {}
    virtual ~Operate() {}

    virtual int GetResult() = 0; // 纯虚函数，强制派生类实现  
    void  SetNumsA(int A)
    {
        NumsA = A;
    }
    void SetNumsB(int B)
    {
        NumsB = B;
    }
protected:
    int NumsA, NumsB;
};

// 加法操作类  
class AddOperate : public Operate {
public:
    int GetResult() override {
        return NumsA + NumsB;
    }
};

// 减法操作类  
class SubOperate : public Operate {
public:
    int GetResult() override {
        return NumsA - NumsB;
    }
};

// 乘法操作类  
class MulOperate : public Operate {
public:
    int GetResult() override {
        return NumsA * NumsB;
    }
};

// 除法操作类  
class DivOperate : public Operate {
public:
    int GetResult() override {
        if (NumsB == 0) {
            throw runtime_error("Division by zero is not allowed.");
        }
        return NumsA / NumsB;
    }
};
//工厂基类
class IFactory {
public:
    virtual std::unique_ptr<Operate> CreateOperation() = 0;
};
//加法工厂类
class AddFactory : public IFactory
{
public:
    std::unique_ptr<Operate> CreateOperation() override {
        return std::make_unique<AddOperate>();
    }
};
//减法工厂类
class SubFactory : public IFactory
{
public:
    std::unique_ptr<Operate> CreateOperation() override {
        return std::make_unique<SubOperate>();
    }
};
//乘法工厂类
class MulFactory : public IFactory
{
public:
    std::unique_ptr<Operate> CreateOperation() override {
        return std::make_unique<MulOperate>();
    }
};
//除法工厂类
class DivFactory : public IFactory
{
public:
    std::unique_ptr<Operate> CreateOperation() override {
        return std::make_unique<DivOperate>();
    }
};



int main() {
    try {
        AddFactory factory;
        std::unique_ptr<Operate> operate = factory.CreateOperation();
        operate->SetNumsA(100);
        operate->SetNumsB(200);

        cout << operate->GetResult() << endl;
    }
    catch (const exception& e) {
        cout << "Error: " << e.what() << endl;
    }

    return 0;
}