2.策略模式

UML图

代码 main.cpp #include "Strategy.h" #include "Context.h" void test() { Context* pContext = nullptr; /* StrategyA */ pContext = new Context(new StrategyA()); pContext->contextInterface(); /* StrategyB */ pContext = new Context(new StrategyB()); pContext->contextInterface(); /* StrategyC */ pContext = new Context(new StrategyC()); pContext->contextInterface(); delete pContext; pContext = nullptr; } int main() { test(); system("pause"); } Strategy.h #pragma once #include <iostream> using namespace std; /* 策略模式：定义了算法家族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化，不会影响到使用算法的用户。 */ /* 抽象策略基类:定义所有支持算法的公共接口 */ class Strategy { public: virtual void algorithmInterface() = 0; }; /* 策略A */ class StrategyA :public Strategy { public: virtual void algorithmInterface()override { cout << "算法A实现" << endl; } }; /* 策略B */ class StrategyB :public Strategy { public: virtual void algorithmInterface()override { cout << "算法B实现" << endl; } }; /* 策略C */ class StrategyC :public Strategy { public: virtual void algorithmInterface()override { cout << "算法C实现" << endl; } }; Context.h #pragma once #include "Strategy.h" /* 笔者感受：使用类C操控类A继承体系A1，A2，A3中公有对外暴露接口。 利用一个额外的类，(1)将strategy抽象策略基类，作为额外类的入参； (2)将strategy抽象策略基类作为额外类的成员变量，利用多态原理，接收外面传来的具体抽象策略。 (3)对外暴露的接口中，使用成员变量抽象策略基类，调用策略继承体系中的子类们都需要继承的纯虚函数接口。 即可，使用额外类操控策略继承体系中公有对外暴露的接口了。 */ class Context { public: Context(Strategy* pStrategy) :m_pStrategy(pStrategy) {} void contextInterface(); private: Strategy* m_pStrategy{ nullptr }; }; void Context::contextInterface() { m_pStrategy->algorithmInterface(); } 策略模式+简单工厂 优点：策略模式+简单工厂：可以完全将策略继承体系与用户端完全剥离开来，将策略继承体系完全封装起来，对用户完全不可见。总结： 类C通过没什么信息含量的枚举作为入参，利用简单工厂生成类A继承体系中的各子类A1、A2、A3。同时，用基类A作为类C的成员变量，接一下刚生成的类A的子类。类C对外统一暴露一个接口，该接口中，类C的成员变量类A调用继承体系公有对外暴露的接口func()。 main.cpp #include "StrategyFactory.h" /* 策略方法+简单工厂：可以将策略继承体系完全剥离开来，完全封装起来，对用户完全不可见。 */ void test() { StrategyFactory* pStrategyFactory = nullptr; /* StrategyA */ pStrategyFactory = new StrategyFactory(StrategyType::eStrategyA); pStrategyFactory->contextInterface(); /* StrategyB */ pStrategyFactory = new StrategyFactory(StrategyType::eStrategyB); pStrategyFactory->contextInterface(); /* StrategyC */ pStrategyFactory = new StrategyFactory(StrategyType::eStrategyC); pStrategyFactory->contextInterface(); delete pStrategyFactory; pStrategyFactory = nullptr; } int main() { test(); system("pause"); } Strategy.h #pragma once #include <iostream> using namespace std; /* 策略模式：定义了算法家族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化，不会影响到使用算法的用户。 */ /* 抽象策略基类:定义所有支持算法的公共接口 */ class Strategy { public: virtual void algorithmInterface() = 0; }; /* 策略A */ class StrategyA :public Strategy { public: virtual void algorithmInterface()override { cout << "算法A实现" << endl; } }; /* 策略B */ class StrategyB :public Strategy { public: virtual void algorithmInterface()override { cout << "算法B实现" << endl; } }; /* 策略C */ class StrategyC :public Strategy { public: virtual void algorithmInterface()override { cout << "算法C实现" << endl; } }; StrategyFactory.h #pragma once #include "Strategy.h" /* 我的感受：使用类C操控类A继承体系A1，A2，A3中公有对外暴露接口。 利用一个额外的类，(1)将strategy抽象策略基类，作为额外类的入参； (2)将strategy抽象策略基类作为额外类的成员变量，利用多态原理，接收外面传来的具体抽象策略。 (3)对外暴露的接口中，使用成员变量抽象策略基类，调用策略继承体系中的子类们都需要继承的纯虚函数接口。 即可，使用额外类操控策略继承体系中公有对外暴露的接口了。 */ enum StrategyType { eStrategyA, eStrategyB, eStrategyC }; class StrategyFactory { public: StrategyFactory(StrategyType nType); ~StrategyFactory(); void contextInterface(); private: Strategy* m_pStrategy{ nullptr }; }; StrategyFactory::StrategyFactory(StrategyType nType) { switch (nType) { case eStrategyA: m_pStrategy = new StrategyA(); break; case eStrategyB: m_pStrategy = new StrategyB(); break; case eStrategyC: m_pStrategy = new StrategyC(); break; } } StrategyFactory::~StrategyFactory() { delete m_pStrategy; m_pStrategy = nullptr; } void StrategyFactory::contextInterface() { m_pStrategy->algorithmInterface(); }