设计模式C++实现（2）——(行为型)策略模式

我就是我 2022-06-03 23:58 169阅读 0赞

软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需要大量实践经验的积累。最近看设计模式的书，对于每个模式，用C++写了个小例子，加深一下理解。主要参考《大话设计模式》和《设计模式:可复用面向对象软件的基础》两本书。本文介绍策略模式的实现。

策略模式是指定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。也就是说这些算法所完成的功能一样，对外的接口一样，只是各自实现上存在差异。用策略模式来封装算法，效果比较好。下面以高速缓存（Cache）的替换算法为例，实现策略模式。

什么是Cache的替换算法呢？简单解释一下， 当发生Cache缺失时，Cache控制器必须选择Cache中的一行，并用欲获得的数据来替换它。所采用的选择策略就是Cache的替换算法。下面给出相应的UML图。

![0_1312614490zIlY.gif][]

ReplaceAlgorithm是一个抽象类，定义了算法的接口，有三个类继承自这个抽象类，也就是具体的算法实现。Cache类中需要使用替换算法，因此维护了一个  ReplaceAlgorithm的对象。这个UML图的结构就是策略模式的典型结构。下面根据UML图，给出相应的实现。

首先给出替换算法的定义。

\[cpp\]  [view plain][]  [copy][view plain]

1.  //抽象接口  
2.  **class** ReplaceAlgorithm  
3.  \{  
4.  **public**:  
5.      **virtual** **void** Replace() = 0;  
6.  \};  
7.  //三种具体的替换算法  
8.  **class** LRU\_ReplaceAlgorithm : **public** ReplaceAlgorithm  
9.  \{  
10. **public**:  
11.     **void** Replace() \{ cout<<"Least Recently Used replace algorithm"<<endl; \}  
12. \};  
13.   
14. **class** FIFO\_ReplaceAlgorithm : **public** ReplaceAlgorithm  
15. \{  
16. **public**:  
17.     **void** Replace() \{ cout<<"First in First out replace algorithm"<<endl; \}  
18. \};  
19. **class** Random\_ReplaceAlgorithm: **public** ReplaceAlgorithm  
20. \{  
21. **public**:  
22.     **void** Replace() \{ cout<<"Random replace algorithm"<<endl; \}  
23. \};

接着给出Cache的定义，这里很关键，Cache的实现方式直接影响了客户的使用方式，其关键在于如何指定替换算法。

方式一：直接通过参数指定，传入一个特定算法的指针。

\[cpp\]  [view plain][]  [copy][view plain]

1.  //Cache需要用到替换算法  
2.  **class** Cache  
3.  \{  
4.  **private**:  
5.      ReplaceAlgorithm \*m\_ra;  
6.  **public**:  
7.      Cache(ReplaceAlgorithm \*ra) \{ m\_ra = ra; \}  
8.      ~Cache() \{ **delete** m\_ra; \}  
9.      **void** Replace() \{ m\_ra->Replace(); \}  
10. \};

如果用这种方式，客户就需要知道这些算法的具体定义。只能以下面这种方式使用，可以看到暴露了太多的细节。

\[cpp\]  [view plain][]  [copy][view plain]

1.  **int** main()  
2.  \{  
3.      Cache cache(**new** LRU\_ReplaceAlgorithm()); //暴露了算法的定义  
4.      cache.Replace();  
5.      **return** 0;  
6.  \}

方式二：也是直接通过参数指定，只不过不是传入指针，而是一个标签。这样客户只要知道算法的相应标签即可，而不需要知道算法的具体定义。

\[cpp\]  [view plain][]  [copy][view plain]

1.  //Cache需要用到替换算法  
2.  **enum** RA \{LRU, FIFO, RANDOM\}; //标签  
3.  **class** Cache  
4.  \{  
5.  **private**:  
6.      ReplaceAlgorithm \*m\_ra;  
7.  **public**:  
8.      Cache(**enum** RA ra)   
9.      \{   
10.         **if**(ra == LRU)  
11.             m\_ra = **new** LRU\_ReplaceAlgorithm();  
12.         **else** **if**(ra == FIFO)  
13.             m\_ra = **new** FIFO\_ReplaceAlgorithm();  
14.         **else** **if**(ra == RANDOM)  
15.             m\_ra = **new** Random\_ReplaceAlgorithm();  
16.         **else**   
17.             m\_ra = NULL;  
18.     \}  
19.     ~Cache() \{ **delete** m\_ra; \}  
20.     **void** Replace() \{ m\_ra->Replace(); \}  
21. \};

相比方式一，这种方式用起来方便多了。其实这种方式将简单工厂模式与策略模式结合在一起，算法的定义使用了策略模式，而Cache的定义其实使用了简单工厂模式。

\[cpp\]  [view plain][]  [copy][view plain]

1.  **int** main()  
2.  \{  
3.      Cache cache(LRU); //指定标签即可  
4.      cache.Replace();  
5.      **return** 0;  
6.  \}

上面两种方式，构造函数都需要形参。构造函数是否可以不用参数呢？下面给出第三种实现方式。

