《大話設計模式》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();
}