行为型模式：Strategy——策略模式

一、意图

定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换，本模式使得算法可独立于使用它的客户而变化——四人团

二、基本思想

定义算法家族，分别封装起来，让它们之间可以互相替换，让算法的变化，不会影响到使用算法的用户。

三、优缺点分析

GOOD:

（1）策略模式是一种定义一系列算法的方法，从概念上看，所有这些算法完成的都是相同的工作，只是实现不同。

所以使用策略模式，就可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。

（2）策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能

（3）简化了单元测试（因为每个算法都有自己的类，可以通过自己的接口单独测试）

BUG:客户端要做出判断使用哪个具体算法（可通过在context中与工厂模式的结合来消除这个问题，虽然当新增加需求时，还是要改context中的代码，但是任何需求的变更本身就是需要成本的）

四、适用情况

策略模式和简单工厂基本相同，但简单工厂模式只能解决对象创建问题，对于类中的成员以方法为主，而且算法经常变动的类，应使用策略模式。

在实践中，策略模式实际上可以封装几乎任何类型的规则，只要在分析过程中听到需要不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。

五、标准UML图例及源码

（1）标准UML图列

（2）标准源码

/************************************************************************

* FileName: Strategy.h

* Author: steven oyj (steven.oyj@gmail.com)

* Description : 抽象算法类：定义所有支持的算法的公共接口

* Time: 2010/5/24

************************************************************************/

#ifndef STRATEGY_H

#define STRATEGY_H

class Strategy

{

public:

 virtual ~Strategy(){}

 // 算法方法

 virtual void AlgorithmInterface() = 0;

};

#endif

/************************************************************************

* FileName: Context.h

* Author: steven oyj (steven.oyj@gmail.com)

* Description : 上下文类，用一个ConcreateStrategy来配置，维护一个对Strategy对象的引用

* Time: 2010/5/24

************************************************************************/

#ifndef CONTEXT_H

#define CONTEXT_H

#include "Strategy.h"

#include <iostream>

class Context

{

public:

 Context(Strategy *pStrategy);// 构造时，传入具体的策略对象

 ~Context();

 void ContextInterface();// 根据具体的策略对象，调用其算法的方法

private:

 Strategy* m_pStrategy;

};

#endif // CONTEXT_H

 1:/************************************************************************

* FileName: ConcreateStrategyA.h

* Author: steven oyj (steven.oyj@gmail.com)

* Description : 具体算法类A：封装了具体的算法或行为，继承于Strategy

* Time: 2010/5/24

************************************************************************/

#ifndef CONCREATESTRATEGYA_H

#define CONCREATESTRATEGYA_H

#include "Strategy.h"

#include <iostream>

class ConcreateStrategyA

 : public Strategy

{

public:

 virtual ~ConcreateStrategyA(){}

// 算法A实现方法

 virtual void AlgorithmInterface();

};

#endif // CONCREATESTRATEGYA_H

/************************************************************************

* FileName: ConcreateStrategyB.h

* Author: steven oyj (steven.oyj@gmail.com)

* Description : 具体算法类B：封装了具体的算法或行为，继承于Strategy

* Time: 2010/5/24

************************************************************************/

#ifndef CONCREATESTRATEGYB_H

#define CONCREATESTRATEGYB_H

#include "Strategy.h"

#include <iostream>

class ConcreateStrategyB

 : public Strategy

{

public:

 virtual ~ConcreateStrategyB(){}

// 算法B实现方法

 virtual void AlgorithmInterface();

};

#endif // CONCREATESTRATEGYB_H

/************************************************************************

* FileName: ConcreateStrategyC.h

* Author: steven oyj (steven.oyj@gmail.com)

* Description : 具体算法C：封装了具体的算法或行为，继承于Strategy

* Time: 2010/5/24

************************************************************************/

#ifndef CONCREATESTRATEGYC_H

#define CONCREATESTRATEGYC_H

#include "Strategy.h"

#include <iostream>

class ConcreateStrategyC

 : public Strategy

{

public:

 virtual ~ConcreateStrategyC(){}

// 算法C实现方法

 virtual void AlgorithmInterface();

};

#endif // CONCREATESTRATEGYC_H

/************************************************************************

* FileName: Context.cpp

* Author: steven oyj (steven.oyj@gmail.com)

* Description : 上下文类的具体实现

* Time: 2010/5/24

************************************************************************/

#include "Context.h"

// 构造时，传入具体的策略对象

Context::Context(Strategy *pStrategy)

 : m_pStrategy(pStrategy)

{

}

Context::~Context()

