设计模式之策略模式(Strategy)

参考《设计模式：可复用面向对象软件的基础》、《大话设计模式》以及百度

策略模式属于对象行为模式中的一种。

意图： 定义一系列的算法，把它们一个个封装起来，并且使他们可相互替换。策略模式使得算法可独立于使用它的客户而变化。

以缓冲算法为例，缓冲算法有：

LFU：最近不经常使用算法。 Least frequently used replace algorithm

LRU：最近最少使用算法。    Least recently used replace algorithm

ARC：自适应缓存替换算法。Automatic Resource Compilation

MRU：最近最常使用算法。   Most commonly recently used algorithm

UML图网上找的一个类似的图，后面自己会重新画一个UML图

替换算法定义

class ReplaceAlgorithm
{
public:
	virtual void Replace() = 0;
};

//四种具体的替换算法  
class LFU_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
	void Replace() 
	{
		cout << "Least frequently used replace algorithm" << endl;
	}
};

class LRU_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
	void Replace() 
	{
		cout << "Least recently used replace algorithm" << endl;
	}
};

class ARU_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
	void Replace() 
	{
		cout << "Automatic Resource Compilation" << endl;
	}
};

class MRU_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
	void Replace()
	{
		cout << "Most commonly recently used algorithm" << endl;
	}
};

方法一 通过传入一个指针参数，调用指定的算法。暴露了太多的细节

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

方法二  通过一个参数，此时是一个标签指定一个算法。此时客户只需要知道算法相应的标签，而不需要知道算法。下面有 简单工厂模式和策略模式结合起来使用

enum RA
{
	LFU, LRU, ARU, MRU
}; //标签  
class Cache
{
private:
	ReplaceAlgorithm *m_ra;
public:
	Cache(enum RA ra)
	{
		if (ra == LFU)
			m_ra = new LFU_ReplaceAlgorithm();
		else if (ra == LRU)
			m_ra = new LRU_ReplaceAlgorithm();
		else if (ra == ARU)
			m_ra = new ARU_ReplaceAlgorithm();
		else if (ra == MRU)
			m_ra = new MRU_ReplaceAlgorithm();
		else
			m_ra = NULL;
	}
	~Cache() {
		delete m_ra;
	}
	void Replace() {
		m_ra->Replace();
	}
};

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

方法三 利用模板来实现，通过模板参数指定调用的算法

template <class RA>
class Cache
{
private:
	RA m_ra;
public:
	Cache() { }
	~Cache() { }
	void Replace() {
		m_ra.Replace();
	}
};

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

整个代码    //代码只是过程。关键是理解思想，学会画UML类图

#include <iostream>
using namespace std;

class ReplaceAlgorithm
{
public:
	virtual void Replace() = 0;
};

//四种具体的替换算法  
class LFU_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
	void Replace() 
	{
		cout << "Least frequently used replace algorithm" << endl;
	}
};

class LRU_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
	void Replace() 
	{
		cout << "Least recently used replace algorithm" << endl;
	}
};

class ARU_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
	void Replace() 
	{
		cout << "Automatic Resource Compilation" << endl;
	}
};

class MRU_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
	void Replace()
	{
		cout << "Most commonly recently used algorithm" << endl;
	}
};


/*
//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
{
	LFU, LRU, ARU, MRU
}; //标签  
class Cache
{
private:
	ReplaceAlgorithm *m_ra;
public:
	Cache(enum RA ra)
	{
		if (ra == LFU)
			m_ra = new LFU_ReplaceAlgorithm();
		else if (ra == LRU)
			m_ra = new LRU_ReplaceAlgorithm();
		else if (ra == ARU)
			m_ra = new ARU_ReplaceAlgorithm();
		else if (ra == MRU)
			m_ra = new MRU_ReplaceAlgorithm();
		else
			m_ra = NULL;
	}
	~Cache() {
		delete m_ra;
	}
	void Replace() {
		m_ra->Replace();
	}
};

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<LFU_ReplaceAlgorithm> cache; //模板实参  
	cache.Replace();
	return 0;
}