当前位置： 
利用策略模式优化代码的if else
今天我们来说说如何利用策略模式重构我们代码中的if else
1、我们本着高内聚低耦合的设计理念，将ifelse中的代码剥离出来，下面我们首先声明一个接口方法：
public interface IStrategyPattern {
typedef struct {
int data;
} Message;
typedef struct {
void (*on_message)(Message);
} Observer;
typedef struct {
Observer* observers[MAX_OBSERVERS];
int num_observers;
} Publisher;
void add_observer(Publisher* publisher, Observer* observer) {
if (publisher->num_observers < MAX_OBSERVERS) {
publisher->observers[publisher->num_observers]=observer;
publisher->num_observers++;
} else {
printf("Cannot add observer: maximum number of observers reached.
");
}
}
void publish_message(Publisher* publisher, Message message) {
int i;
for (i=0; i < publisher->num_observers; i++) {
publisher->observers[i]->on_message(message);
}
}
void handle_message(Message message) {
printf("Received message with data %d
", message.data);
}
int main() {
Publisher publisher;
Observer observer1={ handle_message };
Observer observer2={ handle_message };
add_observer(&publisher, &observer1);
add_observer(&publisher, &observer2);
Message message={ 42 };
publish_message(&publisher, message);
return 0;
}
```
以上代码定义了一个 `Publisher` 结构体作为发布者，一个 `Observer` 结构体作为观察者。发布者可以添加观察者，并通过 `publish_message` 函数发布消息。观察者在收到消息时会调用其自身的 `on_message` 函数处理消息。在 `main` 函数中，创建了一个发布者和两个观察者，并将观察者添加到发布者中。最后，发布者发布了一条消息，观察者收到消息并处理。
### 回答2：
Publish-Subscribe模式采用的设计模式是观察者模式。
观察者模式是一种行为型设计模式，用于定义对象之间的一对多依赖关系，使得当一个对象的状态发生改变时，其所有依赖对象都会得到通知并自动更新。
以下是一个简单的C代码示例：
#include <stdio.h>
#include <stdlib.h>
// 定义观察者接口
typedef struct Observer {
void (*update)(struct Observer* observer, int data); // 更新方法
} Observer;
// 定义具体的观察者
typedef struct ConcreteObserver {
Observer base; // 继承自Observer接口
int id; // 观察者的ID，用于区分不同的观察者
} ConcreteObserver;
// 更新方法的实现
void update(struct Observer* observer, int data) {
ConcreteObserver* concreteObserver=(ConcreteObserver*)observer; // 将Observer类型转换为ConcreteObserver类型
printf("Observer %d received data: %d
", concreteObserver->id, data);
}
// 定义发布者
typedef struct Publisher {
Observer** observers; // 观察者数组
int numObservers; // 观察者数量
} Publisher;
// 初始化发布者
void initPublisher(Publisher* publisher, int numObservers) {
publisher->observers=(Observer**)malloc(sizeof(Observer*) * numObservers);
publisher->numObservers=numObservers;
}
// 添加观察者
void addObserver(Publisher* publisher, Observer* observer, int index) {
publisher->observers[index]=observer;
}
// 发布数据
void publishData(Publisher* publisher, int data) {
for (int i=0; i < publisher->numObservers; i++) {
publisher->observers[i]->update(publisher->observers[i], data); // 调用每个观察者的更新方法
}
}
// 主函数
int main() {
ConcreteObserver observer1={{update}, 1};
ConcreteObserver observer2={{update}, 2};
Publisher publisher;
initPublisher(&publisher, 2);
addObserver(&publisher, &(observer1.base), 0);
addObserver(&publisher, &(observer2.base), 1);
publishData(&publisher, 10);
return 0;
}
运行以上代码会输出：
Observer 1 received data: 10
Observer 2 received data: 10
以上代码演示了一个简单的观察者模式的实现，其中发布者（Publisher）可以添加多个观察者（Observer），当发布者发布数据时，所有的观察者都会收到通知并更新。
### 回答3：
Publish-Subscribe（发布-订阅）模式采用的设计模式是观察者模式（也称为发布-订阅模式）。
观察者模式是一种行为型设计模式，其中一个对象（称为主题或可观察者）维护其依赖对象列表（称为观察者），并在状态发生变化时自动通知观察者。这种模式使得主题和观察者之间的解耦，使得它们可以独立地进行更新。
下面是一个使用C语言的简单示例代码实现观察者模式：
```c
#include <stdio.h>
#include <stdlib.h>
// 观察者接口
typedef struct Observer {
void (*update)(struct Observer* self, int data);
} Observer;
// 具体观察者
typedef struct ConcreteObserver {
Observer observer;
} ConcreteObserver;
void ConcreteObserver_update(Observer* self, int data) {
printf("Received data: %d
", data);
}
// 主题
typedef struct Subject {
Observer** observers;
int count;
void (*attach)(struct Subject* self, Observer* observer);
void (*notify)(struct Subject* self, int data);
} Subject;
// 具体主题
typedef struct ConcreteSubject {
Subject subject;
} ConcreteSubject;
void ConcreteSubject_attach(Subject* self, Observer* observer) {
self->observers[self->count++]=observer;
}
void ConcreteSubject_notify(Subject* self, int data) {
for (int i=0; i < self->count; i++) {
self->observers[i]->update(self->observers[i], data);
}
}
int main(void) {
// 创建主题和观察者
ConcreteSubject subject;
ConcreteObserver observer1;
ConcreteObserver observer2;
// 初始化观察者列表
Observer* observers[]={
&(observer1.observer),
&(observer2.observer),
};
subject.subject.observers=observers;
subject.subject.count=0;
// 附加观察者到主题
subject.subject.attach(&(subject.subject), &(observer1.observer));
subject.subject.attach(&(subject.subject), &(observer2.observer));
// 通知观察者
subject.subject.notify(&(subject.subject), 42);
return 0;
}
```
这个示例中，主题（ConcreteSubject）维护了一个观察者列表，可以动态地添加和删除观察者。观察者（ConcreteObserver）实现了观察者接口（Observer），在数据更新时会被主题通知。在示例代码的main函数中，创建了一个具体主题和两个具体观察者，然后将观察者附加到主题上并通知观察者。运行程序后，观察者将打印出接收到的数据。
上一篇 
