C++设计模式--策略模式解析(head first 设计模式C++实现)

策略模式

1.策略模式体现的设计原则:

• 找出应用中可能需要变化之处把他们独立出来,不要和哪些不需要变化的代码混在一起。(把会变的部分取出并封装起来，以便以后可以轻易地扩充此部分，而不影响不需要变化的其他部分 PS:将鸭子类中的变化部分独立出来)
• 针对接口编程，而不是针对实现编程。(针对接口编程真正的意思是针对超类型编程。关键在多态利用多态,程序可以针对超类型编程，执行时会根据实际状况执行，不会被邦死在超类型的行为上。继承接口子类再实现不算针对接口编程,子类不应该去实现,而是利用多态直接用，继承接口重新实现方法的类。PS:类与类的三大关系 复合 继承 委托 鸭子类可以把变化的飞行,叫委托给其它抽象类)
• 多用组合,少用继承 组合是have-a 继承是is-a 鸭子有飞叫 飞叫不是鸭子
  2.策略模式定义了算法族,分别封装起来,让它们之间可以互相替换,此模式让算法的变化独立使用算法的客户 (策略模式将鸭子的各种行为抽象为不同的策略这样可以改变策略不影响原来的代码)

---

例子

---

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


class QuackBehavior{
    public:
        QuackBehavior(){};        
        ~QuackBehavior(){};
        virtual void quack()=0;        
};


class Duck{
    public:
        Duck(){};        
        ~Duck(){
            delete flybehavior;
            flybehavior=nullptr;
            delete quackbehavior;
            quackbehavior=nullptr;
        };
        void swim(){
            cout<<" every duck can swimming"<<endl; 
        }
        virtual void display()=0;

        void performQuack(){
            if(quackbehavior)
                quackbehavior->quack();  
        } 

        void performFly(){
            if(flybehavior)
                flybehavior->fly();
        }

        void setFlyBehavior(FlyBehavior* m_fly){
            flybehavior=m_fly;
        }

        void setQuackBehavior(QuackBehavior* m_qua){
            quackbehavior=m_qua;
        }
    private:
        FlyBehavior* flybehavior=nullptr;
        QuackBehavior* quackbehavior=nullptr;

};

class RedheadDuck:public Duck{
    public:
        RedheadDuck(){};     
        ~RedheadDuck(){};
        virtual void display(){
            cout<<" this is a headreadduck"<<endl;
            performFly();
            performQuack();
        }     
};


class RubberDuck:public Duck{
    public:
        RubberDuck(){};     
        ~RubberDuck(){};
        virtual void display(){
            cout<<" this is a rubberduck"<<endl;
            performFly();
            performQuack();
        }     
};

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

class FlyNoWay:public FlyBehavior{
    public:
        virtual void fly(){
            cout<<" fly with no way"<<endl;
        } 
};

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

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


int main(){

    RedheadDuck* readheadduck=new RedheadDuck;
    RubberDuck* rubberduck=new RubberDuck;

    Quack* zhizhiquack = new Quack;
    Squack* rubberzhizhiquack = new Squack;

    FlyWithWings* canfly = new FlyWithWings;
    FlyNoWay* cannofly = new FlyNoWay;

    readheadduck->display();
    rubberduck->display();

    readheadduck->setFlyBehavior(canfly);
    readheadduck->setQuackBehavior(zhizhiquack); 
    rubberduck->setFlyBehavior(cannofly);
    rubberduck->setQuackBehavior(rubberzhizhiquack);
    readheadduck->display();
    rubberduck->display();

    
    readheadduck->setFlyBehavior(nullptr);
    readheadduck->setQuackBehavior(nullptr); 
    rubberduck->setFlyBehavior(nullptr);
    rubberduck->setQuackBehavior(nullptr);
    readheadduck->display();
    rubberduck->display();



    system("pause");
    return 0;
}