其他分享
首页 > 其他分享> > 设计模式——策略模式

设计模式——策略模式

作者:互联网

转载来自:https://www.cnblogs.com/xinxue/p/5271184.html

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

 

标签:Fly,策略,void,模式,fb,Duck,FlyBehavior,设计模式,class
来源: https://www.cnblogs.com/Galesaur-wcy/p/15881841.html