C++设计模式感想

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，基类获取状态，再根据条件调用相应子类的状态响应函数。或者叫状态选择器？