{

 delete m_pStrategy;

 m_pStrategy = NULL;

}

// 根据具体的策略对象，调用其算法的方法

void Context::ContextInterface()

{

 if (NULL != m_pStrategy)

{

 m_pStrategy->AlgorithmInterface();

}

}

/************************************************************************

* FileName: ConcreateStrategyA.cpp

* Author: steven oyj (steven.oyj@gmail.com)

* Description : ConcreateStrategyA类的具体实现

* Time: 2010/5/24

************************************************************************/

#include "ConcreateStrategyA.h"

// 算法A实现方法

void ConcreateStrategyA::AlgorithmInterface()

{

 std::cout << "AlgorithmInterface Implemented by ConcreateStrategyA\n";

}

/************************************************************************

* FileName: ConcreateStrategyC.cpp

* Author: steven oyj (steven.oyj@gmail.com)

* Description : ConcreateStrategyC类的具体实现

* Time: 2010/5/24

************************************************************************/

#include "ConcreateStrategyC.h"

// 算法C实现方法

void ConcreateStrategyC::AlgorithmInterface()

{

 std::cout << "AlgorithmInterface Implemented by ConcreateStrategyC\n";

}

/************************************************************************

* FileName: ConcreateStrategyB.cpp

* Author: steven oyj (steven.oyj@gmail.com)

* Description : ConcreateStrategyB类的具体实现

* Time: 2010/5/24

************************************************************************/

#include "ConcreateStrategyB.h"

// 算法B实现方法

void ConcreateStrategyB::AlgorithmInterface()

{

 std::cout << "AlgorithmInterface Implemented by ConcreateStrategyB\n";

}

/************************************************************************

* FileName: Main.cpp

* Author: steven oyj (steven.oyj@gmail.com)

* Description : Strategy模式的测试代码

* Time: 2010/5/24

************************************************************************/

#include "Context.h"

#include "ConcreateStrategyA.h"

#include "ConcreateStrategyB.h"

#include "ConcreateStrategyC.h"

int main()

{

 Strategy* pStrategy;

/**

 * 由于实例化不同的策略，所以最终在调用实际的算法时，所获得结果就不尽相同

 */

 pStrategy = new ConcreateStrategyA();

 Context*pContext1= new Context(pStrategy);

 pContext1->ContextInterface();

 pStrategy = new ConcreateStrategyB();

 Context*pContext2= new Context(pStrategy);

 pContext2->ContextInterface();

 pStrategy = new ConcreateStrategyC();

 Context*pContext3= new Context(pStrategy);

 pContext3->ContextInterface();

 delete pContext1;

 delete pContext2;

 delete pContext3;

 return 0;

}

六、实例UML图及源码

（1）纯策略模式

/************************************************************************

* FileName: CashSuperStratrgy.h

* Author: steven oyj (steven.oyj@gmail.com)

* Description : 抽象收费算法类：定义所有支持的收费算法的公共接口

* Time: 2010/5/24

************************************************************************/

#ifndef CASHSUPERSTRATEGY_H

#define CASHSUPERSTRATEGY_H

class CashSuperStrategy

{

public:

 CashSuperStrategy(){}

 virtual ~CashSuperStrategy(){}

 // 收费算法

 virtual double AcceptCash(double dMoney) = 0;

 protected:

private:

};

#endif // CASHSUPERSTRATEGY_H

/************************************************************************

* FileName: CashContext.h

* Author: steven oyj (steven.oyj@gmail.com)

* Description : 上下文类，用一个CashConcreateStrategy来配置，维护一个对CashSuperStratrgy对象的引用

* Time: 2010/5/24

************************************************************************/

#ifndef CASHCONTEXT_H

#define CASHCONTEXT_H

#include "CashSuperStrategy.h"

#include <iostream>

class CashContext

{

public:

 CashContext(CashSuperStrategy *pCashSuperStrategy);//构造时，传入具体的收费策略对象

 ~CashContext();

 double GetResult(double dMoney);// 根据具体的收费策略对象，获得具体的计算结果

 protected:

private:

 CashSuperStrategy* m_pCashSuperStrategy;

};

#endif // CASHCONTEXT_H

/************************************************************************

* FileName: CashContext.cpp

* Author: steven oyj (steven.oyj@gmail.com)

* Description : CashContext的具体实现

* Time: 2010/5/24

************************************************************************/

#include "CashContext.h"

CashContext::CashContext(CashSuperStrategy * pCashSuperStrategy)

{

 //ctor

 this->m_pCashSuperStrategy = pCashSuperStrategy;

}

