设计模式解析之——Strategy模式（k_eckel转自微软高校博客K_eckel's mindview）

0 引言

0.1 目的

       本文档给出设计模式之——Strategy模式的简化诠释，并给出其C++实现。

0.2 说明

Project	Design Pattern Explanation（By K_Eckel）
Authorization	Free Distributed but Ownership Reserved
Date	2005-04-05（Cherry blossom is Beautiful）
Test Bed	MS Visual C++ 6.0

0.3 参考

       在本文档的写作中，参考了以下的资源，在此列出表示感谢：

u       书籍

[GoF 2000]：GoF,Design Patterns-Elements of Reusable Object-Oriented Software

Addison-Wesley 2000/9.

        [Martine 2003]：Robert C.Martine, Agile Software Development Principles, Patterns, and Practices, Pearson Education, 2003.

0.4 联系作者

Author	K_Eckel
State	Candidate for Master’s Degree School of Computer Wuhan University
E_mail	frwei@whu.edu.cn

2 Strategy模式

2.1 问题

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

2.2 模式选择

       Strategy模式典型的结构图为：

图2-1：Strategy Pattern结构图

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

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

类）。

2.3 实现

2.3.1 完整代码示例（code）

       Strategy模式实现很简单，这里为了方便初学者的学习和参考，将给出完整的实现代码（所有代码采用C++实现，并在VC 6.0下测试运行）。

代码片断1：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_

代码片断2：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;
}

代码片断3：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_

代码片断4：Context.cpp
//Client.c

//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();
}

代码片断5：main.cpp
//main.cpp

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

#include <iostream>
using namespace std;

int main(int argc,char* argv[])
{
 Strategy* ps;

 ps = new ConcreteStrategyA();

 Context* pc = new Context(ps);

 pc->DoAction();

 if (NULL != pc)
  delete pc;

 return 0;
}

2.3.2 代码说明

       Strategy模式的代码很直观，关键是将算法的逻辑封装到一个类中。

2.4 讨论

       可以看到Strategy模式和Template模式解决了类似的问题，也正如在Template模式中分析的，Strategy模式和Template模式实际是实现一个抽象接口的两种方式：继承和组合之间的区别。要实现一个抽象接口，继承是一种方式：我们将抽象接口声明在基类中，将具体的实现放在具体子类中。组合（委托）是另外一种方式：我们将接口的实现放在被组合对象中，将抽象接口放在组合类中。这两种方式各有优缺点，先列出来：

1）  继承：

n         优点

1）易于修改和扩展那些被复用的实现。

n         缺点

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

2）“白盒”复用，原因在1）中；

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

4）从父类继承而来的实现在运行期间不能改变（编译期间就已经确定了）。

2）  组合

n         优点

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

2）封装性好，原因为1）；

3）实现和抽象的依赖性很小（组合对象和被组合对象之间的依赖性小）；

4）可以在运行期间动态定义实现（通过一个指向相同类型的指针，典型的是抽象基类的指针）。

n         缺点

1）系统中对象过多。

从上面对比中我们可以看出，组合相比继承可以取得更好的效果，因此在面向对象的设计中的有一条很重要的原则就是：优先使用（对象）组合，而非（类）继承（Favor Composition Over Inheritance）。

实际上，继承是一种强制性很强的方式，因此也使得基类和具体子类之间的耦合性很强。例如在Template模式中在ConcreteClass1中定义的原语操作别的类是不能够直接复用（除非你继承自AbstractClass，具体分析请参看Template模式文档）。而组合（委托）的方式则有很小的耦合性，实现（具体实现）和接口（抽象接口）之间的依赖性很小，例如在本实现中，ConcreteStrategyA的具体实现操作很容易被别的类复用，例如我们要定义另一个Context类AnotherContext，只要组合一个指向Strategy的指针就可以很容易地复用ConcreteStrategyA的实现了。

我们在Bridge模式的问题和Bridge模式的分析中，正是说明了继承和组合之间的区别。请参看相应模式解析。

另外Strategy模式很State模式也有相似之处，但是State模式注重的对象在不同的状态下不同的操作。两者之间的区别就是State模式中具体实现类中有一个指向Context的引用，而Strategy模式则没有。具体分析请参看相应的State模式分析中。