（三）策略模式-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) = 0;
};

//具体策略类
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 = 0, sum = 0;
    for (int i = 0; i < len; i++)
    {
        sum += a[i];
    }
    score = sum / len;
    return score;
}

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

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

    std::sort(a, a + len);
    for (int i = 1; i < len - 1; i++)
    {
        sum += a[i];
    }
    score = sum / (len - 2);
    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 0;
        }

    }

};


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 0;
}

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

也传入了一个长度参数。