以前我曾經實現過觀察者模式（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*);
};
//-------------------------------------------------------------------