设计模式(六)策略模式C++

策略模式定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。该模式使得算法可独立于使用它的客户而变化。

策略模式为了适应不同的需求，只把变化点封装了，这个变化点就是实现不同需求的算法，但是，用户需要知道各种算法的具体情况。就像加班工资，不同的加班情况，有不同的算法。我们不能在程序中将计算工资的算法进行硬编码，而是能自由的变化的。这就是策略模式。

角色：

    抽象策略角色（Strategy）： 抽象策略类。

    具体策略角色(ConcreteStrategy)：封装了继续相关的算法和行为。

    环境角色(Context)：持有一个策略类的引用，最终给客户端调用。

下面是最直观最简单的策略模式

#include <iostream>
#include <windows.h>
using namespace std;

// The abstract strategy
class Strategy
{
public:
  virtual void AlgorithmInterface() = 0;
};

class ConcreteStrategyA : public Strategy
{
public:
  void AlgorithmInterface()
  {
    cout << "I am from ConcreteStrategyA." << endl;
  }
};

class ConcreteStrategyB : public Strategy
{
public:
  void AlgorithmInterface()
  {
    cout << "I am from ConcreteStrategyB." << endl;
  }
};

class ConcreteStrategyC : public Strategy
{
public:
  void AlgorithmInterface()
  {
    cout << "I am from ConcreteStrategyC." << endl;
  }
};

class Context
{
public:
  Context(Strategy *pStrategyArg) : pStrategy(pStrategyArg)
  {
  }
  void ContextInterface()
  {
    pStrategy->AlgorithmInterface();
  }
private:
  Strategy *pStrategy;
};

int main()
{
  // Create the Strategy
  Strategy *pStrategyA = new ConcreteStrategyA;
  Strategy *pStrategyB = new ConcreteStrategyB;
  Strategy *pStrategyC = new ConcreteStrategyC;
  Context *pContextA = new Context(pStrategyA);
  Context *pContextB = new Context(pStrategyB);
  Context *pContextC = new Context(pStrategyC);
  pContextA->ContextInterface();
  pContextB->ContextInterface();
  pContextC->ContextInterface();

  if (pStrategyA) delete pStrategyA;
  if (pStrategyB) delete pStrategyB;
  if (pStrategyC) delete pStrategyC;

  if (pContextA) delete pContextA;
  if (pContextB) delete pContextB;
  if (pContextC) delete pContextC;

  system("pause");

  return 0;
}      

在实际操作的过程中，我们会发现，在main函数中，也就是在客户端使用策略模式时，会创建非常多的Strategy，而这样就莫名的增加了客户端的压力，让客户端的复杂度陡然增加了。怎么办？可以把策略直接作为参数传递给Context，但是Context内部要有对资源的释放部分

更改之后如下

#include <iostream>
#include <windows.h>
#define  free_ptr(p) \
if(p) delete p; p = NULL;

using namespace std;

// The abstract strategy
class Strategy
{
public:
  virtual void AlgorithmInterface() = 0;
};

class ConcreteStrategyA : public Strategy
{
public:
  void AlgorithmInterface()
  {
    cout << "I am from ConcreteStrategyA." << endl;
  }
};

class ConcreteStrategyB : public Strategy
{
public:
  void AlgorithmInterface()
  {
    cout << "I am from ConcreteStrategyB." << endl;
  }
};

class ConcreteStrategyC : public Strategy
{
public:
  void AlgorithmInterface()
  {
    cout << "I am from ConcreteStrategyC." << endl;
  }
};

class Context
{
public:
  Context(Strategy *pStrategyArg) : m_pStrategy(pStrategyArg)
  {
  }
  ~Context()
  {
    free_ptr(m_pStrategy);
  }

  void ContextInterface()
  {
    m_pStrategy->AlgorithmInterface();
  }
private:
  Strategy *m_pStrategy;
};

int main()
{
  Context *pContextA = new Context(new ConcreteStrategyA);
  Context *pContextB = new Context(new ConcreteStrategyB);
  Context *pContextC = new Context(new ConcreteStrategyC);
  pContextA->ContextInterface();
  pContextB->ContextInterface();
  pContextC->ContextInterface();


  if (pContextA) delete pContextA;
  if (pContextB) delete pContextB;
  if (pContextC) delete pContextC;

  system("pause");

  return 0;
}      

第三种实现方式是简单工厂+策略模式，通过简单工厂同样能够避免一次创建多个Strategy，代码如下

#include <iostream>
#include <windows.h>
using namespace std;

// Define the strategy type
typedef enum StrategyType
{
  StrategyA,
  StrategyB,
  StrategyC
}STRATEGYTYPE;

// The abstract strategy
class Strategy
{
public:
  virtual void AlgorithmInterface() = 0;
  virtual ~Strategy() = 0; // 谢谢hellowei提出的bug，具体可以参见评论
};

Strategy::~Strategy()
{}

class ConcreteStrategyA : public Strategy
{
public:
  void AlgorithmInterface()
  {
    cout << "I am from ConcreteStrategyA." << endl;
  }

  ~ConcreteStrategyA() {}
};

class ConcreteStrategyB : public Strategy
{
public:
  void AlgorithmInterface()
  {
    cout << "I am from ConcreteStrategyB." << endl;
  }

  ~ConcreteStrategyB() {}
};

class ConcreteStrategyC : public Strategy
{
public:
  void AlgorithmInterface()
  {
    cout << "I am from ConcreteStrategyC." << endl;
  }

  ~ConcreteStrategyC() {}
};

class Context
{
public:
  Context(STRATEGYTYPE strategyType)
  {
    switch (strategyType)
    {
    case StrategyA:
      pStrategy = new ConcreteStrategyA;
      break;

    case StrategyB:
      pStrategy = new ConcreteStrategyB;
      break;

    case StrategyC:
      pStrategy = new ConcreteStrategyC;
      break;

    default:
      break;
    }
  }

  ~Context()
  {
    if (pStrategy) delete pStrategy;
  }

  void ContextInterface()
  {
    if (pStrategy)
      pStrategy->AlgorithmInterface();
  }

private:
  Strategy *pStrategy;
};

int main()
{
  Context *pContext = new Context(StrategyA);
  pContext->ContextInterface();

  if (pContext) delete pContext;

  system("pause");
  return 0;
}