「设计模式」 策略模式
replace FIFO_RepIaceAIgorithm ReplaceO ReplaceAIgorithm «abstract» ReplaceO LRU_RepIaceAIgorithm ReplaceO Cache algorithm CacheO —Cache() ReplaceO Random_RepIaceAIgorithm ReplaceO .h文件
//抽象接口 接口/抽象类
class ReplaceAlgorithm
{
public:
virtual void Replace() = 0;
};
//三种具体的替换算法 实现类
class LRU_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
void Replace() { cout<<"Least Recently Used"<<endl; }
};
class FIFO_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
void Replace() { cout<<"First in First out"<<endl; }
};
class Random_ReplaceAlgorithm: public ReplaceAlgorithm
{
public:
void Replace() { cout<<"Random"<<endl; }
};
Cache.h文件 环境类
//Cache需要用到替换算法
class Cache
{
private:
ReplaceAlgorithm *m_ra;
public:
Cache(ReplaceAlgorithm *ra) { m_ra = ra; }
~Cache() { delete m_ra; }
void Replace() { m_ra->Replace(); }
};
main函数 主函数
int main()
{
//switch语句被转移到了此处
Cache cache(new LRU_ReplaceAlgorithm()); //暴露了算法的定义
cache.Replace();
return 0;
}
Cache.h文件
//Cache 的替换算法
class Cache
{
public:
Cache() {}
~Cache() {}
void Replace();
private:
void LRU_ReplaceAlgorithm();
void FIFO_ReplaceAlgorithm();
void Random_ReplaceAlgorithm();
};
Cache.cpp文件
//Cache需要用到替换算法
enum RA {LRU, FIFO, RANDOM}; //标签
main函数
int main()
{
Cache cache(LRU);
cache.Replace();
return 0;
}
策略模式——标准版
.h文件
//抽象接口 接口——策略
class ReplaceAlgorithm
{
public:
virtual void Replace() = 0;
};
//三种具体的替换算法 实现类
class LRU_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
void Replace() { cout<<"Least Recently Used"<<endl; }
};
class FIFO_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
void Replace() { cout<<"First in First out"<<endl; }
};
class Random_ReplaceAlgorithm: public ReplaceAlgorithm
{
public:
void Replace() { cout<<"Random"<<endl; }
};
Cache.h文件 融入了简单工厂
//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(); }
};
main函数 主函数
int main()
{
Cache cache(LRU); //指定标签即可
cache.Replace();
return 0;
}
策略模式——改进版1
改进
传入的参数由指针变为标签
优势
客户只要知道算法的相应标签即可，而不需要知道算法的具体定义【保护实现】
说明
结合了简单工厂模式与策略模式，算法的定义使用了策略模式，而Cache的定义其实使用了简单工厂模式
策略模式——改进版2
改进
利用模板实现
Cache.h文件 环境类
//Cache需要用到替换算法
//此处为模板
template
class Cache
{
private:
RA m_ra;
public:
Cache() { }
~Cache() { }
void Replace() { m_ra.Replace(); }
};
main函数 主函数
int main()
{
Cache<Random_ReplaceAlgorithm> cache; //模板实参
cache.Replace();
return 0;
}
.h文件
//抽象接口 接口——策略
class ReplaceAlgorithm
{
public:
virtual void Replace() = 0;
};
//三种具体的替换算法 实现类
class LRU_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
void Replace() { cout<<"Least Recently Used"<<endl; }
};
class FIFO_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
void Replace() { cout<<"First in First out"<<endl; }
};
class Random_ReplaceAlgorithm: public ReplaceAlgorithm
{
public:
void Replace() { cout<<"Random"<<endl; }
};
策略和工厂有什么区别，什么时候用策略，什么时候用工厂？
定义：定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。
本模式使得算法可独立于使用它的客户而变化。也就是说这些算法所完成的功能一样，对外的接口一样，只是各自实现上存在差异。
Comments