嵌入式C设计模式 - 观察者模式

　　当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。

　　1.观察者模式解决一对多的问题，例如一个模块发生改变时，要通知其他的模块；

　　2.被观察者（observable）/主题（subject）中包含所有的观察者（observer）;

　　3.观察者通过被观察者提供的接口（addObserver）添加自己到被观察者的观察者列表中；

　　4.观察者提供一个 update 接口供被观察者调用，已便在发生改变时通知观察者。

　　5.避免观察者和被观察者循环应用导致系统崩溃。

observer.h

 1 #ifndef __OBSERVER_H
 2 #define __OBSERVER_H
 3
 4 typedef struct subject Subject;
 5 typedef struct observer Observer;
 6
 7 struct subject {
 8     Observer *observer_list;
 9     void (*add_observer)(Subject *sub,Observer *obs);
10     void (*delete_observer)(Subject *sub,Observer *obs);
11     int  (*count_observers)(Subject *sub);
12     void (*notify_observer)(Subject *sub,Observer *obs,void *arg);
13     void (*notify_all_observers)(Subject *sub,void *arg);
14 };
15
16 struct observer {
17     void (*update)(Observer *obs,Subject *sub,void *arg);
18     Observer *next;
19 };
20
21 void subjectInit(Subject *sub);
22
23 void observerInit(Observer *obs);
24
25 #endif

observer.c

  1 #include <stddef.h>
  2 #include "observer.h"
  3
  4 static void
  5 _subjectAddObserver(Subject *sub,Observer *obs)
  6 {
  7     Observer *_obs = sub->observer_list;
  8     obs->next = NULL;
  9
 10     if(_obs == NULL) {
 11         sub->observer_list = obs;
 12         return;
 13     }
 14
 15     while(_obs->next != NULL)
 16         _obs = _obs->next;
 17
 18     _obs->next = obs;
 19 }
 20
 21 static void
 22 _subjectDeleteObserver(Subject *sub,Observer *obs)
 23 {
 24     Observer *_obs = sub->observer_list;
 25
 26     if(_obs == NULL) return;
 27
 28     if(_obs == obs) {
 29         sub->observer_list = _obs->next;
 30         return;
 31     }
 32
 33     while(_obs->next != NULL) {
 34         if(_obs->next == obs) {
 35             _obs->next = obs->next;
 36             return;
 37         }
 38
 39         _obs = _obs->next;
 40     }
 41 }
 42
 43 static int
 44 _subjectCountObservers(Subject *sub)
 45 {
 46     int cnt = 0;
 47     Observer *_obs = sub->observer_list;
 48
 49     while(_obs != NULL) {
 50         cnt ++;
 51         _obs = _obs->next;
 52     }
 53
 54     return cnt;
 55 }
 56
 57 static void
 58 _subjectNotifyObserver(Subject *sub,Observer *obs,void *arg)
 59 {
 60     obs->update(obs,sub,arg);
 61 }
 62
 63 static void
 64 _subjectNotifyAllObservers(Subject *sub,void *arg)
 65 {
 66     Observer *_obs = sub->observer_list;
 67
 68     while(_obs != NULL) {
 69         _obs->update(_obs,sub,arg);
 70         _obs = _obs->next;
 71     }
 72 }
 73
 74 void
 75 subjectInit(Subject *sub)
 76 {
 77     sub->observer_list = NULL;
 78     sub->add_observer = _subjectAddObserver;
 79     sub->delete_observer = _subjectDeleteObserver;
 80     sub->count_observers = _subjectCountObservers;
 81     sub->notify_observer = _subjectNotifyObserver;
 82     sub->notify_all_observers = _subjectNotifyAllObservers;
 83 }
 84
 85 static void
 86 _observerUpdate(Observer *obs,Subject *sub,void *arg)
 87 {
 88     (void)obs;
 89     (void)sub;
 90     (void)arg;
 91
 92     /** You should override the update function **/
 93     while(1) {
 94         ;
 95     }
 96 }
 97
 98 void
 99 observerInit(Observer *obs)
100 {
101     obs->update = _observerUpdate;
102     obs->next = NULL;
103 }

实体观察者类

1 struct observerExtend {
2     Observer obs;
3     Subject  *sub;
4     int id;
5 };
6
7 typedef struct observerExtend ObserverExtend;
8
9 void obExtdinit(ObserverExtend *extd);

 1 #include <stdio.h>
 2 #include "observer_extend.h"
 3
 4 static void
 5 update(Observer *obs,Subject *sub,void *arg)
 6 {
 7     ObserverExtend *extd = (ObserverExtend *)obs;
 8     printf("observer %d, arg %d\r\n",extd->id, arg);
 9 }
10
11 void
12 obExtdinit(ObserverExtend *extd)
13 {
14     observerInit(&extd->obs);
15     extd->obs.update = update;
16     extd->sub->add_observer(extd->sub, &extd->obs);
17 }