Head First 设计模式——chapter1 策略模式C++实现

设计模式：

        设计模式可以告诉我们如何组织类和对象以解决某种问题。构造OO系统的经验被整合成了不同的设计模式。建立可维护的OO系统，要点在于随时想到系统以后可能需要的变化及应对变化的原则。模式是针对设计问题的通用解决方案，可以让开发人员之间有共享的语言，能最大化沟通价值。

策略模式的原则：

一、 封装变化

找出应用中可能需要变化之处，将其独立出来，不要和不需要变化的代码混在一起

将鸭子类和容易改变的飞行，呱呱叫类分开。

二、针对接口编程，而不是针对实现

将具体行为编写在飞行行为，呱呱叫行为类中，而非对每个鸭子类实现行为接口。使得这些行为与鸭子类无关，可以被其他对象复用。

三、多用组合，少用继承

将鸭子的行为和鸭子类组合使用，组合有更大的弹性。

总结：

策略模式:

        将行为想象为一族算法，定义算法族，分别封装起来，让他们之间可以互相替换，使得算法的变化独立于使用算法的客户。

// we have defined the necessary header files here for this problem.
// If additional header files are needed in your program, please import here.
#include <string>
#include <stdio.h>
#include <iostream>

//fly行为抽象类
class FlyBehavior {
public:
    virtual void fly()=0;
    virtual ~FlyBehavior (){}
};

//会飞的鸭子
class FlywithWings :public FlyBehavior {
public:
    void fly() { printf("I'm flying\n"); }
};

//不会飞的鸭子 eg：橡皮鸭
class FlyNoWay :public FlyBehavior {
public:
    void fly() { printf("I can't fly\n"); }
};

//用火箭动力飞的鸭子
class FlayRocketPowered :public FlyBehavior {
public:
    void fly() { printf("I'm flying with a rocket\n"); }
};

//quack行为抽象类
class QuackBehavior {
public:
    virtual void quack()=0;
     virtual ~QuackBehavior (){}
};


//不同叫声的鸭子
class Quack :public QuackBehavior {
public:
    void quack() { printf("Quack...\n"); }
};

class MuteQuack :public QuackBehavior {
public:
    void quack() { printf("silence\n"); }
};

class Squeak :public QuackBehavior {
public:
    void quack() { printf("squaek...\n"); }
};


class Duck { 
public:
    Duck(QuackBehavior*qb,FlyBehavior* fb):quackBehavior(qb),flyBehavior(fb){}
    void performerQuack() { quackBehavior->quack(); }
    void performerFly() { flyBehavior->fly(); }
    virtual void display()=0;

    //在运行时可以改变鸭子行为
    void setQuackBehavior(QuackBehavior* qb) { quackBehavior = qb; }
    void setFlyBehavior(FlyBehavior* fb) { flyBehavior = fb; }

    virtual ~Duck() { printf("delete duck\n"); delete quackBehavior;  delete flyBehavior; }
private:
    QuackBehavior *quackBehavior;
    FlyBehavior *flyBehavior;
};

//野鸭
class MallardDuck :public Duck
{
public:
    MallardDuck(QuackBehavior* qb=new Quack(), FlyBehavior* fb=new FlywithWings()):Duck(qb, fb) {
        display();
    }
    void display() { printf("I'm a really Mallard Duck\n"); }
    ~MallardDuck() { printf("delete MallardDuck\n"); }
};

//模型鸭
class ModelDuck :public Duck
{
public:
    ModelDuck(QuackBehavior* qb = new Quack(), FlyBehavior* fb = new FlyNoWay()):Duck(qb,fb) {
        display();
    }
    void display() { printf("I'm a model Duck\n"); }
    ~ModelDuck() { printf("delete ModelDuck\n"); }
};

void test()
{
    Duck* mallard = new MallardDuck();

    mallard->performerFly();
    mallard->performerQuack();
    delete mallard;

    printf("\n");

    Duck* modelduck = new ModelDuck();
    modelduck->performerFly();
    modelduck->performerQuack();
    modelduck->setFlyBehavior(new FlayRocketPowered());
    modelduck->performerFly();
    modelduck->setQuackBehavior(new Squeak());
    modelduck->performerQuack();

    delete modelduck;
}
int main()
{
    test();

    system("pause");
    return 0;
}