策略模式

定义

　　策略模式，又叫算法簇模式，就是定义了不同的算法族，并且之间可以互相替换，此模式让算法的变化独立于使用算法的客户。
　　策略模式的重心不是如何实现算法，而是如何组织、调用这些算法，从而让程序结构更灵活，具有更好的维护性和扩展性。

角色

　　环境类(Context):用一个ConcreteStrategy对象来配置。维护一个对Strategy对象的引用。可定义一个接口来让Strategy访问它的数据。

　　抽象策略类(Strategy):定义所有支持的算法的公共接口。 Context使用这个接口来调用某ConcreteStrategy定义的算法。

　　具体策略类(ConcreteStrategy):以Strategy接口实现某具体算法。

使用场景

　　当存在以下情况时使用Strategy模式

　　1、多个类只区别在表现行为不同。 “策略”提供了一种用多个行为中的一个行为来配置一个类的方法。

　　2、需要使用一个算法的不同变体。

　　3、对客户(Duck)隐藏具体策略(算法)的实现细节，彼此完全独立。

　　4、一个类定义了多种行为 , 且这些行为在该类的操作中以多个条件语句的形式出现。将相关条件分支移入它们各自的Strategy类中以代替这些条件语句。

优缺点

　　对于Strategy模式来说，主要有如下优点：

　　1、  提供了一种替代继承的方法，而且既保持了继承的优点(代码重用)还比继承更灵活(算法独立，可以任意扩展)。

　　2、  避免程序中使用多重条件转移语句，使系统更灵活，并易于扩展。

　　3、  遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。
 

　　对于Strategy模式来说，主要有如下缺点：

　　1、因为每个具体策略类都会产生一个新类，所以会增加系统需要维护的类的数量。

　　2、客户端必须知道所有的策略类，并自行决定使用哪一个策略类:  

与状态模式的比较

　　1、策略模式只是在对象初始化的时候更改执行模式，而状态模式是根据对象实例的周期时间而动态地改变对象实例的执行模式。

　　2、使用策略模式时，客户端需要知道所选的具体策略是哪一个，而使用状态模式时，客户端无须关心具体状态，环境类的状态会根据用户的操作自动转换。

　　3、如果系统中某个类的对象存在多种状态，不同状态下行为有差异，而且这些状态之间可以发生转换时使用状态模式；

　  　　如果系统中某个类的某一行为存在多种实现方式，而且这些实现方式可以互换时使用策略模式。

 

策略模式、简单工厂模式、工厂方法模式、策略模式与工厂模式结合代码比较

　　

　　

　　为了方便比较，将四种模式的代码放到一起，通过同一个例子来说明。

　　

class COperation
{
public:
    int m_nFirst;
    int m_nSecond;

    virtual double GetResult() = 0; 
};
//加法
class AddOperation : public COperation
{
public:
    AddOperation(int a,int b)
    {
        m_nFirst = a;
        m_nSecond = b;
    }
    
    virtual double GetResult()
    {
        return m_nFirst + m_nSecond;
    }
};
//减法
class SubOperation : public COperation
{
public:
    SubOperation(int a,int b)
    {
        m_nFirst = a;
        m_nSecond = b;
    }

    virtual double GetResult()
    {
        return m_nFirst - m_nSecond;
    }
};

/*************************************************/
// 1.策略模式的实现-策略模式的环境类
class Context
{
private:
    COperation* op;
public:
    Context(COperation* temp)
    {
        op = temp;
    }
    double GetResult()
    {
        return op->GetResult();
    }
}
/*************************************************/
// 2.简单工厂模式的实现-简单工厂模式的工厂类
class CCalculatorFactory
{
public:
    static COperation* Create(char cOperator ,int a ,int b);
};

COperation* CCalculatorFactory::Create(char cOperator, int a, int b)
{
    COperation *oper;
    
    switch (cOperator)
    {
    case '+':
        oper=new AddOperation(a, b);
        break;
    case '-':
        oper=new SubOperation(a, b);
        break;
    default:
        break;
    }
    return oper;
}
/*************************************************/
// 3.工厂模式的工厂类
class CCalculatorFactory
{
public:
    virtual COperation* Create(int a, int b) = 0;
};

class AddFactory : public CCalculatorFactory
{

public:
    COperation* Create(int a, int b)
    {
        return new AddOperation(a, b);
    }
};

class SubFactory : public CCalculatorFactory
{
public:
    virtual COperation* Create(int a, int b)
    {
        return new SubOperation(a, b);
    }
};
/*************************************************/
// 4.策略+工厂的实现
class Context
{
private:
    COperation* op;
public:
    Context(char cType, int a, int b)
    {
        switch(cType)
        {
        case '+':
            op = new AddOperation(a, b);
            break;
        case '-':
            op = new SubOperation(a, b);
            break;
        default:
            break;
        }
    } 
    double GetResult()
    {
        return op->GetResult();
    }
};
/*************************************************/

// 客户端
int main()
{
    int a,b;
    cin>>a>>b;
    // 简单工厂模式       
    COperation * op = CCalculatorFactory::Create('-', a, b);
    cout<<op->GetResult()<<endl; 

    // 工厂方法模式
    CCalculatorFactory* p = new AddFactory;
    COperation* op = p->Create(a, b);
    cout<<op->GetResult()<<endl; 

    // 策略模式
    cin>>c;
    Context *context; 
    switch(c)
    {
    case '+':
        context = new Context(new AddOperation(a, b));
        break;
    case '-':
        context = new Context(new SubOperation(a, b));
        break;
    default:
        break;
    }
    cout<<context->GetResult()<<endl; 
    
    // 策略+工厂模式
    Context *context = new Context('+', a, b);
    cout<<context->GetResult()<<endl; 

    return 0; 

}