我的玻璃盒子

原文链接：http://www.cppblog.com/eXile/archive/2007/09/16/32297.html

　　以前我曾经实现过观察者模式（signal / slot )。有位朋友不以为然，也把他的实现发给我。这是用纯ＯＯ的方式实现的，没有使用模板，不依赖于其它库。应该是仿Java或C#接口。设计得不错，具有以下特点：
　　１）当Subject或Observer 销毁时，连接自动断开（注册自动取消），当然，这也是实现该模式的重点。
　　２）考虑了以下因素：一个Subject是否允许多个Observer观察？一个Observer是否允许同时观察多个Subject? 由此可分为一对一，一对多，多对多，一般的GUI库中都是后两种情况，但自己写的程序中却第一种情况居多。所以他出于效率，设计了SimpleSubject和SimpleObserver。
　　不足之处如下：
　　１）Observer::update()只能带无类型的参数（好象也没有更好的办法）。
　　２）由于C++中没有匿名类，所以使用起来并没有Java中方便。于是我又添加了一个ObserverAdapter。
　　使用举例：

class A : public Subject
{
        int value;
public:
   void setValue(int v)
   {
       value = v;
       notify(&value);
   }      
};

class B : public Observer
{
public:
   void update(void* arg)
   {
       printf("A changed:%d", *(int*)arg);
   }      
};

void f(A* a, B* b)
{
    a->connect(b);
    a->setValue(1);
}

使用ObserverAdapter ,则变成了以下情况：

class B
{
   ObserverAdapter<B> observerOfA;
public:
   B(A* a) : observerOfA(this, &B::valueChanged)
   {
       a->connect(&observerOfA);
   }

   void valueChanged(void* arg)
   {
       printf("A changed:%d", *(int*)arg);
   }      
};

　　代码分为两个文件：IObserver.h 和 Observer.h，就贴在下面吧：
IObserver.h 　： 接口定义

#pragma once

class ISubject;

class IObserver
{
public:
    IObserver()  {}
    virtual ~IObserver() {};

    virtual void update(void*) = 0;

protected:
    virtual void addSubject(ISubject* ) = 0;
    virtual void removeSubject(ISubject* ) = 0;

    friend class ISubject;

private:
    IObserver(IObserver const&);
    IObserver& operator= (IObserver const&);
};

class ISubject
{
public:
    ISubject() {}
    virtual ~ISubject() {};

    virtual void connect(IObserver*) = 0;
    virtual void disconnect(IObserver*) = 0;
    virtual bool isConnected(IObserver*) const= 0;
    virtual void notify(void*) = 0;

protected:
    void addObserver(IObserver* observer);
    void removeObserver(IObserver* observer);

private:
    ISubject(ISubject const&);
    ISubject& operator= (ISubject const&);
};

Observer.h 　： 具体实现

#pragma once

#include <cassert>
#include <set>

#include "IObserver.h"

//-------------------------------------------------------------------

inline void ISubject::addObserver(IObserver* observer)
{
    observer->addSubject(this);
}

inline void ISubject::removeObserver(IObserver* observer)
{
    observer->removeSubject(this);
}

//-------------------------------------------------------------------

class SimpleSubject : public ISubject
{
public:
    SimpleSubject() : m_observer(0)
    {
    }

    ~SimpleSubject()
    {
if (m_observer) removeObserver(m_observer);
    }

    virtual void connect(IObserver* observer)
    {
        assert(observer);
if (m_observer)
            removeObserver(m_observer);
        addObserver(observer);
        m_observer = observer;
    }

    virtual void disconnect(IObserver* observer)
    {
        assert(observer && observer == m_observer);
        removeObserver(m_observer);
        m_observer = 0;
    }

    virtual bool isConnected(IObserver* observer) const
    {
        return observer == m_observer;
    }

    virtual void notify(void* arg)
    {
if (m_observer) m_observer->update(arg);
    }

private:
    IObserver*  m_observer;

};

//-------------------------------------------------------------------

class Subject : public ISubject
{
public:
    Subject() : m_observers()
    {
    }

    ~Subject()
    {
        std::set<IObserver*>::iterator
            it = m_observers.begin(),
            e  = m_observers.end();
for (; it != e; ++it)
        {
            removeObserver(*it);
        }
    }

    virtual void connect(IObserver* observer)
    {
        assert(observer);
        addObserver(observer);
        m_observers.insert(observer);
    }

    virtual void disconnect(IObserver* observer)
    {
        assert(observer);
        removeObserver(observer);
        m_observers.erase(observer);
    }

    virtual bool isConnected(IObserver* observer) const
    {
        return m_observers.find(observer) != m_observers.end();
    }

    virtual void notify(void* arg)
    {
        std::set<IObserver*>::iterator
            it = m_observers.begin(),
            e  = m_observers.end();
while (it != e)
        {
            (*it++)->update(arg); // observer can be disconnected in update()
        }
    }

private:
    std::set<IObserver*>  m_observers;

};

//-------------------------------------------------------------------

class SimpleObserver  : public IObserver
{
public:
    SimpleObserver() : m_subject(0)
    {
    }

    ~SimpleObserver()
    {
if (m_subject) m_subject->disconnect(this);
    }

    ISubject* getSubject() const
    {
        return m_subject;
    }

private:
    virtual void addSubject(ISubject* subject)
    {
if (m_subject) m_subject->disconnect(this);
        m_subject = subject;
    }

    virtual void removeSubject(ISubject* subject)
    {
        assert(subject == m_subject);
        m_subject = 0;
    }

private:
    ISubject*   m_subject;
};


//-------------------------------------------------------------------

class Observer : public IObserver
{
public:
    Observer() : m_subjects()
    {
    }

    ~Observer()
    {
        std::set<ISubject*>::iterator
            it = m_subjects.begin(),
            e  = m_subjects.end();
while (it != e)
        {
            (*it++)->disconnect(this);
        }
    }

private:
    virtual void addSubject(ISubject* subject)
    {
        assert(subject);
        m_subjects.insert(subject);
    }

    virtual void removeSubject(ISubject* subject)
    {
        assert(subject);
        m_subjects.erase(subject);
    }

private:
    std::set<ISubject*>   m_subjects;
};

//-------------------------------------------------------------------

template <class T, class Base = SimpleObserver>
class ObserverAdapter  : public Base
{
public:
    ObserverAdapter(T* t, void (T::*f)(void*))
     : m_obj(t), m_func(f)
    {
    }

    virtual void update(void* arg)
    {
        (m_obj->*m_func)(arg);
    }

private:
    T*  m_obj;
    void (T::*m_func)(void*);
};

//-------------------------------------------------------------------