简单工厂,工厂方法 和 抽象工厂

这三种模式， 都是创建类型的模式， 将对象的创建流程封装起来供客户调用

简单工厂模式

简介: 和策略模式一样，就是针对不通的参数， 返回不通的实例而已
问题: 没有遵循开闭原则， 如果我们想增加一种类， 那么就要修改工厂的核心代码，这违反了对修改关闭的原则, 于是有了 工厂方法模式

策略模式和简单工厂模式的代码用例

class Operator
{
public:int first, second;Operator() {};Operator(int a, int b) : first(a), second(b) {};virtual int get_result() = 0;
};class AddOperator : public Operator
{
public:AddOperator() {};AddOperator(int a, int b) : Operator(a, b) {};int get_result() override{return first + second;}
};class MulOperator : public Operator
{
public:MulOperator() {};MulOperator(int a, int b) : Operator(a, b) {};int get_result() override{return first * second;}
};// strategy
int get_result(char _type, int a, int b)
{Operator* o{};if (_type == '+')o = new AddOperator(a, b);if (_type == '*')o = new MulOperator(a, b);return o->get_result();
}// simple factory
class OperatorFactory
{
public:Operator* get_operator(char c){Operator* o{};if (c == '+')o = new AddOperator();if (c == '*')o = new MulOperator();return o;}
};int main()
{//策略模式int a = get_result('+', 1, 2);cout << a << endl;int b = get_result('*', 8, 9);cout << b << endl;// 简单工厂模式OperatorFactory* op_factory = new OperatorFactory();Operator* o = op_factory->get_operator('+');o->first = 1;o->second = 2;cout << o->get_result() << endl;
}

工厂方法模式

简介: 在简单工厂的基础上，遵循开闭原则, 每个工厂都只产出自己的类， 那么再有新的类要加入的时候， 我们只需要添加一个工厂子类 和 目标子类就行了
问题: 工厂只能产出一种目标类的实例, 这样的话, 系统中类一多, 工厂就会太多.
`代码``

class Operator
{
public:int first, second;Operator() {};Operator(int a, int b) : first(a), second(b) {};virtual int get_result() = 0;
};class AddOperator : public Operator
{
public:AddOperator() {};AddOperator(int a, int b) : Operator(a, b) {};int get_result() override{return first + second;}
};class MulOperator : public Operator
{
public:MulOperator() {};MulOperator(int a, int b) : Operator(a, b) {};int get_result() override{return first * second;}
};class Factory
{
public:virtual Operator* get_operator(int a, int b) = 0;
};class AddFactory : public Factory
{
public:Operator* get_operator(int a, int b) override{Operator* op = new AddOperator(a, b);return op;}
};class MulFactory : public Factory
{
public:Operator* get_operator(int a, int b) override{Operator* op = new MulOperator(a, b);return op;}
};int main()
{// 工厂方法模式AddFactory* add_f = new AddFactory();Operator* op = add_f->get_operator(1, 2);cout << op->get_result() << endl;
}

抽象工厂模式

简介: 一个工厂产出一系列互相关联的类的实例, 实现产品簇的效果
代码

class SoftWare
{
public:SoftWare() {};
};class AndroidSoftWare : public SoftWare
{
public:AndroidSoftWare() {};
};class IosSoftWare : public SoftWare
{
public:IosSoftWare() {};
};class Phone
{
public:SoftWare* ware;virtual void set_soft_ware(SoftWare* ware) = 0;
};class XiaoMiPhone : public Phone
{
public:void set_soft_ware(SoftWare* w) override{cout << "xiao mi phone set android soft ware" << endl;ware = w;}
};class IosPhone : public Phone
{
public:void set_soft_ware(SoftWare* w) override{cout << "ios phone set ios soft ware" << endl;ware = w;}
};// 这种情况下, 用抽象工厂模式, 就不会出错, 不会出现iosphone配上了android soft ware的情况
// 不然在实际项目中, 配错很可能会出现严重后果
class AbstractFactory
{
public:virtual Phone* create_phone() = 0;virtual SoftWare* create_soft_ware() = 0;
};class XiaoMiFactory : public AbstractFactory
{Phone* create_phone() override{Phone* p = new XiaoMiPhone();return p;}SoftWare* create_soft_ware() override{SoftWare* sw = new AndroidSoftWare();return sw;}
};class IosFactory : public AbstractFactory
{Phone* create_phone() override{Phone* p = new IosPhone();return p;}SoftWare* create_soft_ware() override{SoftWare* sw = new IosSoftWare();return sw;}
};
int main()
{// 很多情况下, 工厂不止是生产一种类, 而是生产一整套互相关联的类, 这样一个工厂, 就是抽象工厂模式AbstractFactory* af = new XiaoMiFactory();Phone* p1 = af->create_phone();SoftWare* sw = af->create_soft_ware();p1->set_soft_ware(sw);af = new IosFactory();Phone* p2 = af->create_phone();SoftWare* sw2 = af->create_soft_ware();p2->set_soft_ware(sw2);
}