01策略模式

策略模式

最近在看《Head First设计模式》这本书，最大的感触就是，原来写代码也是有“套路”的，刚学了策略模式，用C++实现了一下，做个笔记，备忘！

感悟

• 把会变化的部分取出并“封装”起来，好让其他部分不会受影响。结果是代码变化引起的不经意后果变少，系统变得更有弹性。
• 设计原则：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。也就是说，如果第次新的需求一来，都会使某方面的代码发生变化，那么就可以确定
• 设计原则：针对接口编程，而不是针对实现编程。真正的意思是“针对超类型编程”，可以更明天地说成“变量的声明类型应该是超类型，通常是一个抽象类或者是一个接口，只要是具体实现此超类型的类所产生对象都可以指定给这个变量。
• 多用组合、少用继承。
• 策略模式：定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

相关类的继承关系

源代码

#include <iostream>

using namespace std;

class FlyBehavior
{
public:
    FlyBehavior();
    virtual ~FlyBehavior();
    virtual void fly();
};
FlyBehavior::FlyBehavior()
{
    cout << "FlyBehavior()" << endl;
}
FlyBehavior::~FlyBehavior()
{
    cout << "~FlyBehavior()" << endl;
}
void FlyBehavior::fly()
{
    cout << "FlyBehavior::fly()" << endl;
}

class FlyWithWings: public FlyBehavior
{
public:
    FlyWithWings();
    ~FlyWithWings();
    void fly();
};
FlyWithWings::FlyWithWings()
{
    cout << "FlyWithWings()" << endl;
}
FlyWithWings::~FlyWithWings()
{
    cout << "~FlyWithWings()" << endl;
}
void FlyWithWings::fly()
{
    cout << "FlyWithWings::fly()" << endl;
}

class FlyNoWay: public FlyBehavior
{
public:
    FlyNoWay();
    ~FlyNoWay();
    void fly();
};
FlyNoWay::FlyNoWay()
{
    cout << "FlyNoWay()" << endl;
}
FlyNoWay::~FlyNoWay()
{
    cout << "~FlyNoWay()" << endl;
}
void FlyNoWay::fly()
{
    cout << "FlyNoWay::fly()" << endl;
}

class FlyRecketPower: public FlyBehavior
{
public:
    FlyRecketPower();
    ~FlyRecketPower();
    void fly();
};
FlyRecketPower::FlyRecketPower()
{
    cout << "FlyRecketPower()" << endl;
}
FlyRecketPower::~FlyRecketPower()
{
    cout << "~FlyRecketPower()" << endl;
}
void FlyRecketPower::fly()
{
    cout << "FlyRecketPower::fly()" << endl;
}

class QuackBehavior
{
public:
    QuackBehavior();
    virtual ~QuackBehavior();
    virtual void quack();
};
QuackBehavior::QuackBehavior()
{
    cout << "QuackBehavior()" << endl;
}
QuackBehavior::~QuackBehavior()
{
    cout << "~QuackBehavior()" << endl;
}
void QuackBehavior::quack()
{
    cout << "QuackBehavior::quack()" << endl;
}

class Quack: public QuackBehavior
{
public:
    Quack();
    virtual ~Quack();
    virtual void quack();
};
Quack::Quack()
{
    cout << "Quack()" << endl;
}
Quack::~Quack()
{
    cout << "~Quack()" << endl;
}
void Quack::quack()
{
    cout << "Quack::quack()" << endl;
}

class Squack: public QuackBehavior
{
public:
    Squack();
    virtual ~Squack();
    virtual void quack();
};
Squack::Squack()
{
    cout << "Squack()" << endl;
}
Squack::~Squack()
{
    cout << "~Squack()" << endl;
}
void Squack::quack()
{
    cout << "Squack::quack()" << endl;
}

class MuteQuack: public QuackBehavior
{
public:
    MuteQuack();
    virtual ~MuteQuack();
    virtual void quack();
};
MuteQuack::MuteQuack()
{
    cout << "MuteQuack()" << endl;
}
MuteQuack::~MuteQuack()
{
    cout << "~MuteQuack()" << endl;
}
void MuteQuack::quack()
{
    cout << "MuteQuack::quack()" << endl;
}

class Duck
{
public:
    Duck();
    virtual ~Duck();
    void performFly();
    void performQuack();
    void setFlyBehavior(FlyBehavior *flyBehavior);
    void setQuackBehavior(QuackBehavior *quackBehavior);

    FlyBehavior *m_flyBehavior;
    QuackBehavior *m_quackBehavior;
};
Duck::Duck()
{
    #if 0
    m_flyBehavior = NULL;
    m_quackBehavior = NULL;
    #endif

    cout << "Duck()" << endl;
}
Duck::~Duck()
{
    #if 0
    if(m_flyBehavior)
        delete m_flyBehavior;

    if(m_quackBehavior)
        delete m_quackBehavior;
    #endif

    cout << "~Duck()" << endl;
}
void Duck::performFly()
{
    m_flyBehavior->fly();
}
void Duck::performQuack()
{
    m_quackBehavior->quack();
}
void Duck::setFlyBehavior(FlyBehavior *flyBehavior)
{
    this->m_flyBehavior = flyBehavior;
}
void Duck::setQuackBehavior(QuackBehavior *quackBehavior)
{
    this->m_quackBehavior = quackBehavior;
}

class MallardDuck: public Duck
{
public:
    MallardDuck();
    ~MallardDuck();
    void display();
};
MallardDuck::MallardDuck()
{
    m_flyBehavior = new FlyWithWings();
    m_quackBehavior = new Quack();

    cout << "MallardDuck()" << endl;
}
MallardDuck::~MallardDuck()
{
    if(m_flyBehavior)
        delete m_flyBehavior;

    if(m_quackBehavior)
        delete m_quackBehavior;

    cout << "~MallardDuck()" << endl;
}
void MallardDuck::display()
{
    cout << "MallardDuck::display()" << endl;
}

class ModelDuck: public Duck
{
public:
    ModelDuck();
    ~ModelDuck();
    void display();
};
ModelDuck::ModelDuck()
{
    m_flyBehavior = new FlyNoWay();
    m_quackBehavior = new Quack();

    cout << "ModelDuck()" << endl;
}
ModelDuck::~ModelDuck()
{
    if(m_flyBehavior)
        delete m_flyBehavior;

    if(m_quackBehavior)
        delete m_quackBehavior;

    cout << "~ModelDuck()" << endl;
}
void ModelDuck::display()
{
    cout << "ModelDuck::display()" << endl;
}

int main(void)
{
    MallardDuck md;
    md.display();
    md.performFly();
    md.performQuack();

    ModelDuck modelDuck;
    modelDuck.display();
    modelDuck.performFly();
    modelDuck.performQuack();
    FlyBehavior *fb = new FlyRecketPower();
    modelDuck.setFlyBehavior(fb);
    QuackBehavior *qb = new Squack();
    modelDuck.setQuackBehavior(qb);
    modelDuck.performFly();
    modelDuck.performQuack();

    return 0;
}