（三）策略模式-C++实现

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

三种角色：

1、策略：一个抽象类，这个接口定义了若干个算法标识，即多个虚函数，这些个算法的实现在不同场景可能会不一样。

2、具体策略：它实现了策略，实现抽象类中定义个算法标识，即给出具体算法实现。

3、上下文：它依赖于策略抽象类，即上下文 包含 策略声明的指针，上下文中提供一个方法，该方法委托策略调用具体策略所实现的算法。

C++实现包含三个文件，一个头文件策略类的声明strategy.h，两个源文件strategy.cpp 和context.cpp，一个是具体策略中方法的实现，另一个是上下文的源文件，将测试用的主函数也放在这个文件中。

1、strategy.h

 #ifndef _STRATEGY_H_
 #define _STRATEGY_H_

 //抽象策略类
 class ComputeStrategy{
 public:
     //这里参数是a[] 实际上相当于指针 所以想获取其长度 非常困难（应该获取不了） 所以传入一个个数
     virtual double computeScore(double a[], int len) = ;
 };

 //具体策略类
 class StrategyOne : public ComputeStrategy
 {
 public:
     double computeScore(double a[], int len);
 };

 class StrategyTwo : public ComputeStrategy
 {
 public:
     double computeScore(double a[], int len);
 };

 class StrategyThree : public ComputeStrategy
 {
 public:
     double computeScore(double a[], int len);
 };

 #endif

2、strategy.cpp

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

 double StrategyOne::computeScore(double a[], int len)
 {
     double score = , sum = ;
     for (int i = ; i < len; i++)
     {
         sum += a[i];
     }
     score = sum / len;
     return score;
 }

 double StrategyTwo::computeScore(double a[], int len)
 {
     double score = , multi = ;
     for (int i = ; i < len; i++)
     {
         multi *= a[i];
     }
     score = std::pow(multi, 1.0 / len);
     return score;
 }

 double StrategyThree::computeScore(double a[], int len)
 {
     double score = , sum = ;
     if ( >= len)
     {
         return 0.0;
     }

     std::sort(a, a + len);
     for (int i = ; i < len - ; i++)
     {
         sum += a[i];
     }
     score = sum / (len - );
     return score;

 }

3、context.cpp

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

 //上下文类 依赖策略类
 class Context
 {
 public:
     ComputeStrategy* myStrategy;
 public:
     void setStrategy(ComputeStrategy* strategy)
     {
         myStrategy = strategy;
     }
     double getPersonScore(double a[], int len)
     {
         if (NULL != myStrategy)
         {
             std::cout << "myStrategy not null" << std::endl;
             return myStrategy->computeScore(a, len);
         }
         else
         {
             return ;
         }

     }

 };

 int main()
 {
     Context *game = new Context();
     double a[] = { 9.12, 9.25, 8.87, 9.99, 6.99, 7.88 };
     int len = sizeof(a) / sizeof(double);

     game->setStrategy(new StrategyOne());
     double r1 = game->getPersonScore(a,len);
     std::cout << "strategy one: " << r1 << std::endl;

     game->setStrategy(new StrategyTwo());
     double r2 = game->getPersonScore(a, len);
     std::cout << "strategy two: " << r2 << std::endl;

     game->setStrategy(new StrategyThree());
     double r3 = game->getPersonScore(a, len);
     std::cout << "strategy three : " << r3 << std::endl;

     delete game;
     game = NULL;

     return ;
 }

在实现中，值得注意的是，设置具体的策略的时候，函数的形参是类的指针。然后本例子实现的是一个统计分数数组的平均分的不同策略，而C++中在数组作为参数的时候，实际上是退化为指针了，而这样是无法获取数组的长度的，所以

也传入了一个长度参数。