C++设计模式——简单工厂模式与策略模式比较

简单工厂模式本应该放到工厂模式那篇博客中去介绍的，因为与策略模式有一定的相似性，这里摘出来单独成章。

简单工厂模式

用一个单独的类来做创造实例的过程，就是工厂。

基本代码

#include <iostream>
using namespace std;

class AbstractProduct {
public:
    virtual ~AbstractProduct() {} 
    virtual void Operation() = 0;
};

class ProductA : public AbstractProduct {
public:
    void Operation() { cout << "ProductA" << endl; }
};

class ProductB : public AbstractProduct {
public:
    void Operation() { cout << "ProductB" << endl; }
};

class Factory {
public:
    AbstractProduct* createProduct(char product) {
        AbstractProduct* ap = NULL;
        switch(product) {
            case 'A': ap = new ProductA(); break;
            case 'B': ap = new ProductB(); break;
        }
        return ap;
    }
};

int main() {
    Factory* f = new Factory();
    AbstractProduct* apa = f->createProduct('A');
    apa->Operation();  // ProductA

    AbstractProduct* apb = f->createProduct('B');
    apb->Operation();  // ProductB

    delete apa;
    delete apb;
    delete f;

    return 0;
}

简单运算工厂

class OperationFactory
{
public:
    Operation createOperate(string operate)
    {
        Operation oper = null;
        switch (operate)
        {
        case "+":
            oper = new OperationAdd();
            break;
        case "-":
            oper = new OperationSub();
            break;
        case "*":
            oper = new OperationMul();
            break;
        case "/":
            oper = new OperationDiv();
            break;
        }
        return oper;
    }
};

简单工厂模式和策略模式的比较

看到这个UML图回想一下之前学习过的策略模式

二者好像差不多？

唯一不同的就是简单工厂类和 Context类。

转载自https://blog.csdn.net/zwj_jyzl/article/details/80869905

原博客是用Java实现的，由于并不影响阅读与理解，在这里直接拷贝过来，没有做修改

简单工厂类和Context类中代码的区别

简单工厂类：

public class OperationFactory
{
    public static Operation CreateOperate (string operate)
    {
        Operation oper=null;   
        switch (operate)
        {
            case "+":
                oper = new OperationAdd();
                break;
            case "-":
                oper = new OperationSub();
                break;
            case "*":
                oper = new OperationMul();
                break;
            case "/":
                oper = new OperationDiv();
                break;
            default:
                oper = new Operation();
                break;
        }
        return oper;
    }
}

策略模式中的Context类：

class Context
{
    CashSuper csuper;
    public Context(CashSuper cs)
    {
        this.csuper = cs;
    }
    public double GetResult(double money)
    {
        //调用具体策略类的收费方法
        return csuper.acceptCash(money);
    }
}

1.首先看一下接收的参数：简单工厂类中的 CreateOperate 方法接收的是字符串，返回的是一个 Operation 对象；而 Context 类初始化时需要接收一个 CashSuper 对象。
2.简单工厂类中是根据接收的条件创建一个相应的对象，而 Context 类接收的是一个对象，可以调用方法去执行此对象的方法。
总结简单工厂模式和策略模式

1.从类型上说：简单工厂模式属于创建型模式，而策略模式属于行为型模式。
2.接下来，看一个小例子：

斧子有很多种，有一个工厂专门负责生产各种需求的斧子。

    工厂模式：
    1）根据你给出的目的来生产不同用途的斧子，例如要砍人，那么工厂生产砍人斧子，要伐木就生产伐木斧子。
    2）即根据你给出一些属性来生产不同行为的一类对象返回给你。
    3）关注对象创建
    策略模式：
    1）用工厂生产的斧子来做对应的事情，例如用砍人的斧子来砍人，用伐木的斧子来伐木。
    2）即根据你给出对应的对象来执行对应的方法。
    3）关注行为的选择

3.简单工厂模式：根据客户选择的条件，来帮客户创建一个对象。
策略模式：客户给它一个创建好的对象，它来帮客户做相应的事。
两种模式的优缺点

首先来看一下两种模式的客户端代码：

//简单工厂模式的客户端：
Operation op;
//交给简单工厂类创建对象
op = OperationFactory.CreateOperate("+");
op.StrNumberA = 10;
op.StrNumberB = 20;
//调用生成对象的方法
double result = op.GetResult();
Console.WriteLine(result);

//策略模式的客户端：
double total = 0;
private void btnOk_Click(object sender, EventArgs e)
{
    CashContext cc = null;
    //客户端自己创建对象
    switch(cbxType.SelectedItem.ToString())
    {
        case: "正常收费":
            cc = new CashContext(new CashNormal());
            break;
        case: "满300返100":
            cc = new CashContext(new CashReturn());
            break;  
        case: "打8折":
            cc = new CashContext(new CashRebate());
            break;  
    }
    //计算具体策略收取的费用，交给context类执行相应的方法，客户端只需要接收返回的值就可以
    double acceptMoney = cc.GetResult(Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text));
    //计算总费用
    total += acceptMoney;
    listBox1.Items.Add("单价：" + txtPrice.Text + " 数量：" + txtNum.Text + " " + comboBox1.SelectedItem.ToString() + "总计：" + acceptMoney);
    lblResult.Text = total.ToString();
}

扫描二维码关注公众号，回复： 10776073 查看本文章

通过比较客户端的代码发现：
简单工厂模式：将对象的选择创建交给了简单工厂类，客户端只需要输入相应的条件就可以，不用负责对象的创建，但是需要客户端自己调用算法类的方法。但是一旦需要增加新的运算类，比如开根运算，就要去修改简单工厂类。
策略模式：对象的选择创建仍需要自己来做，但是将调用方法的职责交给了Context类。一旦需要增加新的策略需要修改客户端。

因此，简单工厂模式的缺点就是当有新的需求增加时，需要频繁的修改工厂类。只用策略模式，当有新的需求增加时需要修改的是客户端，客户端仍然承担着创建对象的职责，并没有减轻客户端的压力。而将这两种模式结合起来使用，则需要修改 Context 类，总之不是完美的。