设计模式之策略模式

1.意图

根据GOF的定义：定义一系列的算法或操作，并把它们一个个封装起来，并且使它们可以互换替换。以达到算法与业务独立开发的目的。

简单的说就是针对某个业务需求，抽象出解决问题的算法的一个个方法，然后实现封装不同的特定的算法(通过集成抽象类或接口)，在客户端需要使用这个算法的时候开业方便的替换就OK了，做到算法操作与业务逻辑解耦，降低了维护成本和易拓展。

2.动机

有时候对于某个问题会有多种的解决算法，但是如果在这个解决问题的类中定义多种的算法，会使这个类膨胀，拥有了一些不需要的属性和方法，这时没必要的，会使得类很难维护。

不用把所有的算法都塞进类中，只要在需要的时候替换上对应的算法类就ok了。

如果把算法实现集成到业务类中时会造成在增加新的算法的时候，需要修改此类，违背了设计原则-开闭原则，在开发中，一般是对原有代码封闭，对拓展开放的思想。

因此，通过以上的动机，策略模式就应运而生了。

3.模式结构与角色定义

策略模式的结构也比较简单。主要涉及到继承与委托两种关系，算法抽象，具体算法继承算法抽象类并实现算法，根据面向接口编程，Strategy委托给Context上下文，客户端调用到对应算法的时候，直接把对应的算法动态的赋给Context上下文就OK了。

Strategy：
1.算法的抽象类或接口。抽象出算法的一个个方法，主要被算法具体类继承实现。
ConcreteStrategyA/B/C:
1.算法的具体类。继承算法抽象类，实现算法。
Context：
1.拥有Strategy的引用，有对应的接口调用算法。

客户端在调用算法的使用，主要是借助Context(其实就是一个委托类，用来调用对应的算法的)，直接调用对应的算法，把业务与算法解耦。

4.应用场景

许多相关的类只是算法实现细节有异。策略提供了一种用多个算法中的一个算法来配置一个类的方法。
针对某个问题有多种算法，不同时候可能使用不同的算法，要方便的替换。
算法与业务逻辑解耦，不想业务逻辑或客户端程序知道过多的算法实现细节。
一个类定义了多种行为，但是在某个问题上，使用了多个条件判断的方法来使用不同的行为，这时候可以用策略模式来消除多个条件判断。

5.模式的实现步骤与例子

1.将算法的抽象类或接口。抽象出算法的一个个方法。
2.实现算法的具体类。
3.创建一个拥有Strategy引用的Context类，拥有对应调用算法的方法。

下面看例子。

算法的抽象类与算法具体类：

//Strategy.h
class CalStrategy
{
public:
	virtual ~CalStrategy() {}
	virtual void Calculate() = 0;
};

class ACalStrategy : public CalStrategy
{
public:
	~ACalStrategy(){}

	void Calculate() override {
		cout << "ACalStrategy Calculate" << endl;
	}
};

class BCalStrategy : public CalStrategy
{
public:
	~BCalStrategy() {}

	void Calculate() override {
		cout << "BCalStrategy Calculate" << endl;
	}
};

在这里通过工厂方法的方式来创建出对应的算法：

class CalStrategyFactory
{
public:
	virtual ~CalStrategyFactory(){}
	virtual CalStrategy* CreateCalStrategy() = 0;
};


class ACalStrategyFactory : public CalStrategyFactory
{
public:
	~ACalStrategyFactory(){}
	CalStrategy* CreateCalStrategy() override {
		return new ACalStrategy();
	}
};

class BCalStrategyFactory : public CalStrategyFactory
{
public:
	~BCalStrategyFactory() {}
	CalStrategy* CreateCalStrategy() override {
		return new BCalStrategy();
	}
};

Context上下文类，主要是用于算法的调用：

class Context
{
public:
	Context(CalStrategyFactory* factory){
		this->calStrategy = factory->CreateCalStrategy();
	}
	~Context(){
		delete calStrategy;
	}

	void Calculate() {
		//...
		std::cout<<"============算法开始==========="<<std::endl;

		calStrategy->Calculate();

		std::cout<<"============算法结束==========="<<std::endl;
		//...
	}

private:
	CalStrategy * calStrategy;
};

客户端调用：

#include "strategy.h"

int main()
{
	CalStrategyFactory* factoryA = new ACalStrategyFactory();
	Context* orderA = new Context(factoryA);

	CalStrategyFactory* factoryB = new BCalStrategyFactory();
	Context* orderB = new Context(factoryB);

	orderA->Calculate();
	orderB->Calculate();

	delete factoryA;
	delete factoryB;
	
	system("pause");

	return 0;
}

运行结果：

============算法开始===========
ACalStrategy Calculate
============算法结束===========
============算法开始===========
BCalStrategy Calculate
============算法结束===========

6.小结

策略方法主要是定义系列的算法，方便在需求变化时很容易的替换对应的算法，几乎是不增加什么成本的。有助于提取出算法的公共部分抽象出抽象类或接口。但是在实际使用的时候，要注意Context的使用，如果直接在里面硬编码new一个具体类的算法，就会比较生硬，没有动态性。

一般拥有一个strategy引用，是通过一个接口传入对应的算法具体类，达到动态的替换算法。
另外一种方法是把Context实现为模板类，在创建的时候直接创建对应的算法的方法。比如Context<ACalStrategy> contex，这样就是静态绑定，这样的话丧失了运行时的动态性，但是效率会高一点。具体的选择应根据实际情况选择。

设计模式