策略模式（Strategy Pattern）

策略模式（Strategy Pattern）

flyfish

#include "stdafx.h"
#include <iostream>
#include <map>
using namespace std;

typedef enum StrategyType
{
    StrategyA,
    StrategyB,
    StrategyC
}STRATEGYTYPE;

class Strategy
{
public:
    virtual void Interface() = 0;
    virtual ~Strategy() = 0;
};

Strategy::~Strategy()
{}

class ConcreteStrategyA : public Strategy
{
public:
    void Interface()
    {
        cout << "ConcreteStrategyA." << endl;
    }

    ~ConcreteStrategyA() {}
};

class ConcreteStrategyB : public Strategy
{
public:
    void Interface()
    {
        cout << "ConcreteStrategyB." << endl;
    }

    ~ConcreteStrategyB() {}
};

class ConcreteStrategyC : public Strategy
{
public:
    void Interface()
    {
        cout << "ConcreteStrategyC." << endl;
    }

    ~ConcreteStrategyC() {}
};

class Context
{
    typedef void (Context::*pFun)();
public:
    void Interface(int type)
    {

        auto it = m_pMessageMap.find(type);
        if (it != m_pMessageMap.end())
        {
            (this->*(it->second))();
        }

    };
private:
    std::map<int, pFun>   m_pMessageMap{
        std::make_pair(STRATEGYTYPE::StrategyA, &Context::InterfaceA),
        std::make_pair(STRATEGYTYPE::StrategyB, &Context::InterfaceB),
        std::make_pair(STRATEGYTYPE::StrategyC, &Context::InterfaceC)
    };

    void InterfaceA()
    {
        m_pStrategy = new ConcreteStrategyA;    
        m_pStrategy->Interface();
    };
    void InterfaceB()
    {
        m_pStrategy = new ConcreteStrategyB;
        m_pStrategy->Interface();
    };
    void InterfaceC()
    {
        m_pStrategy = new ConcreteStrategyC;
        m_pStrategy->Interface();
    };

private:
    Strategy *m_pStrategy;
};

int main()
{
    Context* p = new Context();
    p->Interface(STRATEGYTYPE::StrategyC);
    if (p) delete p;
    system("pause");


}