《大话设计模式》C++实现：02 策略模式（四）——（策略模式+简单工厂）

文章目录

• • 1、好处
  • 2、代码
  • • 2.1、结果
    • 2.2、代码
    • • 2.2.1、Strategy.h
      • 2.2.2、StrategyFactory.h

1、好处

策略模式+简单工厂：可以完全将策略继承体系与用户端完全剥离开来，将策略继承体系完全封装起来，对用户完全不可见。

抽象总结一下：

（1）类C通过没什么信息含量的枚举作为入参，利用简单工厂生成类A继承体系中的各子类A1、A2、A3。同时，用基类A作为类C的成员变量，接一下刚生成的类A的子类。

（2）类C对外统一暴露一个接口，该接口中，类C的成员变量类A调用继承体系公有对外暴露的接口func()。

至此，用户感知到的只有类C和代表子策略的枚举，用户只需要类C的头文件即可，彻底不再依赖类A继承体系了。

2、代码

2.1、结果

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");
}
           

2.2、代码

2.2.1、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;
	}
};
           

2.2.2、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();
}