16.策略模式--Strategy

 

Strategy模式：
Strategy模式定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。另外，策略模式简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。

Strategy模式和Template模式要解决的问题是相同（类似）的，都是为了给业务逻辑（算法）具体实现和抽象接口之间的解耦。Strategy模式将逻辑（算法）封装到一个类（Context）里面，通过组合的方式将具体算法的实现在组合对象中实现，再通过委托的方式将抽象接口的实现委托给组合对象实现。

Strategy模式典型的结构图为：
 

以《大话设计模式》中商场销售策略为例，商场中有打折策略和返现策略，通过context管理。
Strategy模式的实现代码如下：

//strategy.h
#ifndef _STRATEGY_H_
#define _STRATEGY_H_

// 商场策略
class Strategy
{
public:
    Strategy();
    virtual ~Strategy();
    virtual void AlgrithmInterface() = 0;
protected:
private:
};

// 打折策略
class ConcreteStrategyA:public Strategy
{
public:
    ConcreteStrategyA();
    virtual ~ConcreteStrategyA();
    void AlgrithmInterface();
protected:
private:
};

// 返现策略
class ConcreteStrategyB:public Strategy
{
public:
    ConcreteStrategyB();
    virtual ~ConcreteStrategyB();
    void AlgrithmInterface();
protected:
private:
};
#endif //~_STRATEGY_H_

//Strategy.cpp
#include "Strategy.h"
#include <iostream>
using namespace std;
Strategy::Strategy()
{
}
Strategy::~Strategy()
{
    cout<<"~Strategy....."<<endl;
}
void Strategy::AlgrithmInterface()
{
}
ConcreteStrategyA::ConcreteStrategyA()
{
}
ConcreteStrategyA::~ConcreteStrategyA()
{
    cout<<"~ConcreteStrategyA....."<<endl;
}
void ConcreteStrategyA::AlgrithmInterface()
{
    cout<<"test ConcreteStrategyA.....打折策略"<<endl;
}
ConcreteStrategyB::ConcreteStrategyB()
{
}
ConcreteStrategyB::~ConcreteStrategyB()
{
    cout<<"~ConcreteStrategyB....."<<endl;
}
void ConcreteStrategyB::AlgrithmInterface()
{
    cout<<"test ConcreteStrategyB.....返现策略"<<endl;
}

//Context.h
#ifndef _CONTEXT_H_
#define _CONTEXT_H_
class Strategy;
/**
*这个类是Strategy模式的关键，也是Strategy模式和Template模式的根本区别所在。
*Strategy通过“组合”（委托）方式实现算法（实现）的异构，而Template模式则采取的是继承的方式
*这两个模式的区别也是继承和组合两种实现接口重用的方式的区别
*/
class Context
{
public:
    Context(Strategy* stg);
    ~Context();
    void DoAction();
protected:
private:
    Strategy* _stg;
};
#endif //~_CONTEXT_H_

//Context.cpp
#include "Context.h"
#include "Strategy.h"
#include <iostream>
using namespace std;
Context::Context(Strategy* stg)
{
    _stg = stg;
}
Context::~Context()
{
    if (!_stg)
        delete _stg;
}
void Context::DoAction()
{
    _stg->AlgrithmInterface();
}

//main.cpp
#include "Context.h"
#include "Strategy.h"
#include <iostream>
using namespace std;
int main(int argc,char* argv[])
{
    // 打折策略
    Strategy* ps1 = new ConcreteStrategyA();
    Context* pc1 = new Context(ps1);
    pc1->DoAction();

    // 返现策略
    Strategy* ps2 = new ConcreteStrategyB();
    Context* pc2 = new Context(ps2);
    pc2->DoAction();

    return 0;
}

下面是Template模式和Strategy模式的优缺点对比。
Template模式（继承）的优点：
1）易于修改和扩展那些被复用的实现。
Template模式（继承）的缺点：
1）破坏了封装性，继承中父类的实现细节暴露给子类了；
2）“白盒”复用，原因在1）中；
3）当父类的实现更改时，其所有子类将不得不随之改变
4）从父类继承而来的实现在运行期间不能改变（编译期间就已经确定了）。

Strategy模式（组合）的优点：
1）“黑盒”复用，因为被包含对象的内部细节对外是不可见的；
2）封装性好，原因为1）；
3）实现和抽象的依赖性很小（组合对象和被组合对象之间的依赖性小）；
4）可以在运行期间动态定义实现（通过一个指向相同类型的指针，典型的是抽象基类的指针）。
Strategy模式（组合）的缺点：
1）系统中对象过多。