第一章 - 策略模式

一、初始问题

//如下示例是最初的设计，鸭子都会呱呱叫和游泳，每个鸭子的外观都不同，所以外观设计为纯虚函数，子类自己实现

如下实现了一种红头鸭和一种绿头鸭，在目前的需求下可以很好的运行，代码如下：

#include <iostream>
#include <string>
using namespace std;

class Duck    //鸭子基类
{
public:
    void quack()    //鸭子呱呱叫
    {
        printf("我会呱呱叫\n");
    }            
    void swim()        //鸭子会游泳
    {
        printf("我会游泳\n");
    }        
    virtual void display() = 0;    //抽象的鸭子外观
};

class MullardDuck: public Duck
{
public:
    void display()
    {
        printf("我是绿头鸭\n");
    }
};

class RedHeadDuck: public Duck
{
public:
    void display()
    {
        printf("我是红头鸭\n");
    }
};

void main()
{
    Duck *pDuck1 = new RedHeadDuck();
    Duck *pDuck2 = new MullardDuck();

    pDuck1->display();
    pDuck1->quack();
    pDuck1->swim();
    
    pDuck2->display();
    pDuck2->quack();
    pDuck2->swim();
    
    delete pDuck1;
    delete pDuck2;
}

运行结果：

二、问题升级：

此时，我需要增加需求：

1、我需要鸭子能飞

2、我需要增加一种橡皮鸭（不会飞），一种模型鸭

//需要把特殊属性抽取出来,形成组合，使程序弹性增大，代码如下:

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class  FlyBehavior    //飞行接口
{
public:
    virtual void fly() = 0;
};

class QuackBehavior    //叫声接口
{
public:
    virtual void quack() = 0;
};


class FlyWithWings: public FlyBehavior
{
public:
    virtual void fly()
    {
        printf("我会飞\n");
    }
};

class FlyNoWay: public FlyBehavior
{
public:
    virtual void fly()
    {
        printf("我不会飞\n");
    }
};

class Quack: public QuackBehavior
{
public:
    virtual void quack()
    {
        printf("我会呱呱叫\n");
    }
};

class Squeak: public QuackBehavior
{
public:
    virtual void quack()
    {
        printf("我会吱吱叫\n");
    }
};

class MuteQuack: public QuackBehavior
{
public:
    virtual void quack()
    {
        printf("我不会叫\n");
    }
};

class Duck    //鸭子基类
{
public:
    FlyBehavior      * pFly;    //飞行指针
    QuackBehavior * pQuack;    //鸣叫指针

    void performFly()
    {
        pFly->fly();
    }

    void performQuack()
    {
        pQuack->quack();
    }        
    void swim()        //鸭子会游泳
    {
        printf("我会游泳\n");
    }        
    virtual void display() = 0;    //抽象的鸭子外观
};

class MullardDuck: public Duck
{
public:
    MullardDuck()
    {
        pFly   = new FlyNoWay();
        pQuack = new Quack();
    }
    void display()
    {
        printf("我是绿头鸭\n");
    }
};

class RedHeadDuck: public Duck
{
public:
    RedHeadDuck()
    {
        pFly   = new FlyWithWings();
        pQuack = new Squeak();
    }
    void display()
    {
        printf("我是红头鸭\n");
    }
};

class  RubberDuck: public Duck
{
public:
    void display()
    {
        printf("我是橡皮鸭\n");
    }
};

class  DecoyDuck: public Duck
{
public:
    DecoyDuck()
    {
        pFly   = new FlyNoWay();
        pQuack = new MuteQuack();
    }
    void display()
    {
        printf("我是模型鸭\n");
    }
};
typedef vector<Duck *>VEC_DUCK;
void main()
{
    VEC_DUCK mDuck;
    Duck *pDuck1 = new MullardDuck();
    Duck *pDuck2 = new RedHeadDuck();
    Duck *pDuck3 = new DecoyDuck();

    mDuck.push_back(pDuck1);
    mDuck.push_back(pDuck2);
    mDuck.push_back(pDuck3);

    VEC_DUCK::iterator iter = mDuck.begin();
    for(;iter!= mDuck.end(); iter++)
    {
        Duck * pDuck = *iter;
        pDuck->display();
        pDuck->performFly();
        pDuck->performQuack();
        printf("\n");
        //(*iter).display();
        //*iter->display();
        //iter->performFly();
        //iter->performQuack();
    }
}