C++实现Behavioral - Strategy模式

也称为Policy模式。

 

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

“Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.”- GoF

 

在软件构建过程中，某些对象使用的算法可能多种多样，经常改变，如果将这些算法都编码到某个对象中，将会使该对象变得异常复杂；而且有时候支持不使用的算法也是一个性能负担。Strategy设计模式就是在运行时根据需要透明地更改对象的算法，将算法和对象本身解耦。

 

我们在编程中，经常碰到这样的情况：用不同的办法去做同一件事情，比如，

1.       将文件保存为不同的格式；

2.       用不同的压缩算法压缩一个文本文件；

3.       用不同的压缩算法压缩视频文件

4.       将同样的数据，用不同的图形显示出来：折线图、柱状图或者饼图；

5.       将用某种语言写的一个句子，翻译成为几种其他的语言。

客户程序告诉驱动模块(不妨称为Context)，它将使用哪个算法(即所谓的strategy或policy)，并请求Context执行该算法。

 

Strategy模式UML类图：

 v

 

角色：

Strategy：

-          给所有支持的算法声明一个通用接口，Context使用该接口调用由ConcreteStrategy定义的算法。

 

ConcreteStrategy：

-        按照Strategy给出的接口实现具体的算法。

 

Context

-        包含一个Strategy的引用；

-        可以由ConcreteStrategy对象对其进行配置。

 

业务示例：

将阿拉伯数字“520”分别翻译成中文、英语和俄语。

 

下面是具体C++代码：

// Strategy.h

#include <iostream>

#include <string>

#include <memory>

using namespace std;

 

// Strategy抽象类，用做借口

class Strategy

{

public:

         virtual string substitute(string str) = 0;

 

public:

         virtual ~Strategy()

         {

                   cout << "in the destructor of Strategy..." << endl;

         }

};

 

// 中文Strategy

class ChineseStrategy : public Strategy

{

public:

         string substitute(string str)

         {

                   size_t index = str.find("520");

                   string tempstr = str.replace(index, 3, "我爱你");

                   return tempstr;

         }

 

public:

         ~ChineseStrategy()

         {

                   cout << "in the destructor of ChineseStrategy..." << endl;

         }

};

 

// 英语Strategy

class EnglishStrategy : public Strategy

{

public:

         string substitute(string str)

         {

                   size_t index = str.find("520");

                   string tempstr = str.replace(index, 3, "I love you");

                   return tempstr;

         }

 

public:

         ~EnglishStrategy()

         {

                   cout << "in the destructor of EnglishStrategy..." << endl;

         }

};

 

// 俄语Strategy

class RussianStrategy : public Strategy

{

public:

         string substitute(string str)

         {

                   size_t index = str.find("520");

                   string tempstr = str.replace(index, 3, "Я люблю тебя");

                   return tempstr;

         }

 

public:

         ~RussianStrategy()

         {

                   cout << "in the destructor of RussiaStrategy..." << endl;

         }

};

 

// Context类

class Translator

{

private:

         auto_ptr<Strategy> strategy;

 

public:

         ~Translator()

         {

                   cout << "in the destructor of Translator..." << endl;

         }

 

public:

         void set_strategy(auto_ptr<Strategy> strategy)

         {

                   this->strategy = strategy;

         }

 

         string translate(string str)

         {

                   if(0 == strategy.get()) return "";

                   return strategy->substitute(str);

         }

};

 

// Strategy.cpp

#include "Strategy.h"

 

int main(int argc, char** argv)

{

         string str("321520");

         Translator* translator = new Translator;

 

         // 未指定strategy时

         cout << "No strategy: " << translator->translate(str) << endl;

         cout << "--------------------------" << endl;

 

         // 翻译成中文

         auto_ptr<Strategy> s1(new ChineseStrategy());

         translator->set_strategy(s1);

         cout << "Chinese strategy: " << translator->translate(str) << endl;

         cout << "--------------------------" << endl;

 

         // 翻译成英语

         auto_ptr<Strategy> s2(new EnglishStrategy());

         translator->set_strategy(s2);

         cout << "English strategy: " << translator->translate(str) << endl;

         cout << "--------------------------" << endl;

 

         // 翻译成俄语

         auto_ptr<Strategy> s3(new RussianStrategy());

         translator->set_strategy(s3);

         cout << "Russian strategy: " << translator->translate(str) << endl;

         cout << "--------------------------" << endl;

 

         delete translator;

 

         return 0;

}

运行结果：

No strategy:

--------------------------

Chinese strategy: 321我爱你

--------------------------

in the destructor of ChineseStrategy...

in the destructor of Strategy...

English strategy: 321I love you

--------------------------

in the destructor of EnglishStrategy...

in the destructor of Strategy...

Russian strategy: 321Я люблю тебя

--------------------------

in the destructor of Translator...

in the destructor of RussiaStrategy...

in the destructor of Strategy...

 

结果符合预期。

1.       从上面程序可以很容易看出，可以在运行时改变translator对象的行为；

2.       算法如果改变了，客户端程序不需要做任何改动，比如在EnglishStrategy的实现中将“520”翻译成“Five hundred and twenty”，客户端代码无需任何改变；

3.       当需要增加新的算法时，比如要将“520”翻译成日语的“わたし爱してるあなた”，只需要增加一个具体的Strategy类，比如JapaneseStrategy类，并重写Strategy中声明的纯虚函数即可。这完全符合OCP。

 

上述代码的UML类图：

 

 

Strategy模式和State粗看起来非常相似，但他们的意图完全不同。他们主要的区别在于：

1.       Strategy一次只能选择一个strategy(即算法)，而State模式中，不同的状态有可能同时被激活；

2.       Strategy封装的是算法，State封装的是状态；

3.       Strategy所封装的算法(每个算法对应一个类)，所做的事情相差无几，而State所封装的状态(每个状态对应一个类)，往往颇不相同；

4.       State模式中的状态迁移的概念，在Strategy中根本不存在。

 

转： http://patmusing.blog.163.com/blog/static/1358349602010150224904/