方式三：利用模板实现。算法通过模板的实参指定。当然了，还是使用了参数，只不过不是构造函数的参数。在策略模式中，参数的传递难以避免，客户必须指定某种算法。

\[cpp\]  [view plain][]  [copy][view plain]

1.  //Cache需要用到替换算法  
2.  **template** <**class** RA>  
3.  **class** Cache  
4.  \{  
5.  **private**:  
6.      RA m\_ra;  
7.  **public**:  
8.      Cache() \{ \}  
9.      ~Cache() \{ \}  
10.     **void** Replace() \{ m\_ra.Replace(); \}  
11. \};

使用方式如下：

\[cpp\]  [view plain][]  [copy][view plain]

1.  **int** main()  
2.  \{  
3.      Cache<Random\_ReplaceAlgorithm> cache; //模板实参  
4.      cache.Replace();  
5.      **return** 0;  
6.  \}

**备注：**

**策略模式简记：一个策略接口，若干具体的策略实现类，封装一个用于更新和执行策略的上下文Context，其构造函数和设置策略函数功能是一致的。**

**思考：为什么使用Cache而不直接创建对象并直接调用函数？**

细心如你应该会想我使用如下代码也能实现，Cache的存在是为了什么？

ReplaceAlgorithm\* a = new LRU\_ReplaceAlgorithm();  
a->Replace();

这里我们看看第一种现象：

修改抽象策略中的方法

virtual void Replace(int number) = 0;

修改具体策略的实现

void Replace(int number) \{ cout<<"Least Recently Used replace algorithm"<<endl; \}

看到这里你会不会觉得这个参数number有安全隐患，传进来的合法吗？于是我要判断，so，你可以每个具体的策略中都写一段相同的逻辑去判断下，或者传参时判断下，那么不想copy的你此刻是不是想找个地方统一判断一把，是的Cache此刻显示出重要性，我们大可在构造函数中去判断，那么我们总结下Cache的第一个优点：**必要时可以增加系统的安全性，减少代码的冗余**。

**本文转自:**

**http://blog.csdn.net/wuzhekai1985/article/details/6665197**

[0_1312614490zIlY.gif]: /images/20220604/abbe326ab99d4d84b8e40d8f595c6a63.png
[view plain]: http://blog.csdn.net/wuzhekai1985/article/details/6665197#

发表评论取消回复

表情：

评论列表（有 0 条评论，169人围观）

还没有评论，来说两句吧...

相关阅读

相关 c#设计模式-行为型模式之策略模式

定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实...

朱雀/ 2024年04月23日 20:19/ 0 赞/ 77 阅读

相关行为型设计模式之策略模式【设计模式系列】

系列文章目录 [C++技能系列][C] [Linux通信架构系列][Linux] [C++高性能优化编程系列][C 1] [深入理解软件架构设计系列][Lin

缺乏、安全感/ 2024年03月22日 20:50/ 0 赞/ 87 阅读

相关【设计模式】行为型：策略模式

策略模式（Strategy Pattern）是指定义了算法家族、分别封装起来，让它们之间可以互相替换，此模式让算法的变化不会影响到使用算法的用户。我们知道，工厂模式是解耦对

旧城等待，/ 2023年01月17日 07:40/ 0 赞/ 121 阅读

相关设计模式 ☞ 行为型之策略模式

1.1 简介 1.1.1 概述策略(Strategy)模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算

本是古典何须时尚/ 2023年01月06日 11:51/ 0 赞/ 156 阅读

相关设计模式：行为型-策略模式

目录第一章策略模式介绍第二章策略模式实现 2.1、抽象策略 2.2、具体策略 2.3、环境类 2

╰半夏微凉°/ 2022年11月18日 01:51/ 0 赞/ 169 阅读

相关设计模式C++实现（2）——(行为型)策略模式

软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长

我就是我/ 2022年06月03日 23:58/ 0 赞/ 170 阅读

相关行为型模式-策略模式

策略模式一个类的行为或其算法可以在运行时更改 UML类图： ![在这里插入图片描述][20181019094435747] ---------

àì夳堔傛蜴生んèń/ 2022年05月10日 15:50/ 0 赞/ 218 阅读

相关行为型模式：策略模式

简介姓名：策略模式英文名：Strategy Pattern 价值观：集计谋于一身个人介绍： Define a family of algorithms

朱雀/ 2022年01月29日 02:47/ 0 赞/ 307 阅读

相关设计模式之策略模式(行为型)

一、模式定义策略模式：定义一系列算法，然后将每一个算法封装起来，并将它们可以互相替换。也就是将一系列算法封装到一系列策略类里面。策略模式是一种对象行为型模式。策略模式符

ゝ一纸荒年。/ 2021年09月17日 11:20/ 0 赞/ 330 阅读

相关 Java设计模式（13）行为型：策略模式

（一）模块概述策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。策略模式的重心不是如何实现算法，

曾经终败给现在/ 2021年09月11日 05:36/ 0 赞/ 342 阅读