CashContext::~CashContext()

{

 //dtor

 delete m_pCashSuperStrategy;

 m_pCashSuperStrategy = NULL;

}

double CashContext::GetResult(double dMoney)

{

 return m_pCashSuperStrategy->AcceptCash(dMoney);

}

/************************************************************************

* FileName: CashNormalStrategy.h

* Author: steven oyj (steven.oyj@gmail.com)

* Description : 具体的正常收费算法类CashNormalStrategy：封装了具体的正常收费算法，继承于Strategy

* Time: 2010/5/24

************************************************************************/

#ifndef CASHNORMALSTRATEGY_H

#define CASHNORMALSTRATEGY_H

#include "CashSuperStrategy.h"

class CashNormalStrategy : public CashSuperStrategy

{

public:

 CashNormalStrategy();

 virtual ~CashNormalStrategy();

 // 具体的收费算法

 virtual double AcceptCash(double dMoney);

 protected:

private:

};

#endif // CASHNORMALSTRATEGY_H

/************************************************************************

* FileName: CashNormalStrategy.cpp

* Author: steven oyj (steven.oyj@gmail.com)

* Description : CashNormalStrategy的具体实现

* Time: 2010/5/24

************************************************************************/

#include "CashNormalStrategy.h"

CashNormalStrategy::CashNormalStrategy()

{

 //ctor

}

CashNormalStrategy::~CashNormalStrategy()

{

 //dtor

}

double CashNormalStrategy::AcceptCash(double dMoney)

{

 return dMoney;

}

/************************************************************************

* FileName: CashRebateStrategy.h

* Author: steven oyj (steven.oyj@gmail.com)

* Description : 具体的打则收费算法类CashNormalStrategy：封装了具体的打折收费算法，继承于Strategy

* Time: 2010/5/24

************************************************************************/

#ifndef CASHREBATESTRATEGY_H

#define CASHREBATESTRATEGY_H

#include "CashSuperStrategy.h"

class CashRebateStrategy : public CashSuperStrategy

{

public:

 CashRebateStrategy(double dMoneyRebate);

 virtual ~CashRebateStrategy();

 // 具体的收费算法

 virtual double AcceptCash(double dMoney);

 protected:

private:

 double m_dMoneyRebate;

};

#endif // CASHREBATESTRATEGY_H

/************************************************************************

* FileName: CashRebateStrategy.cpp

* Author: steven oyj (steven.oyj@gmail.com)

* Description : CashRebateStrategy的具体实现

* Time: 2010/5/24

************************************************************************/

#include "CashRebateStrategy.h"

CashRebateStrategy::CashRebateStrategy(double dMoneyRebate)

{

 //ctor

 this->m_dMoneyRebate = dMoneyRebate;

}

CashRebateStrategy::~CashRebateStrategy()

{

 //dtor

}

double CashRebateStrategy::AcceptCash(double dMoney)

{

 return dMoney * m_dMoneyRebate;

}

/************************************************************************

* FileName: CashReturnStrategy.h

* Author: steven oyj (steven.oyj@gmail.com)

* Description : 具体的返现收费算法类CashReturnStrategy：封装了具体的返现收费算法，继承于Strategy

* Time: 2010/5/24

************************************************************************/

#ifndef CASHRETURNSTRATEGY_H

#define CASHRETURNSTRATEGY_H

#include "CashSuperStrategy.h"

class CashReturnStrategy : public CashSuperStrategy

{

public:

 CashReturnStrategy(double dMoneyCondition, double dMoneyReturn);

 virtual ~CashReturnStrategy();

 // 具体的收费算法

 virtual double AcceptCash(double dMoney);

 protected:

private:

 double m_dMoneyCondition;

 double m_dMoneyReturn;

};

#endif // CASHRETURNSTRATEGY_H

/************************************************************************

* FileName: CashReturnStrategy.cpp

* Author: steven oyj (steven.oyj@gmail.com)

* Description : CashReturnStrategy

* Time: 2010/5/24

************************************************************************/

#include "CashReturnStrategy.h"

CashReturnStrategy::CashReturnStrategy(double dMoneyCondition, double dMoneyReturn)

{

 //ctor

 this->m_dMoneyCondition = dMoneyCondition;

 this->m_dMoneyReturn = dMoneyReturn;

}

CashReturnStrategy::~CashReturnStrategy()

{

 //dtor

}

double CashReturnStrategy::AcceptCash(double dMoney)

