1  会飞的鸭子 

    Duck 基类中,有成员函数 Swim() 和 Display()

    class Duck
    {
    public:
        void Swim();
        virtual void Display();
    };  

    派生类野鸭 MallardDuck,橡皮鸭 RubberDuck 和 红头鸭 RedheadDuck,外形不一,须各自重写 Display()    

   

    class MallardDuck : public Duck
    {
    public:
        void Display(); // adding virtual is OK but not necessary
    };

    class RedheadDuck : public Duck
    // ... 

    class RubberDuck : public Duck
    //...   

    现要求,增加飞行函数 -- Fly,该如何设计?

1.1  继承

    考虑到并非所有的鸭子都会飞,在 Duck 中加普通虚函数 Fly(),“会飞”的直接继承 Fly() ,“不会飞”的重写 Fly()

    void Duck::Fly()
    {
        cout << "I am flying !" << endl;
    }

    void RubberDuck::Fly()
    {
        cout << "I cannot fly !" << endl;
    }  

1.2  接口

    用普通虚函数并非良策,C++11 之 override “1.2 普通虚函数” 中已经说明。代替方法是 "纯虚函数 + 缺省实现" :即 Duck 类中的 Fly() 声明为纯虚函数,同时写一个缺省实现

    因为 Fly() 是纯虚函数,所以只有“接口”会被继承,缺省的“实现”不会被继承,是否调用 Duck::Fly() 的缺省实现,则取决于重写的 Fly()

    void MallardDuck::Fly()
    {
        Duck::Fly();
    }

    void RedheadDuck::Fly()
    {
        Duck::Fly();
    }  

1.3  设计模式

    到目前为止,并没有设计模式,但问题已经解决。实际上用不用设计模式,取决于实际需求,也取决于设计者。

    《Design Patterns》 中,关于策略模式的适用情景,如下:

      1) many related classes differ only in their behavior

      2) you need different variants of an algorithm

      3) an algorithm uses data that clients shouldn't know about

      4) a class defines many behaviors, and these appear as multiple conditional statements in its operations

    Duck 的派生类属于 “related classes”,关键在于“飞”这个 "behavior",如果只是将“飞”的行为,简单划分为“会飞”和“不会飞”,则不用设计模式完全可以。

    如果“飞的行为”,随派生类的增加,会有几十种;或“飞的行为”可视为多种算法;或“飞的行为”作为算法库提供给第三方使用此时,应用设计模式,价值便会体现出来 -- 易复用,易扩展,易维护

    而第 4) 种适用情景,多见于重构之中,替换一些条件选择语句 -- "Replace Type Code with State/Strategy"

 

2  设计原则

    在引出策略模式之前,先看面向对象的三个设计原则

    1)  隔离变化identify what varies and separate them from what stays the same

        Duck 基类中, “飞行方式“是变化的,于是把 Fly() 择出来,和剩余不变的分隔开

    2)  编程到接口program to an interface, not an implementation

        分离Fly(),将其封装为一个接口,里面实现各种不同的“飞行方式” (一系列”算法“),添加或修改算法都在这个接口里进行。

    “接口”对应于 C++ 便是抽象基类,故可将“飞行方式”封装为 FlyBehavior 类,并在类中声明 Fly() 为纯虚函数 

    class FlyBehavior
    {
    public:
        virtual void Fly() = 0;
    };

    class FlyWithWings : public FlyBehavior
    {
    public:
        virtual void Fly();
    };

    class FlyNoWay ...

    class FlyWithRocket ...  

     具体实现各种不同的算法 -- “飞行方式”,如下:

    void FlyWithWings::Fly() { cout << "I am flying !" << endl; }

    void FlyNoWay::Fly() { cout << "I cannot fly !" << endl; }

    void FlyWithRocket::Fly() { cout << "I am flying with a rocket !" << endl; }  

    3)  复合优于继承:favor composition (has-a) over inheritance (is-a)

       公有继承即是 “is-a”,而 Composition (复合或组合) 的含义是 “has-a”,因此,可在 Duck 基类中,声明 FlyBehavior 型指针,如此,只需通过指针 _pfB 便可调用相应的"算法" -- "飞行方式" 

    class Duck
    {
        ...
    private:
        FlyBehavior* fb_;  // 或 std::unique_ptr<FlyBehavior> fb_;
    };   

 

3  策略模式

3.1  内容

    即便不懂设计模式,只要严格按照遵守 隔离变化 --> 编程到接口 --> 复合 三个原则,设计思路也会和策略模式类似:

    策略模式的具体内容如下:

    Defines a family of algorithms,  encapsulates each one,  and makes them interchangeable.  Strategy lets the algorithm vary independently from clients that use it.

    

    Context 指向 Strategy (由指针实现);Context 通过 Strategy 接口,调用一系列算法;ConcreteStrategy 实现了一系列具体的算法

3.2  分析

    FlyBehavior 类对应策略模式的“接口”,“算法实现”分别对应派生类 FlyWithWings, FlyNoWay, FlyWithRocket,“引用”对应 fb_ 指针

    Duck::Duck(FlyBehavior* fb)
        : fb_(fb)
    {}

  Duck 对应于 Context,实际上是其派生类 MallardDuck 等,通过 FlyBehavior 接口来调用各种“飞行方式”。因此,需要在各个派生类的构造函数中,初始化 fb_ 

    MallardDuck::MallardDuck(FlyBehavior* fb)
        : Duck(fb)
    {}  

    然后,在 Duck 基类中,通过指针 fb_, 实现对 Fly() 的调用

    void Duck::PerformFly()
    {
        fb_->Fly();
    }  

    除了在构造函数中初始化 fb_ 外,还可在 Duck 类中,定义一个 SetFlyBehavior 成员函数,动态的设置“飞行方式”

    void Duck::SetFlyBehavior(FlyBehavior* fb)
    {
        fb_ = fb;
    }  

3.3  例程

    因为 main 执行结束后,程序也就结束了,所以对于简单程序,指针 new 了后,可以不用 delete

int main ()
{
    FlyBehavior *pfWings = new FlyWithWings;
    FlyBehavior *pfNo = new FlyNoWay;
    FlyBehavior *pfRocket = new FlyWithRocket;

    // fly with wings
    Duck *pDuck = new MallardDuck(pfWings);
    pDuck->PerformFly();

    // fly with a rocket
    pDuck->SetFlyBehavior(pfRocket);
    pDuck->PerformFly();
}

  

 

小结

  1)  面向对象的三个设计原则:隔离变化,编程到接口,复合优于继承

  2)  策略模式主要涉及的是“一系列算法“,熟悉其适用的四种情景

 

参考资料

 《大话设计模式》 第二章

 《Head First Design Patterns》 ch 1

 《Effective C++》 item 32, item 38

 《Design Patterns》 Strategy

 《Refactoring》 ch 8

  Herb Sutter, GotW #91 Solution: Smart Pointer Parameters

 

posted on 2016-06-01 00:08  飞鸢逐浪  阅读(12326)  评论(2编辑  收藏  举报