Strategy模式

Strategy模式

Strategy模式要解决的问题和Template模式相似，都是为了把算法的声明和算法的实现解耦．Template模式是通过继承来实现的，而Strategy模式是通过组合来实现的．

Strategy模式将算法封装到一个类(Context)里面，通过组合的方式将算法在组合的对象中实现，之后通过委托将抽象接口委托给组合对象来实现．其类结构图如下

实现：

//Strategy.h

//Strategy.h

class Strategy
{
public:
    virtual void PrimitiveOperation() = 0;
    virtual ~Strategy();
protected:
    Strategy();
};

class ConcreteStrategy1 :public Strategy
{
public:
    ConcreteStrategy1();
    ~ConcreteStrategy1();
    void PrimitiveOperation();
};
class ConcreteStrategy2 :public Strategy
{
public:
    ConcreteStrategy2();
    ~ConcreteStrategy2();
    void PrimitiveOperation();
};

//Strategy.cpp

//Strategy.cpp

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

Strategy::Strategy()
{}
Strategy::~Strategy()
{}

ConcreteStrategy1::ConcreteStrategy1()
{}
ConcreteStrategy1::~ConcreteStrategy1()
{}
void ConcreteStrategy1::PrimitiveOperation()
{
    cout << "ConcreteStrategy1 PrimitiveOperation()" << endl;
}

ConcreteStrategy2::ConcreteStrategy2()
{}
ConcreteStrategy2::~ConcreteStrategy2()
{}
void ConcreteStrategy2::PrimitiveOperation()
{
    cout << "ConcreteStrategy2 PrimitiveOperation()" << endl;
}

//Context.h

//Context.h

#ifndef _CONTEXT_H_
#define _CONTEXT_H_

class Strategy;

class Context
{
public:
    Context(Strategy*);
    ~Context();
    void DoAction();

private:
    Strategy* _strategy;
};

#endif

//Context.cpp

//Context.cpp

#include"Context.h"
#include"Strategy.h"

Context::Context(Strategy* strategy)
{
    _strategy = strategy;
}
Context::~Context()
{
    delete _strategy;
}
void Context::DoAction()
{
    _strategy->PrimitiveOperation();
}

//main.cpp

//main.cpp

#include"Context.h"
#include"Strategy.h"

int main()
{
    Strategy* p1 = new ConcreteStrategy1();
    Strategy* p2 = new ConcreteStrategy2();
    Context* c1 = new Context(p1);
    Context* c2 = new Context(p2);
    c1->DoAction();
    c2->DoAction();
    return 0;
}

可以看出Template是通过继承来实现接口，而Strategy模式是通过组合来实现．这两种方式各有优缺点．

继承：优点是易于扩展和修改那些被复用的实现．
缺点有：１）破坏了封装，继承父类的实现细节暴露给子类了．２）＂白盒＂复用，因为１）．３）父类实现更改时，所有子类不得不随之改变．４）从父类继承而来的实现在运行期间不能被改变(编译期间已经确定了)．

组合：优点：１）＂黑盒＂复用，封装性好．２）实现和抽象的依赖性低，因为组合对象和被组合对象之间的依赖性很小．３）可以在运行期间修改，例如通过更改指针指向的对象．

缺点就是系统对象过多．