行为型设计模式之策略模式【设计模式系列】

系列文章目录

C++技能系列
Linux通信架构系列
C++高性能优化编程系列
深入理解软件架构设计系列
高级C++并发线程编程
设计模式系列

期待你的关注哦！！！

现在的一切都是为将来的梦想编织翅膀，让梦想在现实中展翅高飞。
Now everything is for the future of dream weaving wings, let the dream fly in reality.

一、策略模式介绍

⚠️ 意图：
定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

⚠️ 主要解决：
在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。

⚠️ 何时使用：
一个系统有许多许多类，而区分它们的只是他们直接的行为。

⚠️ 如何解决：
将这些算法封装成一个一个的类，任意地替换。

在策略模式（Strategy Pattern）中一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。
在策略模式定义了一系列算法或策略，并将每个算法封装在独立的类中，使得它们可以互相替换。通过使用策略模式，可以在运行时根据需要选择不同的算法，而不需要修改客户端代码。
在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

图1_1 策略模式类图

二、策略模式优缺点

2.1 优点

1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。

2.2 缺点

1、策略类会增多。 2、所有策略类都需要对外暴露。

三、策略模式使用场景

1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

四、策略模式实现

ReplaceAlgorithm是一个抽象类，定义了算法的接口，有三个类继承自这个抽象类，也就是具体的算法实现。Cache类中需要使用替换算法，因此维护了一个 ReplaceAlgorithm的对象。

首先给出替换算法的定义。

//抽象接口
class ReplaceAlgorithm
{
    
    
public:
	virtual void Replace() = 0;
};
//三种具体的替换算法
class LRU_ReplaceAlgorithm : public ReplaceAlgorithm
{
    
    
public:
	void Replace() {
    
     cout<<"Least Recently Used replace algorithm"<<endl; }
};
 
class FIFO_ReplaceAlgorithm : public ReplaceAlgorithm
{
    
    
public:
	void Replace() {
    
     cout<<"First in First out replace algorithm"<<endl; }
};
class Random_ReplaceAlgorithm: public ReplaceAlgorithm
{
    
    
public:
	void Replace() {
    
     cout<<"Random replace algorithm"<<endl; }
};

接着给出Cache的定义，这里很关键，Cache的实现方式直接影响了客户的使用方式，其关键在于如何指定替换算法。

方式一：直接通过参数指定，传入一个特定算法的指针。

//Cache需要用到替换算法
class Cache
{
    
    
private:
	ReplaceAlgorithm *m_ra;
public:
	Cache(ReplaceAlgorithm *ra) {
    
     m_ra = ra; }
	~Cache() {
    
     delete m_ra; }
	void Replace() {
    
     m_ra->Replace(); }
};

如果用这种方式，客户就需要知道这些算法的具体定义。只能以下面这种方式使用，可以看到暴露了太多的细节。

int main()
{
    
    
	Cache cache(new LRU_ReplaceAlgorithm()); //暴露了算法的定义
	cache.Replace();
	return 0;
}

方式二：也是直接通过参数指定，只不过不是传入指针，而是一个标签。这样客户只要知道算法的相应标签即可，而不需要知道算法的具体定义。

//Cache需要用到替换算法
enum RA {
    
    LRU, FIFO, RANDOM}; //标签
class Cache
{
    
    
private:
	ReplaceAlgorithm *m_ra;
public:
	Cache(enum RA ra) 
	{
    
     
		if(ra == LRU)
			m_ra = new LRU_ReplaceAlgorithm();
		else if(ra == FIFO)
			m_ra = new FIFO_ReplaceAlgorithm();
		else if(ra == RANDOM)
			m_ra = new Random_ReplaceAlgorithm();
		else 
			m_ra = NULL;
	}
	~Cache() {
    
     delete m_ra; }
	void Replace() {
    
     m_ra->Replace(); }
};

相比方式一，这种方式用起来方便多了。其实这种方式将简单工厂模式与策略模式结合在一起，算法的定义使用了策略模式，而Cache的定义其实使用了简单工厂模式。

int main()
{
    
    
	Cache cache(LRU); //指定标签即可
	cache.Replace();
	return 0;
}

上面两种方式，构造函数都需要形参。构造函数是否可以不用参数呢？下面给出第三种实现方式。

方式三：利用模板实现。算法通过模板的实参指定。当然了，还是使用了参数，只不过不是构造函数的参数。在策略模式中，参数的传递难以避免，客户必须指定某种算法。

//Cache需要用到替换算法
template <class RA>
class Cache
{
    
    
private:
	RA m_ra;
public:
	Cache() {
    
     }
	~Cache() {
    
     }
	void Replace() {
    
     m_ra.Replace(); }
};

使用方式如下：

int main()
{
    
    
	Cache<Random_ReplaceAlgorithm> cache; //模板实参
	cache.Replace();
	return 0;
}