C语言实现观察者模式
时间: 2024-04-14 22:21:18 浏览: 16
C语言实现观察者模式需要以下步骤:
1. 定义一个观察者接口(Observer),包含一个更新方法(update),用于接收被观察者(Subject)的通知。
2. 定义一个被观察者接口(Subject),包含添加观察者、删除观察者、通知观察者等方法。
3. 实现观察者接口,创建具体的观察者类。
4. 实现被观察者接口,创建具体的被观察者类,并在其中维护一个观察者列表。
5. 当被观察者发生变化时,调用通知方法,将变化传递给所有观察者。
以下是C语言实现观察者模式的示例代码:
```
#include <stdio.h>
#include <stdlib.h>
typedef struct Observer Observer;
typedef struct Subject Subject;
// 观察者接口
struct Observer {
void (*update)(Observer *);
};
// 被观察者接口
struct Subject {
void (*attach)(Subject *, Observer *);
void (*detach)(Subject *, Observer *);
void (*notify)(Subject *);
};
// 具体观察者
struct ConcreteObserver {
Observer base;
int state;
};
void ConcreteObserver_update(Observer *observer) {
ConcreteObserver *self = (ConcreteObserver *)observer;
printf("Observer state update: %d\n", self->state);
}
ConcreteObserver *ConcreteObserver_create(int state) {
ConcreteObserver *self = malloc(sizeof(ConcreteObserver));
self->base.update = ConcreteObserver_update;
self->state = state;
return self;
}
// 具体被观察者
struct ConcreteSubject {
Subject base;
Observer **observers;
int count;
};
void ConcreteSubject_attach(Subject *subject, Observer *observer) {
ConcreteSubject *self = (ConcreteSubject *)subject;
self->count++;
self->observers = realloc(self->observers, sizeof(Observer *) * self->count);
self->observers[self->count - 1] = observer;
}
void ConcreteSubject_detach(Subject *subject, Observer *observer) {
ConcreteSubject *self = (ConcreteSubject *)subject;
for (int i = 0; i < self->count; i++) {
if (self->observers[i] == observer) {
for (int j = i; j < self->count - 1; j++) {
self->observers[j] = self->observers[j + 1];
}
self->count--;
self->observers = realloc(self->observers, sizeof(Observer *) * self->count);
break;
}
}
}
void ConcreteSubject_notify(Subject *subject) {
ConcreteSubject *self = (ConcreteSubject *)subject;
for (int i = 0; i < self->count; i++) {
self->observers[i]->update(self->observers[i]);
}
}
ConcreteSubject *ConcreteSubject_create() {
ConcreteSubject *self = malloc(sizeof(ConcreteSubject));
self->base.attach = ConcreteSubject_attach;
self->base.detach = ConcreteSubject_detach;
self->base.notify = ConcreteSubject_notify;
self->observers = NULL;
self->count = 0;
return self;
}
int main() {
ConcreteSubject *subject = ConcreteSubject_create();
ConcreteObserver *observer1 = ConcreteObserver_create(1);
ConcreteObserver *observer2 = ConcreteObserver_create(2);
subject->base.attach(&subject->base, &observer1->base);
subject->base.attach(&subject->base, &observer2->base);
subject->base.notify(&subject->base);
subject->base.detach(&subject->base, &observer2->base);
subject->base.notify(&subject->base);
free(observer1);
free(observer2);
free(subject->observers);
free(subject);
return 0;
}
```