常见的设计模式

单例模式：

构造函数（私有）；

获取构造函数（公有，静态）；

Class Singleton
{
private :
    Singleton(){}
    static Singleton *psingleton;
public:
    static Singleton * GetInstance()
    {
         if(NULL==psingleton)//是否存在实例
         {
             pthread_mutex_lock(&mutex);//加锁，保证多线程安全
             if(NULL==psingleton)
             {
                 psingleton=new Singleton();
             }
             pthread_mutex_unlock(&mutex);
         }
         return psingleton;      
    }
};

观察者监听者模式：

将view的回调函数注册到model中（将监听者的回调函数注册到观察者中）

当model（数据）改变时，调用相应的view回调函数，使view出现新的视图效果。

（多个监听者可能对观察者中的同一数据感兴趣）

**观察者只是感知事情的发生； 监听者只是处理事件；

**当观察者数据变动，通知所有对此数据感兴趣的监听者；

#include <iostream>
#include <string>
#include <memory>
#include <map>
#include <vector>
using namespace std;

//用弱智能指针观察强智能指针，
//弱智能指针调用数据时，先提升为强智能指针，再调用
template <typename T>
bool operator==(const weak_ptr<T> &left, const weak_ptr<T> &right)
{
    return left.lock() == right.lock();
}


class Listener
{
public:
    Listener(string name) :_name(name) {}
    virtual void handleMessage(int msgid) = 0; //抽象方法（纯虚方法）
    string _name;
};


class Listener1 : public Listener //继承
{
public:
    Listener1(string name) :Listener(name) {}
    void handleMessage(int msgid)
    {
        cout << _name << " ";
        switch (msgid)
        {
        case 0:
            cout << " recv 0 msg!" << endl;
            break;
        case 1:
            cout << " recv 1 msg!" << endl;
            break;
        case 2:
            cout << " recv 2 msg!" << endl;
            break;
        }
    }
};


class Listener2 : public Listener
{
public:
    Listener2(string name) :Listener(name) {}
    void handleMessage(int msgid)
    {
        cout << _name << " ";
        switch (msgid)
        {
        case 0:
            cout << " recv 0 msg!" << endl;
            break;
        case 2:
            cout << " recv 2 msg!" << endl;
            break;
        }
    }
};


class Listener3 : public Listener
{
public:
    Listener3(string name) :Listener(name) {}
    void handleMessage(int msgid)
    {
        cout << _name << " ";
        switch (msgid)
        {
        case 1:
            cout << " recv 1 msg!" << endl;
            break;
        case 2:
            cout << " recv 2 msg!" << endl;
            break;
        }
    }
};


class Observer
{
public:
	//将（感兴趣的事件，监听者）添加到事件集合
    void registerListener(weak_ptr<Listener> lp, int msgid)
    {
        map<int, vector<weak_ptr<Listener>>>::iterator it = _ObserMap.find(msgid);
        if (it == _ObserMap.end())
        {
            vector<weak_ptr<Listener>> vec;
            vec.push_back(lp);
            _ObserMap.insert(make_pair(msgid, vec));
        }
        else
        {
            it->second.push_back(lp);
        }
    }
	//删除监听者以及感兴趣的事件
    void deleteListener(weak_ptr<Listener> lp, int msgid)
    {
        map<int, vector<weak_ptr<Listener>>>::iterator it = _ObserMap.find(msgid);
        if (it != _ObserMap.end())
        {
            vector<weak_ptr<Listener>>::iterator vecIt = find(it->second.begin(), it->second.end(), lp);
            if (vecIt != it->second.end())
                it->second.erase(vecIt);
        }
    }
	
	//事件发生，通知监听者（视图）进行处理
    void dispatchMessage(int msgid)
    {
        map<int, vector<weak_ptr<Listener>>>::iterator it = _ObserMap.find(msgid);
        if (it != _ObserMap.end())
        {
            vector<weak_ptr<Listener>>::iterator vecIt = it->second.begin();
            for (; vecIt != it->second.end(); ++vecIt)
            {
                shared_ptr<Listener> lp = (*vecIt).lock();
                if (lp != NULL) 
                    lp->handleMessage(msgid);
            }
        }
    }
private:
	//观察的事件集合（感兴趣的事件，监听者（视图））
    map<int, vector<weak_ptr<Listener>>> _ObserMap;
};


int main()
{
    shared_ptr<Listener> p1(new Listener1("Listener1"));
    shared_ptr<Listener> p2(new Listener1("Listener2"));
    shared_ptr<Listener> p3(new Listener1("Listener3"));


    Observer obser;
    obser.registerListener(p1, 0);
    obser.registerListener(p1, 1);
    obser.registerListener(p1, 2);
    obser.registerListener(p2, 0);
    obser.registerListener(p2, 2);
    obser.registerListener(p3, 1);
    obser.registerListener(p3, 2);


    while (true)
    {
        int msgid;
        cout << "msgid:";
        cin >> msgid;
        obser.dispatchMessage(msgid);
    }
    return 0;
}