设计模式--策略模式

      策略模式其实就从字面理解就能知道大概的意思，无非就是解决某种问题的时候，可能有好几种解决方法，这些方法都可以称为策略，无非是选用哪一个的问题，如果看中了哪个策略，只要将这个策略应用到该问题上就可以了。
     从以上的总结中不难看出，其实策略模式的核心思想其实就是将算法实现抽象剥离出对象类（即针对接口编程 ， 而不是针对实现编程）
     
      那么策略模式为什么好呢？ 接下来先来看个传统的设计方法，也就是最简单的继承
     
      现在有一个鸭子的父类
     

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

    里面有一个接口fly，是需要子类去实现的，然后我有了一个家养的鸭子类去重载这个方法
  

class fDuck : public cDuck
{
public:
    fDuck();
    ~fDuck();
    void fly();
};

void fDuck::fly()
{
    printf("I can't fly\n");
}

因为是家养的所以当然是不能飞的（呵呵），这样，我们就实现了自己养的鸭子的实现，现在看看没有什么问题，但是现在我需要一直野生的鸭子怎么办呢？
    野生的鸭子是可以自己飞的，那你可能会说很简单啊，我只要重载这个fly接口，重现创建一个野鸭子的类就可以了
   

class yDuck : public cDuck
{
public:
    yDuck();
    ~yDuck();
    void fly();
};

void yDuck::fly()
{
    printf("I can fly\n");
}

没错，这样是没什么问题。可是不知道你们发现没，如果我现在要求出现一只能飞的太空鸭子，你是不是又要去完全的重写一遍fly接口？ 这就带来了复用性的问题，就是说以后不管有几个鸭子，只要能飞，我都要去实现这个fly的接口（也就是复制黏贴下），这太恐怖了吧，简直就是灾难，现在的情况用之前总结的话说就是编程依赖于实现了，（如果你不写fly的接口，你就不能完成你的鸭子的创建过程）
这时候，就应该是我们策略模式登场的时候了!!!!!!!!!!!!!!!

      策略模式的思想就是将功能算法这类解决问题的策略剥离出类，这样就独立于类的实现了，通过组合的方式包含在该类中，更进一步的方式就是将策略类抽象出来，通过针对接口进行编程
       修改后的代码：

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

增加了一个对于fly这个功能的抽象类，对于以后不同鸭子的不同飞行方式都是基于这个类的，这个类就是我们的策略基类。
接下来对于野鸭子的飞行方式进行实现

class cduckfly : public duckfly
{
public:
    cduckfly(){}
    ~cduckfly(){}
    void fly()
    {
        printf("I can fly\n");
    }
};

家养的鸭子：

class fduckfly : public duckfly
{
public:
    fduckfly(){}
    ~fduckfly(){}
    void fly()
    {
        printf("I can't fly\n");
    }
};

有了这两个公共的飞行类后，各种鸭子类的飞行方法就可以剥离出来了，在这里重新给鸭子的基类一个设定飞行模式的方法，用于动态的改变飞行方法

class cDuck
{
public:
    cDuck();
    ~cDuck();
    void swim();
    void setFlyMethod(duckfly* tmpfly);
    virtual void fly() = 0;
protected:
    duckfly* m_fly;
};

cDuck::cDuck()
{
    m_fly = NULL;
}

cDuck::~cDuck()
{

}

void cDuck::swim()
{
    printf("I can swim\n");
}

void cDuck::setFlyMethod(duckfly* tmpfly)
{
    m_fly = tmpfly;
}

这样一来，可以发现，不论我想要什么类型的鸭子，最终我都可以通过改变他们的飞行方法让他们重生了。这样就避免了代码重复和复用的问题了
主函数：

int _tmain(int argc, _TCHAR* argv[])
{
    duckfly* flymt1 = new fduckfly();
    duckfly* flymt2 = new cduckfly();
    cDuck *cd1 = new fDuck();
    cd1->setFlyMethod(flymt1);
    cd1->fly();

    cDuck *cd2 = new yDuck();
    cd2->setFlyMethod(flymt2);
    cd2->fly();

    system("pause");

    return 0;
}

代码还可以进一步优化，这里就不做具体的优化了