C++ 设计模式 工厂类设计模式

简单工厂模式

描述：

将系统的逻辑部分和功能部分分离，创建对象的操作由工厂类负责。

缺点：

1. 增加了系统类的个数，一定程度上增加了系统的复杂度。

2. 扩展性差，一旦增加新产品，就需要修改工厂逻辑，不利于系统的扩展与维护。且违背了开闭原则。

代码

#include <iostream>
#include <string>
using namespace std;
//基类
class Operation {
public :
    double A, B;
    virtual double getResult() {
        return 0;
    }
};
//加
class addOperation : public Operation {
    double getResult() {
        return A + B;
    }
};
 
//减
class subOperation : public Operation {
    double getResult() {
        return A - B;
    }
};
//乘
class mulOperation : public Operation {
    double getResult() {
        return A * B;
    }
};
//除
class divOperation : public Operation {
    double getResult() {
        return A / B;
    }
};
//工厂类
class operFactory {
public :
    static Operation *createOperation(char c) {
        switch (c) {
        case '+' :
            return new addOperation;
            break;
 
        case '-' :
            return new subOperation;
            break;
 
        case '*' :
            return new mulOperation;
            break;
 
        case '/' :
            return new divOperation;
            break;
        }
    }
};
 
int main() {
    Operation *oper = operFactory::createOperation('+');
    oper->A = 12;
    oper->B = 13;
    cout << oper->getResult() << endl;
    delete oper;
    return 0;
}

工厂方法模式

描述：定义一个创建对象的接口，让子类决定实例化哪一个类，工厂方法模式使得一个类的实例化延迟（目的：解耦；手段：虚函数）到子类。

缺点：1. 增加了复杂度。2. 要求所有对象的创建方法/参数相同

#include <iostream>
#include <string>
using namespace std;
 
class Operation {
public:
    double A, B;
    virtual double getResult() {
        return 0;
    }
};
//加
class addOperation : public Operation {
    double getResult() {
        return A + B;
    }
};
 
//减
class subOperation : public Operation {
    double getResult() {
        return A - B;
    }
};
//乘
class mulOperation : public Operation {
    double getResult() {
        return A * B;
    }
};
//除
class divOperation : public Operation {
    double getResult() {
        return A / B;
    }
};
 
class IFactory {
public:
    virtual Operation *createOperation() = 0;
};
 
class AddFactory : public IFactory {
public:
    Operation *createOperation() {
        return new addOperation();
    }
};
 
class SubFactory : public IFactory {
public:
    Operation *createOperation() {
        return new subOperation();
    }
};
 
class MulFactory : public IFactory {
public:
    Operation *createOperation() {
        return new mulOperation();
    }
};
 
class DivFactory : public IFactory {
public:
    Operation *createOperation() {
        return new divOperation();
    }
};
 
class Work {
private:
    IFactory* factory;
public:
    Work(IFactory* factory) {
        this->factory = factory;
    }
    virtual ~Work() {
    }
    void calculate(int a, int b) {
        Operation* oper = factory->createOperation();
        oper->A = a;
        oper->B = b;
        cout << oper->getResult() << endl;
        delete oper;
    }
};
 
int main() {
    AddFactory *factory = new AddFactory();
    Work *work = new Work(factory);
    work->calculate(12, 13);
    delete work;
    return 0;
}