工厂模式和观察者模式 C++ 代码
时间: 2023-11-15 15:08:32 浏览: 35
工厂模式的 C 代码实现:
```c
#include <stdio.h>
// 定义产品接口
typedef struct Product {
void (*show)(void);
} Product;
// 定义具体产品A
typedef struct ConcreteProductA {
Product product;
char name[10];
} ConcreteProductA;
void ConcreteProductA_show(void) {
printf("This is ConcreteProductA\n");
}
// 定义具体产品B
typedef struct ConcreteProductB {
Product product;
char name[10];
} ConcreteProductB;
void ConcreteProductB_show(void) {
printf("This is ConcreteProductB\n");
}
// 工厂类
typedef struct Factory {
Product *(*create_product)(void);
} Factory;
// 工厂类的具体实现,创建具体产品A
Product *ConcreteFactoryA_create_product(void) {
ConcreteProductA *product = (ConcreteProductA *)malloc(sizeof(ConcreteProductA));
product->product.show = ConcreteProductA_show;
strcpy(product->name, "ConcreteProductA");
return (Product *)product;
}
// 工厂类的具体实现,创建具体产品B
Product *ConcreteFactoryB_create_product(void) {
ConcreteProductB *product = (ConcreteProductB *)malloc(sizeof(ConcreteProductB));
product->product.show = ConcreteProductB_show;
strcpy(product->name, "ConcreteProductB");
return (Product *)product;
}
int main() {
Factory factoryA, factoryB;
factoryA.create_product = ConcreteFactoryA_create_product;
factoryB.create_product = ConcreteFactoryB_create_product;
Product *productA = factoryA.create_product();
Product *productB = factoryB.create_product();
productA->show();
productB->show();
free(productA);
free(productB);
return 0;
}
```
观察者模式的 C 代码实现:
```c
#include <stdio.h>
#include <stdlib.h>
// 定义观察者接口
typedef struct Observer {
void (*update)(struct Observer *observer, int value);
} Observer;
// 定义具体观察者A
typedef struct ConcreteObserverA {
Observer observer;
char name[10];
} ConcreteObserverA;
void ConcreteObserverA_update(Observer *observer, int value) {
ConcreteObserverA *concrete_observer = (ConcreteObserverA *)observer;
printf("Observer %s received new value: %d\n", concrete_observer->name, value);
}
// 定义具体观察者B
typedef struct ConcreteObserverB {
Observer observer;
char name[10];
} ConcreteObserverB;
void ConcreteObserverB_update(Observer *observer, int value) {
ConcreteObserverB *concrete_observer = (ConcreteObserverB *)observer;
printf("Observer %s received new value: %d\n", concrete_observer->name, value);
}
// 定义被观察者接口
typedef struct Subject {
void (*attach)(struct Subject *subject, Observer *observer);
void (*detach)(struct Subject *subject, Observer *observer);
void (*notify)(struct Subject *subject, int value);
} Subject;
// 定义具体被观察者
typedef struct ConcreteSubject {
Subject subject;
int value;
Observer *observers[10];
int count;
} ConcreteSubject;
void ConcreteSubject_attach(Subject *subject, Observer *observer) {
ConcreteSubject *concrete_subject = (ConcreteSubject *)subject;
concrete_subject->observers[concrete_subject->count++] = observer;
}
void ConcreteSubject_detach(Subject *subject, Observer *observer) {
ConcreteSubject *concrete_subject = (ConcreteSubject *)subject;
for (int i = 0; i < concrete_subject->count; i++) {
if (concrete_subject->observers[i] == observer) {
for (int j = i; j < concrete_subject->count - 1; j++) {
concrete_subject->observers[j] = concrete_subject->observers[j + 1];
}
concrete_subject->count--;
break;
}
}
}
void ConcreteSubject_notify(Subject *subject, int value) {
ConcreteSubject *concrete_subject = (ConcreteSubject *)subject;
for (int i = 0; i < concrete_subject->count; i++) {
concrete_subject->observers[i]->update(concrete_subject->observers[i], value);
}
}
int main() {
ConcreteSubject subject;
ConcreteObserverA observerA;
ConcreteObserverB observerB;
observerA.observer.update = ConcreteObserverA_update;
strcpy(observerA.name, "A");
observerB.observer.update = ConcreteObserverB_update;
strcpy(observerB.name, "B");
subject.subject.attach = ConcreteSubject_attach;
subject.subject.detach = ConcreteSubject_detach;
subject.subject.notify = ConcreteSubject_notify;
subject.subject.attach((Subject *)&subject, (Observer *)&observerA);
subject.subject.attach((Subject *)&subject, (Observer *)&observerB);
subject.subject.notify((Subject *)&subject, 10);
subject.subject.detach((Subject *)&subject, (Observer *)&observerA);
subject.subject.notify((Subject *)&subject, 20);
return 0;
}
```