最近看到观察者模式,但是不知道怎么实现~~

[tczyp]

我在很多书上看到观察者模式,或者叫"出版订阅模式"用来解决双向依赖的问题,设计意图是:被依赖的对象向外发布自己的状态,而此前订阅了该状态的所有对象都会得到通知.
但是我们怎么去实现这个过程?比如被依赖的对象向外发布自己的状态是怎么一个过程?
是被依赖对象调用自己的函数,还是调用别人的函数,还是怎样?
而依赖对象是怎么得知这些状态的改变的?是通过循环调用自己的函数,别人的函数还是怎么实现?
这样实现出来的效率会不会明显降低?
我想不少人都会遇到类似的困难,高手指点,或者提供一些参考资料,非常感谢~~

[RockHwnd]

你的信 誉 值太低了...

[tczyp]

汗...信誉跟什么有关...我保证我从来不骂人,不灌水...虽然我非常忙所以也很少回帖...

[sheds]

他的意思是你问了问题不给分, 所以信誉就低下来了

[tczyp]

唉...有些问题没有解决...只是被一些人灌水...那么我是否应该结贴...不过我以后会注意的...还是希望大家能帮我解决这个问题,我一定记得给分,当然我想高手的分已经多得不差我给的这么一点点了,但是希望不吝指教~~

[perfervid]

楼主看看这个Java的，应该比较好理解。

http://www.graphics.net.cn/article/001/107.asp

[tczyp]

我的问题说得不够清楚吗?

[qiangorqiang]

/*
*/
class BaseClassSubject {
public:
void Operation (int newValue);
};

class MySubject : public BaseClassSubject {
public:
void Operation (int newValue);
private:
int _myInstVar;
};

/*
*/
void MySubject::Operation (int newValue) {
BaseClassSubject::Operation(newValue);
// trigger notification

_myInstVar += newValue;
// update subclass state (too late!)
}
/*
*/
typedef int TextRange;
class Text {
public:
void Cut(int newValue);
void ReplaceRange(int newValue);
void Notify();
};

/*
*/
void Text::Cut (TextRange r) {
ReplaceRange(r); // redefined in subclasses
Notify();
}
/*
*/
#include "List.H"
/*
*/
class Subject;

class Observer {
public:
virtual ~ Observer();
virtual void Update(Subject* theChangedSubject) = 0;
protected:
Observer();
};
/*
*/
class Subject {
public:
virtual ~Subject();
/*
*/
virtual void Attach(Observer*);
virtual void Detach(Observer*);
virtual void Notify();
protected:
Subject();
private:
List<Observer*> *_observers;
};
/*
*/
void Subject::Attach (Observer* o) {
_observers->Append(o);
}
/*
*/
void Subject::Detach (Observer* o) {
_observers->Remove(o);
}
/*
*/
void Subject::Notify () {
ListIterator<Observer*> i(_observers);

for (i.First(); !i.IsDone(); i.Next()) {
i.CurrentItem()->Update(this);
}
}
/*
*/
class ClockTimer : public Subject {
public:
ClockTimer();
/*
*/
virtual int GetHour();
virtual int GetMinute();
virtual int GetSecond();
/*
*/
void Tick();
};
/*
*/
void ClockTimer::Tick () {
// update internal time-keeping state
// ...
Notify();
}
/*
*/
class Widget {
public:
virtual void Draw();
};
/*
*/
class DigitalClock: public Widget, public Observer {
public:
DigitalClock(ClockTimer*);
virtual ~DigitalClock();
/*
*/
virtual void Update(Subject*);
// overrides Observer operation
/*
*/
virtual void Draw();
// overrides Widget operation;
// defines how to draw the digital clock
private:
ClockTimer* _subject;
};
/*
*/
DigitalClock::DigitalClock (ClockTimer* s) {
_subject = s;
_subject->Attach(this);
}

DigitalClock::~DigitalClock () {
_subject->Detach(this);
}
/*
*/
void DigitalClock::Update (Subject* theChangedSubject) {
if (theChangedSubject == _subject) {
Draw();
}
}
/*
*/
void DigitalClock::Draw () {
// get the new values from the subject

int hour = _subject->GetHour();
int minute = _subject->GetMinute();
// etc.

// draw the digital clock
}
/*
*/
class AnalogClock : public Widget, public Observer {
public:
AnalogClock(ClockTimer*);
virtual void Update(Subject*);
virtual void Draw();
// ...
};
/*
*/
ClockTimer* timer = new ClockTimer;
AnalogClock* analogClock = new AnalogClock(timer);
DigitalClock* digitalClock = new DigitalClock(timer);
/*
*/

[oyljerry]

不知Message算不算

[fine10000]

学习
关注

[aben456]

pattern design

[tczyp]

非常感谢,perfervid,看过那个java的例子,我大致上知道了观察者模式的机制.
但是同时有几个问题:在被观察者里面有一个"通知"函数,那个函数会调用被观察者的update函数,那就说明被观察者有观察者的对象指针,而被观察者的update函数需要根据观察者状态的改变来进行相应的处理,那么就是说被观察者也有观察者的指针......那么如果是这样的话观察者模式还有意义吗?