设计模式 策略模式

1、strategy.h

#ifndef STRATEGY_H
#define STRATEGY_H

#include <iostream>
using namespace std;

class Operation //Strategy,策略基类,所有支持的算法的公共接口
{
public:
    Operation();
    ~Operation();
    virtual void Calculate() = 0;
    virtual int GetResult() = 0;
public:
    int m_nFirst;
    int m_nSecond;
    int m_nResult;
};

class AddOperation : public Operation //ConcreteStrategy,策略具体类—加法类
{
public:
    AddOperation(int a,int b);
    virtual void Calculate();
    virtual int GetResult();
};

class SubOperation : public Operation //ConcreteStrategy,策略具体类—减法类
{
public:
    SubOperation(int a,int b);
    virtual void Calculate();
    virtual int GetResult();
};

//Context，用一个ConcreteStrategy来配置，维护一个Strategy对象的引用，可定义一个接口，让Strategy访问它的数据
class Context
{
private:
    Operation* op;
public:
    Context(Operation* temp);
    ~Context();
    void Calculate();
    int GetResult();
};

#endif // STRATEGY_H

2、strategy.cpp

#include "strategy.h"

Operation::Operation(){}

Operation::~Operation(){}

AddOperation::AddOperation(int a,int b)
{
    m_nFirst=a;
    m_nSecond=b;
}

void AddOperation::Calculate()
{
    m_nResult = m_nFirst+m_nSecond;
}

int AddOperation::GetResult()
{
    return m_nResult;
}

SubOperation::SubOperation(int a,int b)
{
    m_nFirst=a;
    m_nSecond=b;
}

void SubOperation::Calculate()
{
    m_nResult = m_nFirst-m_nSecond;
}

int SubOperation::GetResult()
{
    return m_nResult;
}

Context::Context(Operation* temp)
{
    op=temp;
}

void Context::Calculate()
{
    return op->Calculate();
}

int Context::GetResult()
{
    return op->GetResult();
}

3、main.cpp

/*
作者：jhluroom弹   QQ：454676244  MSN：jhlu0815@hotmail.com
开发IDE：qt creater
开发环境：QT C++
参考网站：神秘果：http://www.shenmiguo.com/

定义：
策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。
策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模式相当于"可插入式（Pluggable）的算法。

理解：
1.每个对象都是一个具有职责的个体。
2.这些职责不同的具体实现是通过多态的使用来完成的。
3.概念上相同的算法具有多个不同的实现，需要进行管理
4.环境（Context）角色：持有一个Strategy类的引用。
  抽象策略（Strategy）角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
  具体策略（ConcreteStrategy）角色：包装了相关的算法或行为。

要点：
1.对策略对象定义一个公共接口。
2.编写策略类，该类实现了上面的公共接口。
3.策略对象的类中保存一个对策略对象的引用。
4.略对象的类中，实现对策略对象的set和get方法。
5.策略模式封装了不同的“算法”，使它们可以在运行时相互替换。它与结构型模式里的装饰模式功能接近，策略模式改变类的行为内核，
  而装饰模式改变类的行为外观。如果类的接口很庞大，那么装饰模式的实现代价就过高，而策略模式仅改变类的内核，可能很小。
  策略模式的实现结构很像状态模式，但它不改变对象的状态。
6.策略模式(Strategy)和简单工厂基本相同，但简单工厂模式只能解决对象创建问题，对于经常变动的算法应使用策略模式。
7.和模板方法模式相比，策略模式的一个明显的好处是在程序运行时，可以插入变化的代码.
8.简单工厂模式是实现对象的多样性，而策略模式适合类中的成员以方法为主；
  简单工厂模式只能解决对象创建问题，对于经常变动的算法应使用策略模式。

应用：
1.类中的成员以方法为主，算法经常变动；
2.简化了单元测试（因为每个算法都有自己的类，可以通过自己的接口单独测试。
本例中应用加法和减法两种策略方法加以实现，如下源码所示：

以上文字说明，从网上整理而来，有可能部分与其他同仁相同，请谅解，希望我们能够共同交流，谢谢！
*/

#include <QtCore/QCoreApplication>

#include "strategy.h"

int main(int argc, char *argv[])
{
    cout << "=== jhluroom start ========" << endl;

    int a = 200;
    int b = 100;

    Context *contextAdd=new Context(new AddOperation(a,b));
    contextAdd->Calculate();
    cout<<"contextAdd-AddOperation:"<<contextAdd->GetResult()<<endl;

    Context *contextSub=new Context(new SubOperation(a,b));
    contextSub->Calculate();
    cout<<"contextAdd-SubdOperation:"<<contextSub->GetResult()<<endl;

    cout << "=== jhluroom finish _^_ ===" << endl;
    return 0;
}

运行结果：
=== jhluroom start ========
contextAdd-AddOperation:300
contextAdd-SubdOperation:100

=== jhluroom finish _^_ ===