策略模式

策略模式：

定义了算法族，分别封装起来，让它们之间可以互换；
此模式让算法的变化独立于使用算法的客户;

下面一个简单例子，让我们来演示这个模式。

#include "stdafx.h"

#include <stdio.h>

 

//算法接口类
class IFly

{

public:

    virtual void fly() = 0;

};

 

//实现A算法
class FlyA: public IFly

{

public:

    void fly()

    {

       printf("I am flying! /n");

    }

};

//实现B算法
class FlyB: public IFly

{

public:

    void fly()

    {

       printf("I am flying  with rocket! /n");

    }

};

/*

Object接口类

设计原则：

1:使用组合方式把Object的Fly形为集成到对象中，而不是继续的方式。(多用组合，少用继续)

2:将Object中不会改变的方法集中在IObject，将经常变动的方法通过IFly分离出去（真对接口编程，而不是真对实现编程）

*/

 

class IDuck

{

public:

    IDuck():m_pFly(NULL){ }

   

    void SetFly(IFly *pFly)

    {

       if (m_pFly)

       {

           delete m_pFly;

       }

       m_pFly = pFly;

    }

   

    void DuckFly()

    {

       if (m_pFly)

       {

           m_pFly->fly();

       }

    }

   

    ~IDuck()

    {

       if (m_pFly)

       {

           delete m_pFly;

           m_pFly = NULL;

       }

    }

 

protected:

    IFly *m_pFly;

 

};

 //对象1
class MallardDuck : public IDuck

{

public:

    MallardDuck()

    {

       printf("I am a Mallard Duck! /n ");

       m_pFly = new FlyA();

    }

};

 //对象2

class ModelDuck : public IDuck

{

public:

    ModelDuck()

    {

       printf("I am a Model Duck! /n ");

       m_pFly = new FlyB();

    }

};

 

 

int _tmain(int argc, _TCHAR* argv[])

{

    MallardDuck MyDuck1;

    MyDuck1.DuckFly();

    MyDuck1.SetFly(new FlyB());//对象形为（算法）之间的切换

    MyDuck1.DuckFly();

 

    ModelDuck MyDuck2;

    MyDuck2.DuckFly();

    return 0;

}