Strategy模式

Strategy模式

    Strategy模式和Template模式要解决的问题是相同的，都是为了实现业务逻辑具体实现和抽象接口之间的解耦。

Strategy模式将逻辑算法封装到一个类中，通过组合的方式将具体算法的实现放在组合对象中实现，再通过委托的方式

将抽象接口的实现委托给组合对象实现。Strategy模式和Template模式实际上是实现一个抽象接口的两种方式--组合

和继承之间的区别。State也有类似功能。

C++代码示例：

//strategy.h

#ifndef STRATEGY_H
#define STRATEGY_H

class Strategy{

public:
    Strategy();
    virtual ~Strategy();
    virtual void AlgrithmInterface() = 0;
};

class ConcreteStrategyA : public Strategy{

public:
    ConcreteStrategyA();
    virtual ~ConcreteStrategyA();
    void AlgrithmInterface();
};

class ConcreteStrategyB : public Strategy{

public:
    ConcreteStrategyB();
    virtual ~ConcreteStrategyB();
    void AlgrithmInterface();
};

#endif // STRATEGY_H

//strategy.cpp

#include "strategy.h"
#include <iostream>

using std::cout;
using std::endl;

Strategy::Strategy(){

}

Strategy::~Strategy(){

    cout << "~Strategy..." << endl;
}

void Strategy::AlgrithmInterface(){

}

ConcreteStrategyA::ConcreteStrategyA(){

}

ConcreteStrategyA::~ConcreteStrategyA(){

    cout << "~ConcreteStrategyA..." << endl;
}

void ConcreteStrategyA::AlgrithmInterface(){

    cout << "Test ConcreteStrategyA..." << endl;
}

ConcreteStrategyB::ConcreteStrategyB(){

}

ConcreteStrategyB::~ConcreteStrategyB(){

    cout << "~ConcreteStrategyB..." << endl;
}

void ConcreteStrategyB::AlgrithmInterface(){

    cout << "Trest ConcreteStrategyB..." << endl;
}

//context.h

#ifndef CONTEXT_H
#define CONTEXT_H

class Strategy;

class Context{  //这个类是Strategy模式的关键

public:
    Context(Strategy* strategy);
    ~Context();
    void DoAction();
private:
    Strategy* m_strategy;
};

#endif // CONTEXT_H

//context.cpp

#include "context.h"
#include "strategy.h"
#include <iostream>

Context::Context(Strategy* strategy){

    m_strategy = strategy;
}

Context::~Context(){

    if(m_strategy)
        delete m_strategy;
}

void Context::DoAction(){

    m_strategy->AlgrithmInterface();
}

//main.cpp

#include "context.h"
#include "strategy.h"
#include <iostream>

int main()
{
    Strategy* ps;
    ps = new ConcreteStrategyA();
    Context* pc = new Context(ps);
    pc->DoAction();
    if(NULL != pc)
        delete pc;
    return 0;
}
//运行结果：

***简单说一下继承和组合的优缺点： //这里没有对私有保护公有多重继承/组合展开分析,不过优缺点差不多也就这些了

一、继承：

  优点：易于修改和扩展那些被复用的实现。

  缺点：1)破坏了封装性 2)”白盒“复用 3)当父类的实现更改时，所有子类不得不随之改变 4)从父类继承而来的实现在运行

期间不能改变，编译时期就已确定。

二、组合：

  优点：1)"黑盒"复用 2)封装性好 3)实现和抽象的依赖性小 4)可以在运行期间动态定义实现(通过一个指向相同类型的指针，

典型的是指向基类的指针).

  缺点：系统中对象过多等。

//如有欠缺，还望看此博文的朋友补充。。。