设计模式C++实现（2）——策略模式

港控/mmm° 2022-09-20 12:34 131阅读 0赞

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

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

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

![0_1312614490zIlY.gif][]

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

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

**\[cpp\]**  [view plain][] [copy][view plain] [print][view plain] [?][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] [print][view plain] [?][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] [print][view plain] [?][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] [print][view plain] [?][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] [print][view plain] [?][view plain]

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

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

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

**\[cpp\]**  [view plain][] [copy][view plain] [print][view plain] [?][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] [print][view plain] [?][view plain]

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

本人享有博客文章的版权，转载请标明出处 [http://blog.csdn.net/wuzhekai1985][http_blog.csdn.net_wuzhekai1985]

[0_1312614490zIlY.gif]: /images/20220828/30f72a5d24b7413597ba9f0579340123.png
[view plain]: http://blog.csdn.net/wuzhekai1985/article/details/6665197#
[http_blog.csdn.net_wuzhekai1985]: http://blog.csdn.net/wuzhekai1985

发表评论取消回复

表情：

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

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

相关阅读

相关【设计模式】Head First 设计模式——策略模式 C++实现

> 设计模式最大的作用就是在变化和稳定中间寻找隔离点，然后分离它们，从而管理变化。将变化像小兔子一样关到笼子里，让它在笼子里随便跳，而不至于跳出来把你整个房间给污染掉。设

迷南。/ 2023年10月15日 11:56/ 0 赞/ 148 阅读

相关设计模式C++实现（2）——策略模式

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

港控/mmm°/ 2022年09月20日 12:34/ 0 赞/ 132 阅读

相关 C#设计模式——策略模式

商场促销——策略模式：一、定义：它是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少

灰太狼/ 2022年08月20日 05:25/ 0 赞/ 136 阅读

相关 c#设计模式==策略模式

　　[策略模式][Link 1]，看完策略模式最大的感受就是将所有的算法封装起来，让它们之间可以相互替换，这个模式让算法的变化不会影响到使用者。　　我写的例子还是之前的那个

分手后的思念是犯贱/ 2022年06月17日 09:21/ 0 赞/ 181 阅读

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

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

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

相关 C++设计模式---策略模式

定义算法家族，分别封装起来，让他们之间可以相互替换，让算法变化，不会影响到用户。适合类中的成员以方法为主，算法经常变动，简化了单元测试（因为每个算法都有自己的类），可以通过自己

女爷i/ 2022年05月27日 00:06/ 0 赞/ 157 阅读

相关设计模式C++实现（2）——策略模式

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

素颜马尾好姑娘i/ 2022年04月24日 06:14/ 0 赞/ 193 阅读

相关 [C++实现设计模式(12)] : 策略模式

文章目录情景描述策略模式的定义策略模式的应用策略模式的优点

短命女/ 2022年01月23日 03:43/ 0 赞/ 241 阅读

相关 c++设计模式：策略模式

1.主要思想：例如针对不同的算法，创建不同的类。 include <iostream> using namespace std; // T

叁歲伎倆/ 2021年12月04日 06:37/ 0 赞/ 223 阅读

相关 JavaScript设计模式（2）—— 策略模式

策略模式的定义是：定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。讲人话就是：定义一系列算法逻辑，处理类似的业务场景。讲JavaScript

清疚/ 2021年09月02日 04:26/ 0 赞/ 322 阅读