设计模式五,Observer

原创 2011年01月18日 23:16:00

观察者(Observer)模式用于解决一个相当常见的问题:当某些其他对象改变状态时,如果一组对象需要进行相应的更新,那么应该如何处理呢?假定有一些数据(即文档)和两个视图,一个图形视图和一个文本视图,在更改“文档”数据时,必须通知这些视图更新它们自身,这就是观察者模式所要完成的任务。

以下代码完成Observer模式,采用内部内的方式,不过虽然实现了此模式,但内部类的代码不断重复,不是好的方法。

找到更适合的方法再考虑进行更新。

 
#ifndef OBSERVER_H
#define OBSERVER_H
 
class Observable;
class Argument {};
 
class Observer {
public:
  // Called by the observed object, whenever
  // the observed object is changed:
  virtual void update(Observable* o, Argument* arg) = 0;
  virtual ~Observer() {}
};
#endif // OBSERVER_H ///:~
 
 
#ifndef OBSERVABLE_H
#define OBSERVABLE_H
#include 
#include "Observer.h"
 
class Observable {
  bool changed;
  std::set observers;
protected:
  virtual void setChanged() { changed = true; }
  virtual void clearChanged() { changed = false; }
public:
  virtual void addObserver(Observer& o) {
    observers.insert(&o);
  }
  virtual void deleteObserver(Observer& o) {
    observers.erase(&o);
  }
  virtual void deleteObservers() {
    observers.clear();
  }
  virtual int countObservers() {
    return observers.size();
  }
  virtual bool hasChanged() { return changed; }
  // If this object has changed, notify all
  // of its observers:
  virtual void notifyObservers(Argument* arg = 0) {
    if(!hasChanged()) return;
    clearChanged(); // Not "changed" anymore
    std::set::iterator it;
    for(it = observers.begin();it != observers.end(); it++)
      (*it)->update(this, arg);
  }
  virtual ~Observable() {}
};
#endif // OBSERVABLE_H ///:~
 
 
//: C10:ObservedFlower.cpp
// Demonstration of "observer" pattern.
#include 
#include 
#include <string>
#include 
#include "Observable.h"
using namespace std;
 
class Flower {
    bool isOpen;
public:
    Flower() : isOpen(false),
        openNotifier(this), closeNotifier(this) {}
    void open() { // Opens its petals
        isOpen = true;
        openNotifier.notifyObservers();
        closeNotifier.open();
    }
    void close() { // Closes its petals
        isOpen = false;
        closeNotifier.notifyObservers();
        openNotifier.close();
    }
    // Using the "inner class" idiom:
    class OpenNotifier;
    friend class Flower::OpenNotifier;
    class OpenNotifier : public Observable {
        Flower* parent;
        bool alreadyOpen;
    public:
        OpenNotifier(Flower* f) : parent(f),
            alreadyOpen(false) {}
        void notifyObservers(Argument* arg = 0) {
            if(parent->isOpen && !alreadyOpen) {
                setChanged();
                Observable::notifyObservers();
                alreadyOpen = true;
            }
        }
        void close() { alreadyOpen = false; }
    } openNotifier;
    class CloseNotifier;
    friend class Flower::CloseNotifier;
    class CloseNotifier : public Observable {
        Flower* parent;
        bool alreadyClosed;
    public:
        CloseNotifier(Flower* f) : parent(f),
            alreadyClosed(false) {}
        void notifyObservers(Argument* arg = 0) {
            if(!parent->isOpen && !alreadyClosed) {
                setChanged();
                Observable::notifyObservers();
                alreadyClosed = true;
            }
        }
        void open() { alreadyClosed = false; }
    } closeNotifier;
};
 
class Bee {
    string name;
    // An "inner class" for observing openings:
    class OpenObserver;
    friend class Bee::OpenObserver;
    class OpenObserver : public Observer {
        Bee* parent;
    public:
        OpenObserver(Bee* b) : parent(b) {}
        void update(Observable*, Argument *) {
            cout << "Bee " << parent->name
                << "'s breakfast time!" << endl;
        }
    } openObsrv;
    // Another "inner class" for closings:
    class CloseObserver;
    friend class Bee::CloseObserver;
    class CloseObserver : public Observer {
        Bee* parent;
    public:
        CloseObserver(Bee* b) : parent(b) {}
        void update(Observable*, Argument *) {
            cout << "Bee " << parent->name
                << "'s bed time!" << endl;
        }
    } closeObsrv;
public:
    Bee(string nm) : name(nm),
        openObsrv(this), closeObsrv(this) {}
    Observer& openObserver() { return openObsrv; }
    Observer& closeObserver() { return closeObsrv;}
};
 
