Strategy模式

Strategy模式和Template模式要解决的问题是相同的，都是为了给业务逻辑具体实现和抽象接口之间的解耦。

Strategy模式将逻辑封装到一个类里面，通过组合的方式将具体算法的实现在组合对象中实现，再通过委托的方式将抽象接口的实现委托给组合对象实现。

Strategy.h

//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

//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

//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

//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 "Strategy.h"
#include "Context.h"

#include <iostream>
using namespace std;


int main(){
	Strategy* ps = new ConcreteStrategyA();

	Context* pc = new Context(ps);
	pc->DoAction();

	if (NULL != pc)
		delete pc;

    return 0;
}

可以看到，Strategy模式和Template模式实际上是实现一个抽象接口的两种方式：继承和组合之间的区别。

继承和组合各有优缺点：

1、继承：

优点：1）易于修改和扩展被复用的实现；

缺点：1）破坏了封装性，继承中父类的实现细节暴露给了子类；

2）“白盒”复用

3）当父类的实现更改时，其所有子类将不得不随之改变

4）从父类继承而来的实现在运行期间不能改变

2、组合：

优点：1）“黑盒”复用，因为被包含对象的内部细节对外是不可见的

2）封装性好

3）实现和抽象的依赖性很小

4）可以在运行期间动态定义实现

缺点：

1）系统对象过多