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

http://blog.csdn.net/wuzhekai1985

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

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

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

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

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

[cpp]  view plain copy print ?

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 print ?

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 print ?

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

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

[cpp]  view plain copy print ?

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 print ?

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

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

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

[cpp]  view plain copy print ?

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 print ?

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