总结 :
个人理解:
工厂方法模式就是在简单工程模式的基础下将工厂类抽象出来。如果不抽象工厂类 ,每一次创建一个新的算法,都要修改原来的工厂类,这不符合 开放–封闭原则
将工厂类给抽象出来,让具体的算法去实现一个工厂 ,然后工厂内部添加算法的具体实现。这样就能不影响原来的类。 比如加法工厂去继承工厂类 ,然后我们直接去调用加法工厂然后创建相关的操作。
定义工厂方法模式
定义一个用于创建对象的接口。让子类决定实例化那一个类。工厂方法是一个类的实例化延迟到其子类
原来的简单工厂模式就可以写成下面的架构:
以后修改代码的时候 也不用去修改原来的工厂类 而是直接去声明其子类(具体的工厂) 新的添加不会影响其他的子类
修改后的代码
#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;
}