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