C++设计模式（十一） strategy模式

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

UML:



这里的关键就是将算法的逻辑抽象接口（DoAction）封装到一个类中（Context），再

通过委托的方式将具体的算法实现委托给具体的Strategy类来实现（ConcreteStrategeA/B

类）。这里可以看出template和strategy模式的关键区别：template模式采用的是继承的方式二strategy模式采用的是组合的方式，所以通过设置一定的属性，我们可以改变context提供的接口的实现，而template则失去了这种灵活性。

strategy.h

#ifndef STRATEGY_H_
#define STRATEGY_H_
class Strategy
{
public:
virtual ~Strategy();
virtual void ArlgorithInterface()=0;
protected:
Strategy();
};
class ConcreteStrategy1:public Strategy
{
public:
ConcreteStrategy1();
virtual void ArlgorithInterface();
virtual ~ConcreteStrategy1();
};
class ConcreteStrategy2:public Strategy
{
public:
ConcreteStrategy2();
virtual void ArlgorithInterface();
virtual ~ConcreteStrategy2();
};
#endif

strategy.cpp

#include<iostream>
#include "strategy.h"
using namespace std;
Strategy::Strategy()
{
cout<<"constructor Strategy"<<endl;
}
Strategy::~Strategy()
{
cout<<"deconstructor strategy"<<endl;
}
void Strategy::ArlgorithInterface()
{
cout<<"Strategy::algorithInterface()"<<endl;
}
ConcreteStrategy1::ConcreteStrategy1()
{
cout<<"constructor ConcreteStrategy1"<<endl;
}
ConcreteStrategy1::~ConcreteStrategy1()
{
cout<<"deconstructor concreteStrategy1"<<endl;
}
void ConcreteStrategy1::ArlgorithInterface()
{
cout<<"ConcreteStrategy1::ArlgorithInterface()"<<endl;
}
ConcreteStrategy2::ConcreteStrategy2()
{
cout<<"constructor ConcreteStrategy2"<<endl;
}
ConcreteStrategy2::~ConcreteStrategy2()
{
cout<<"deconstructor concreteStrategy2"<<endl;
}
void ConcreteStrategy2::ArlgorithInterface()
{
cout<<"ConcreteStrategy2::ArlgorithInterface()"<<endl;
}

context.h

</mce:script><mce:script type="text/javascript" src="http://hi.images.csdn.net/js/blog/tiny_mce/plugins/syntaxhl/langs/zh.js" mce_src="http://hi.images.csdn.net/js/blog/tiny_mce/plugins/syntaxhl/langs/zh.js"></mce:script>pp">#ifndef CONTEXT_H_
#define CONTEXT_H_
#include "strategy.h"
class Context
{
private:
Strategy* pStrategy;
public:
void doAction();
Context(Strategy* pStrategy);
virtual ~Context();
};
#endif

context.cpp

#include<iostream>
#include "context.h"
using namespace std;
Context::Context(Strategy* pStrategy)
{
cout<<"constructor context"<<endl;
this->pStrategy=pStrategy;
}
Context::~Context()
{
cout<<"deconstructor context"<<endl;
}
void Context::doAction()
{
cout<<"Begin Context::doAction()"<<endl;
pStrategy->ArlgorithInterface();
cout<<"End Context::doAction()"<<endl;
}

main.cpp

#include<iostream>
#include "context.h"
using namespace std;
int main(int argv,char** argc)
{
Strategy* pStrategy=new ConcreteStrategy1();
Context* pContext=new Context(pStrategy);

pContext->doAction();
delete pStrategy;
delete pContext;
return 0;
}

策略(Strategy)模式体现了2个重要的面向对象设计原则：
1.封装变化。
2.针对接口编程。