设计模式（一）策略模式

1、什么是策略模式？

　　策略模式，又叫算法簇模式，就是定义了不同的算法簇，并且之间可以互相替换，此模式算法的变化独立于使用算法的客户。

2、策略模式有什么好处？

　　策略模式的好处在于你可以动态改变对象的行为。

3、设计原则

　　设计原则是把一个类中经常改变或者将来改变的部分提取出来，作为一个接口（C++中可以用抽象类），然后在类中包含这个对象的实例，这样类的实例在运行时就可以随意调用实现这个接口的类的行为。

　　策略模式属于对象行为型模式，主要针对一组算法，将每一个算法封装到具有共同接口（C++中即为抽象基类）的独立的类中，从而使得他们可以相互替换。策略模式使得算法可以在不影响客户端的情况下发生变化。

4、策略模式中有三个对象：

　　（1）环境对象：该类中实现了对抽象策略中定义的接口或者抽象类的引用。

　　（2）抽象策略对象：它可由接口或者抽象类来实现。

　　（3）具体策略对象：它封装了实现不同功能的不同算法。

5、适用性

　　当存在以下情况时，使用策略模式

　　（1）“策略”提供一种用多个行为中的一个行为来配置一个类的方法。即一个系统需要动态地在几种算法中选择一种。

　　（2）需要使用一个算法的不同变体。例如，你可能会定义一些反应不同的空间/时间权衡的算法。当这些变体实现为一个算法的类层次时，可以使用策略模式。

　　（3）算法使用了客户不应该知道的数据。可使用策略模式以避免暴露复杂的、与算法相关的数据结构。　

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

6、结构

　　

7、应用场景举例：

　　刘备要到江东娶老婆了，走之前诸葛亮给赵云（伴郎）三个锦囊妙计，说是按天机拆开能解决棘手问题，嘿，还别说，真解决了大问题，搞到最后是周瑜陪了夫人又折兵，那咱们先看看这个场景是什么样子的。

　　先说说这个场景中的要素：三个妙计，一个锦囊，一个赵云，妙计是亮哥给的，妙计放在锦囊里，俗称就是锦囊妙计嘛，那赵云就是一个干活的人，从锦囊取出妙计，执行，然后获胜。

　　先来看看图。

　　

　　解释：

　　main(),赵云

　　CContext,锦囊

　　CStrategy,策略抽象类

　　CBackDoor,策略之一

　　CGivenGreenLight,策略之二

　　CBlockEnemy,策略之三

　　说明：一个策略放到一个锦囊里。当用的时候，找到这个锦囊，从锦囊里拿出策略来使用。

　　注意：锦囊只是简单的装载和调用策略，锦囊里没有逻辑。策略会有更大的自主权，运行更多的逻辑。

　　代码：

　　三个策略继承自抽象类CStrategy，首先是CStrategy类的定义：

#ifndef    _STRATEGY_H_
#define    _STRATEGY_H_
class CStrategy{
public:
    CStrategy(void){};
    virtual ~CStrategy(void){};
    virtual void Operate(void) = 0;//纯虚函数，这样每个继承自CStrategy的类都可以实现一个自身的Operate()函数，即实现各自的策略
};
#endif

　　然后再写三个实现类，因为有三个策略：

　　妙计一：初到吴国：

　　BackDoor.h

#ifndef        _BACKDOOR_H_
#define        _BACKDOOR_H_
#include "Strategy.h"
class CBackDoor :public CStrategy{
public:
    CBackDoor(void);
    ~CBackDoor(void);
    void Operate(void);
};
#endif

　　BackDoor.cpp

#include "BackDoor.h"
#include <iostream>
using namespace std;
//构造函数
CBackDoor::CBackDoor(void)
{
    
}

//析构函数
CBackDoor::~CBackDoor(void)
{
    
}

void CBackDoor::Operate(void)
{
    cout << "找乔国老帮忙，让吴国太给孙权施压" << endl;
}

　　

　　妙计二：求吴国太开绿灯，放行：

　　GivenGreenLight.h

#ifndef        _GIVENGREENLIGHT_H_
#define        _GIVENGREENLIGHT_H_
#include "Strategy.h"

class CGivenGreenLight:public CStrategy{
public:
    CGivenGreenLight(void);
    ~CGivenGreenLight(void);
    void Operate(void);
};
#endif

　　GivenGreenLight.cpp

#include "GivenGreenLight.h"
#include <iostream>
using namespace std;

CGivenGreenLight::CGivenGreenLight(void)
{

}

CGivenGreenLight::~CGivenGreenLight(void)
{

}

void CGivenGreenLight::Operate(void)
{
    cout << "求吴国太开个绿灯，放行！" << endl;
}

