C++策略模式

策略模式：

    它定义了算法家族，分别封装起来，让它们之间可以相到替换，此模式用算法的变化不会影响到其它的客户。

 

   

 

---

此模式还是其实就是我们平常写的代码，其实设计模式就是告诉你如何写代码罢了，并不是什么搬来就可以用的方案，如果是这样，为鸟不直接写在库作框架调用就得了，因为它仅仅提供一种解决方案。它只是告诉你有与它相似需求的时候，代码该怎么写。这样写出来的代码它的扩展性好，容易维护，类之间的耦合度低。

---

策略模式迎合了几个面向对象的设计思想：

    1、找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

    2、多用组合，少用继承。

    3、针对接口而不是实现编程。

---

引用《Head First 设计模式》中的例子：

    假如我们要设一个鸭子类：

那么一般的想法就是：

    

在基类中，有fly(),swim(),quack()这些函数接口，然后在子类中只要实现这些接口就行了。但是问题来了，例如我们要实现一个“旱鸭子”和“橡皮鸭”。你会发现，感觉在设计上逻辑有点不太对了，像皮鸭会叫吗？它会有quack()或者fly()函数接口吗？而旱鸭子会有swim()方法？这些肯定是不对的。

    问题在于这种设计思路不太符合：

         2、多用组合，少用继承。

    原则，都用继承就没有那么灵活了。

或者你会这么设计：

    

 这样也许是个好设计，把fly()和swim单独弄出来作一个类，然后单独继承，这样设计倒是符合：

1、找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

但是Acton类本来应该也是Duck该有的，Action应该是属于Duck类。单独分开来继承，可能实现上没有太大的影响 ，但是从逻辑上好像也不太好，好像有人非得把你“五马分尸”。

所以总结下，这么设计：

    

也就是将Action作为Duck的成员，再在它自己的方法中调用Action中的接口。

1. voidDuck::peformfly(){
2. this->action.fly();
3. }

---

上面的框图的，代码实现。

    #include<iostream>
    #include<string>
    classStratery{
    public:
        Stratery(){
        }
        virtualvoidAlgorithmInterface(){
            std::cout<<"AlgorithmInterface"<<std::endl;
        }
    };
    classConcreteStrateryA:publicStratery{
    public:
        virtualvoidAlgorithmInterface(){
            std::cout<<"ConcreteStrateryA"<<std::endl;
        }
    };
    classConcreteStrateryB:publicStratery{
    public:
       virtualvoidAlgorithmInterface(){
            std::cout<<"ConcreteStrateryB"<<std::endl;
       }
    };
    classConcreteStrateryC:publicStratery{
    public:
        virtualvoidAlgorithmInterface(){
            std::cout<<"ConcreteStrateryC"<<std::endl;
        }
    };
    classContext{
    private:
        Stratery*stratery;
    public:
        Context(Stratery*_stratery):stratery(_stratery){
        }
       voidContextInterface(){
           stratery->AlgorithmInterface();
       }
    };
    int main(){
        Context contextA(newConcreteStrateryA());
        contextA.ContextInterface();
        Context contextB(newConcreteStrateryB());
        contextB.ContextInterface();
        Context contextC(newConcreteStrateryB());
        contextC.ContextInterface();
    }

---

上面的实现，就是使用了策略模式的经典用法。

其中：

1. ConcreteStrateryA

1. ConcreteStrateryB

1. ConcreteStrateryC

就是算法家族。这些算法之间是没有耦合的。这也是策略模式的要点之一。

可以说，策略模式就是用来封装算法，但是也可以扩展到所有其它与之要求相似的类。例如前面的Duck类，那么Duck类中封装的算法就是

Action了。

 

    

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

null