{

 double result = dMoney;

 if (dMoney >= m_dMoneyCondition)

{

 result = dMoney - (int)(dMoney / m_dMoneyCondition) * m_dMoneyReturn;

}

 return result;

}

（2）策略与工厂结合

GOOD:客户端只需访问Context类，而不用知道其它任何类信息，实现了低耦合。

在上例基础上，增加一个结合了工厂模式的类

/************************************************************************

* FileName: CashContextWithFactory.h

* Author: steven oyj (steven.oyj@gmail.com)

* Description : 结合了工厂类的上下文类定义

* Time: 2010/5/24

************************************************************************/

#ifndef CASHCONTEXTWITHFACTORY_H

#define CASHCONTEXTWITHFACTORY_H

#include "CashSuperStrategy.h"

#include "CashNormalStrategy.h"

#include "CashRebateStrategy.h"

#include "CashReturnStrategy.h"

#include <iostream>

class CashContextWithFactory

{

public:

 CashContextWithFactory(int type);//构造时，传入具体的收费策略类型，构造函数中自行根据类型创建对应收费类对象

 virtual ~CashContextWithFactory();

 double GetResult(double dMoney);// 根据具体的收费策略对象，获得具体的计算结果

 protected:

private:

 CashSuperStrategy* m_pCashSuperStrategy;

};

#endif // CASHCONTEXTWITHFACTORY_H

/************************************************************************

* FileName: CashContextWithFactory.cpp

* Author: steven oyj (steven.oyj@gmail.com)

* Description : CashContextWithFactory的具体实现

* Time: 2010/5/24

************************************************************************/

#include "CashContextWithFactory.h"

//构造时，传入具体的收费策略类型，构造函数中自行根据类型创建对应收费类对象

CashContextWithFactory::CashContextWithFactory(int type)

{

 //ctor

 switch (type)

{

 case 0:

 m_pCashSuperStrategy = new CashNormalStrategy();

 break;

 case 1:

 m_pCashSuperStrategy = new CashRebateStrategy(0.8);

 break;

 case 2:

 m_pCashSuperStrategy = new CashReturnStrategy(300, 100);

 break;

 default:

 break;

}

}

CashContextWithFactory::~CashContextWithFactory()

{

 //dtor

 delete m_pCashSuperStrategy;

 m_pCashSuperStrategy = NULL;

}

double CashContextWithFactory::GetResult(double dMoney)

{

 return m_pCashSuperStrategy->AcceptCash(dMoney);

}

（3）测试代码

/************************************************************************

* FileName: main.cpp

* Author: steven oyj (steven.oyj@gmail.com)

* Description : 策略模型及其与工厂模式结合的测试主函数

* Time: 2010/5/24

************************************************************************/

#include <iostream>

#include "CashContext.h"

#include "CashNormalStrategy.h"

#include "CashRebateStrategy.h"

#include "CashReturnStrategy.h"

#include "CashContextWithFactory.h"

using namespace std;

void PureStratrgyTest();

void StrategyWithFactoryTest();

int main()

{

 PureStratrgyTest();

 StrategyWithFactoryTest();

 return 0;

}

/**

* 由于实例化不同的收费策略类对象，所以最终在调用实际的收费算法时，所获得结果就不尽相同

*/

void PureStratrgyTest()

{

 CashSuperStrategy* pStrategy;

 pStrategy = new CashNormalStrategy();

 CashContext*pContext1= new CashContext(pStrategy);

 cout << pContext1->GetResult(800) << endl;

 pStrategy = new CashRebateStrategy(0.8);

 CashContext*pContext2= new CashContext(pStrategy);

 cout << pContext2->GetResult(800) << endl;

 pStrategy = new CashReturnStrategy(300, 100);

 CashContext*pContext3= new CashContext(pStrategy);

 cout << pContext3->GetResult(800) << endl;

 delete pContext1;

 delete pContext2;

 delete pContext3;

}

/**

* 结合工厂模式，传入不同收费策略的指令参数，

* 由上下文类中的工厂自行实例化不同的收费策略类对象

* 所以最终在调用实际的收费算法时，所获得结果就不尽相同

*/

void StrategyWithFactoryTest()

{

 CashContextWithFactory* pContext1 = new CashContextWithFactory(0);

 cout << pContext1->GetResult(800) << endl;

 CashContextWithFactory* pContext2 = new CashContextWithFactory(1);

 cout << pContext2->GetResult(800) << endl;

 CashContextWithFactory* pContext3 = new CashContextWithFactory(2);

 cout << pContext3->GetResult(800) << endl;

 delete pContext1;

 delete pContext2;

 delete pContext3;

}