　　妙计三：孙夫人断后，挡住追兵：

　　BlockEnemy.h

#ifndef        _BLOCKENEMY_H_
#define        _BLOCKENEMY_H_
#include "Strategy.h"
class CBlockEnemy :public CStrategy{
public:
    CBlockEnemy(void);
    ~CBlockEnemy(void);
    void Operate(void);

};
#endif

　　BlockEnemy.cpp

#include "BlockEnemy.h"
#include <iostream>
using namespace std;

CBlockEnemy::CBlockEnemy(void)
{

}

CBlockEnemy::~CBlockEnemy(void)
{

}

void CBlockEnemy::Operate(void)
{
    cout << "孙夫人断后，挡住追兵" << endl;
}

　　好了，三个妙计是有了，还需要一个地方放妙计，即锦囊：

　　Context.h

#ifndef        _CONTEXT_H_
#define        _CONTEXT_H_
#include "Strategy.h"
//定义环境（锦囊）存策略
class CContext{
public:
    CContext(CStrategy* pStrategy);
    ~CContext(void);
    void Operate(void);
private:
    CStrategy* m_pStrategy;
};
#endif

　　Context.cpp

#include "Context.h"
//构造函数中传入具体的策略，使用抽象基类CStrategy指针类型
//指向策略
//CStrategy中的Operate()函数定义为纯虚函数，如此可实现多态：在不同的类中使用不同的operate()函数
CContext::CContext(CStrategy* pStrategy)
{
    this->m_pStrategy = pStrategy;
}
//析构函数
CContext::~CContext(void)
{
    delete this->m_pStrategy;    //销毁CStrategy类指针
}

//操作具体的策略
void CContext::Operate(void)
{
    this->m_pStrategy->Operate();
}

　　然后就是赵云护送刘备去娶亲了。看看执行过程吧。

　　excute.cpp

#include <iostream>
#include <tchar.h>
#include "Context.h"
#include "BackDoor.h"
#include "GivenGreenLight.h"
#include "BlockEnemy.h"
using namespace std;

int _tmain(int argc, _TCHAR** argv)
{
    //定义一个CContext类的指针
    CContext* pContext;

    cout << "



" << endl;
    cout << "----------刚刚到吴国的时候拆第一个----------" << endl;
    //使用关键字new在堆上动态创建一个对象
    /*
    它实际上做了三件事：
    获得一块内存空间
    调用构造函数
    返回正确的指针。
    */
    pContext = new CContext(new CBackDoor);
    pContext->Operate();
    /*
    delete时做了两件事：
    1、调用 pContext指向对象的析构函数，对打开的文件进行关闭。
    2、释放该对象的内存
    */
    delete pContext;

    cout << "



" << endl;
    cout << "----------刘备乐不思蜀了，拆第二个了----------" << endl;
    pContext = new CContext(new CGivenGreenLight);
    pContext->Operate();
    delete pContext;

    cout << "



" << endl;
    cout << "----------孙权的小兵追了，咋办？拆第三个----------" << endl;
    pContext = new CContext(new CBlockEnemy);
    pContext->Operate();
    delete pContext;

    /*
    _CrtSetDbgFlag:
        检索或修改 _crtDbgFlag 标志的状态，以控制调试堆管理器的分配行为
    _CRTDBG_ALLOC_MEM_DF:
        启用调试堆分配并使用内存块类型标识符，例如 _CLIENT_BLOCK。
    _CRTDBG_LEAK_CHECK_DF:
        在程序退出时通过对 _CrtDumpMemoryLeaks 的调用执行自动泄露检查，如果应用程序无法释放它分配的所有内存，则生成错误报告。
    */
    _CrtSetDbgFlag(-_CRTDBG_ALLOC_MEM_DF || _CRTDBG_LEAK_CHECK_DF);
    _CrtDumpMemoryLeaks();
    getchar();
    return 0;

}

　　运行结果：

　　

　8、总结与分析

　　（1）策略模式是一个比较容易理解和使用的设计模式，策略模式是对算法的封装，它把算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法封装到一系列的策略里面，作为一个抽象策略类的子类。用一句话来说，就是“准备一组算法，并将每一个算法封装起来，使得他们可以互换。”

　　（2）在策略模式中，应该由客户端自己决定在什么情况下使用什么具体策略。

　　（3）策略模式仅仅封装算法，提供新算法插入到已有系统中，以及老算法从系统中“退休”的方便，策略模式并不决定在何时使用何种算法，算法的选择由客户端决定。这在一定成都上提高了系统的灵活性，但是客户端需要理解所有具体策略类之间的区别，以便选择合适的算法，这也是策略模式的缺点之一，在一定程度上增加了客户端的使用难度。