class Hummingbird {
    string name;
    class OpenObserver;
    friend class Hummingbird::OpenObserver;
    class OpenObserver : public Observer {
        Hummingbird* parent;
    public:
        OpenObserver(Hummingbird* h) : parent(h) {}
        void update(Observable*, Argument *) {
            cout << "Hummingbird " << parent->name
                << "'s breakfast time!" << endl;
        }
    } openObsrv;
    class CloseObserver;
    friend class Hummingbird::CloseObserver;
    class CloseObserver : public Observer {
        Hummingbird* parent;
    public:
        CloseObserver(Hummingbird* h) : parent(h) {}
        void update(Observable*, Argument *) {
            cout << "Hummingbird " << parent->name
                << "'s bed time!" << endl;
        }
    } closeObsrv;
public:
    Hummingbird(string nm) : name(nm),
        openObsrv(this), closeObsrv(this) {}
    Observer& openObserver() { return openObsrv; }
    Observer& closeObserver() { return closeObsrv;}
};
 
int main() {
    Flower f;
    Bee ba("A"), bb("B");
    Hummingbird ha("A"), hb("B");
    f.openNotifier.addObserver(ha.openObserver());
    f.openNotifier.addObserver(hb.openObserver());
    f.openNotifier.addObserver(ba.openObserver());
    f.openNotifier.addObserver(bb.openObserver());
    f.closeNotifier.addObserver(ha.closeObserver());
    f.closeNotifier.addObserver(hb.closeObserver());
    f.closeNotifier.addObserver(ba.closeObserver());
    f.closeNotifier.addObserver(bb.closeObserver());
    // Hummingbird B decides to sleep in:
    f.openNotifier.deleteObserver(hb.openObserver());
    // Something changes that interests observers:
    f.open();
    f.open(); // It's already open, no change.
    // Bee A doesn't want to go to bed:
    f.closeNotifier.deleteObserver(
        ba.closeObserver());
    f.close();
    f.close(); // It's already closed; no change
    f.openNotifier.deleteObservers();
    f.open();
    f.close();
} ///:~
 

设计模式----Observer模式

在以下任一情况下可以使用观察者模式: 1、当一个抽象模型有两个方面,其中一个方面依赖于另一个方面。将这二者封装在独立的对象中以使他们可以各自独立的改变和复用 2、当对一个对象的改变需要同时改变其他...
  • fly542
  • fly542
  • 2011年08月25日 00:00
  • 4699

设计模式——观察者模式(Observer)

要想正确理解设计模式,首先必须明确它是为了解决什么问题而提出来的。 设计模式学习笔记,欢迎交流。 ——Shulin 转载请注明出处:http://blog.csdn.net/zhsh...
  • u012909091
  • u012909091
  • 2014年08月20日 16:52
  • 2962

设计模式总结之Observer Pattern(观察者模式)

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。...
  • cooldragon
  • cooldragon
  • 2016年08月11日 00:53
  • 966

C#,由委托到Observer设计模式,再到事件机制

1. 什么是委托? 开始处理诸如int,bool等基本数据类型,它们是数据的类型。委托,是方法的类型。 如  int a; a可以是1,2,3,4,5......... 那么 delegate D; ...
  • u013781568
  • u013781568
  • 2014年03月01日 11:30
  • 997

设计模式 - 观察者模式(Observer Pattern) 详解

观察者模式(Observer Pattern) 详解 本文地址: http://blog.csdn.net/caroline_wendy/article/details/26583157 版权...
  • u012515223
  • u012515223
  • 2014年05月22日 14:37
  • 2982

[Android&Java]浅谈设计模式-代码篇:观察者模式Observer

观察者,就如同一个人,对很多东西都感兴趣,就好像音乐、电子产品、Game、股票等,这些东西的变化都能引起爱好者们的注意并时刻关注他们。在代码中,我们也有这样的一种方式来设计一些好玩的思想来。今天就写个...
  • sunjundelove
  • sunjundelove
  • 2015年07月22日 20:47
  • 981

Java面向对象设计模式(十五)——观察者模式(Observer)

相关文档:Java面向对象设计模式 观察者模式(Observer)         包括这个模式在内的接下来的四个模式,都是类和类之间的关系,不涉及到继承,学的时候应该 记得归纳,记得本文...
  • u011814346
  • u011814346
  • 2017年05月08日 14:54
  • 211

设计模式(C++实现)之Observer

观察者模式(Observer Pattern)也叫做发布-订阅模式(Publish/Subscribe). 跟随一个关于军官指挥士兵打仗的例子来学习此模式吧。 GOF中关于Observer的类图 ...
  • whsmile555
  • whsmile555
  • 2010年08月30日 16:13
  • 173

设计模式-深入解析观察者模式(Observer)

在上篇设计模式上我们继续前进把,苦逼(酷毙)的程序员一刻都不能松懈的,要紧跟脚步,每天都学习啊!!学了策略模式,我自己去用设计模式写了几个例子,感觉还扣以啊。下面继续总结一下观察者模式的学习,如有不正...
  • qq_29282475
  • qq_29282475
  • 2015年12月07日 16:16
  • 1322

23种设计模式 之 Observer模式(发布-订阅模式)[C语言]

一、概念定义     Observer模式又称为发布-订阅模式。     Observer模式:定义了一种一对多的依赖关系,让多个观察者(Observer)同时监听某一主题对象(Subject)。当...
  • RoyalApex
  • RoyalApex
  • 2012年11月15日 15:58
  • 4885
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:设计模式五,Observer
举报原因:
原因补充:

(最多只允许输入30个字)