1.工厂模式和策略模式
工厂模式和策略模式比较相似,通过标签屏蔽子类的具体实现这是一种比较好的方法。用户类cache维护一个工厂抽象类ReplaceAlgorithm ,并通过标签生成相应的ReplaceAlgorithm 子类。
http://blog.csdn.net/wuzhekai1985/article/details/6665197
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; }
};
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(); }
};
2.单例模式
单例模式之前花了一部分时间研究,现在总结一下
简单单例模式,线程安全,但是在单例调单例的时候会出问题,因为调用第二个单例的时候,可能第二个单例还没有创建
class Singleton
{
public:
static Singleton* GetInstance()
{
return &m_instance;
}
private:
Singleton(){};
Singleton(Singleton const&);
Singleton& operator=(Singleton const&);
static Singleton m_instance;
};
Singleton Singleton::m_instance;
boost单例模式:
class QMManager
{
protected:
struct object_creator
{
object_creator()
{
QMManager::instance();
}
inline void do_nothing() const {}
};
static object_creator create_object_;
QMManager();
~QMManager(){};
public:
static QMManager *instance()
{
static QMManager instance;
return &instance;
}
};
QMManager::object_creator QMManager::create_object_;
以下是boost模板类:
template <typename T>
class Singleton
{
struct object_creator
{
object_creator() { Singleton<T>::GetInstance(); }
inline void do_nothing()const {}
};
static object_creator create_object;
public:
typedef T object_type;
static object_type& GetInstance()
{
static object_type obj;
//据说这个do_nothing是确保create_object构造函数被调用
//这跟模板的编译有关
create_object.do_nothing();
return obj;
}
};
template <typename T> typename Singleton<T>::object_creator Singleton<T>::create_object;
class QMManager
{
protected:
QMManager();
~QMManager() {};
friend class Singleton<QMManager>;
public:
void do_something() {};
};
int main()
{
Singleton<QMManager>::instance()->do_something();
return 0;
}
3.桥接模式
大量使用基类多态,这里是别人的例子代码:
//操作系统
class OS
{
public:
virtual void InstallOS_Imp() {}
};
class WindowOS: public OS
{
public:
void InstallOS_Imp() { cout<<"安装Window操作系统"<<endl; }
};
class LinuxOS: public OS
{
public:
void InstallOS_Imp() { cout<<"安装Linux操作系统"<<endl; }
};
//计算机
class Computer
{
public:
virtual void InstallOS(OS *os) {}
};
class AppleComputer: public Computer
{
public:
void InstallOS(OS *os) { os->InstallOS_Imp(); }
};
int main()
{
OS *os1 = new WindowOS();
OS *os2 = new LinuxOS();
Computer *computer1 = new AppleComputer();
computer1->InstallOS(os1);
computer1->InstallOS(os2);
}
4.观察者模式
Object保存多个observer指针,一旦object有时间发生,遍历保存的observer指针,调用observer中的notify函数通知。感觉这种设计很直观,不过boost中也实现了观察者模式好像使用siginal2,QT的观察者模式局简单多了直接connect搞定
5.中介模式
这个模式和我写的一个消息队列的程序有点像,有时间的时候发上来
6.状态模式
这个模式有点意思,有点和观察者模式相似,和消息队列也搭得上边(感觉所有的东西都可以用消息队列来做。。。。)状态模式可以想象成这样:4个状态对应4个子类,某一个子类被触发了某个状态,然后notify基类,或者说调用基类的setstatus,基类获取状态,再根据条件调用相应子类的状态响应函数。或者叫状态选择器?