当前位置：首页 > news >正文

00000007_C语言设计模式

news 2025/7/6 4:44:10

C语言设计模式

尽管 C 语言并不直接支持面向对象编程，但通过结构体和函数指针的灵活运用，我们依然可以实现多种经典的设计模式。

1. 工厂模式

1.1 工厂方法的定义与实现

工厂模式通过统一的接口创建对象，客户端无需知道具体的创建逻辑。

代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>// 抽象产品类型定义
typedef struct Product {void (*use)(struct Product*); // 指向具体产品使用方法的函数指针
} Product;// 具体产品A定义
typedef struct {Product base;char* name;
} ProductA;// 产品A的使用方法实现
void useProductA(Product* base) {ProductA* self = (ProductA*)base;printf("Using Product A: %s\n", self->name);
}// 具体产品B定义
typedef struct {Product base;int version;
} ProductB;// 产品B的使用方法实现
void useProductB(Product* base) {ProductB* self = (ProductB*)base;printf("Using Product B: version %d\n", self->version);
}// 工厂方法，根据类型创建不同的产品
Product* createProduct(const char* type) {if (strcmp(type, "A") == 0) {ProductA* product = malloc(sizeof(ProductA));product->base.use = useProductA;product->name = "Example A";return (Product*)product;} else if (strcmp(type, "B") == 0) {ProductB* product = malloc(sizeof(ProductB));product->base.use = useProductB;product->version = 1;return (Product*)product;}return NULL;
}// 测试工厂模式
int main() {Product* p1 = createProduct("A");Product* p2 = createProduct("B");p1->use(p1);p2->use(p2);free(p1);free(p2);return 0;
}

1.2 适用场景

数据库连接：根据需求创建不同类型的数据库连接对象。
图形系统：动态创建圆形、矩形等不同的图形对象。
日志系统：创建不同日志记录方式的对象，如文件日志或控制台日志。

2. 策略模式

2.1 策略模式的实现

策略模式通过函数指针实现不同策略的切换。

代码示例：

#include <stdio.h>
#include <stdlib.h>// 策略类型定义
typedef struct {void (*execute)(void); // 指向策略实现的函数指针
} Strategy;// 策略A实现
void strategyA() {printf("Executing Strategy A\n");
}// 策略B实现
void strategyB() {printf("Executing Strategy B\n");
}// 测试策略模式
int main() {Strategy strategy;// 使用策略Astrategy.execute = strategyA;strategy.execute();// 切换为策略Bstrategy.execute = strategyB;strategy.execute();return 0;
}

2.2 适用场景

排序算法：动态选择快速排序、归并排序等不同算法。
支付系统：支持支付宝、微信支付等多种支付方式切换。
文件压缩：选择不同的压缩算法，如ZIP或RAR。

3. 观察者模式

3.1 观察者模式的实现

观察者模式实现一对多的通知机制。

代码示例：

#include <stdio.h>
#include <stdlib.h>// 观察者接口定义
typedef struct Observer {void (*update)(struct Observer*, const char* message); // 更新方法struct Observer* next; // 链表指针，指向下一个观察者
} Observer;// 具体观察者定义
typedef struct {Observer base;char* name;
} ConcreteObserver;// 具体观察者的更新方法实现
void observerUpdate(Observer* base, const char* message) {ConcreteObserver* self = (ConcreteObserver*)base;printf("%s received: %s\n", self->name, message);
}// 主题（Subject）定义
typedef struct {Observer* observers; // 链表头指针，保存所有观察者
} Subject;// 添加观察者到主题
void addObserver(Subject* subject, Observer* observer) {observer->next = subject->observers;subject->observers = observer;
}// 通知所有观察者
void notifyObservers(Subject* subject, const char* message) {Observer* current = subject->observers;while (current) {current->update(current, message);current = current->next;}
}// 测试观察者模式
int main() {Subject subject = { .observers = NULL };// 创建两个观察者ConcreteObserver o1 = { .base.update = observerUpdate, .name = "Observer 1" };ConcreteObserver o2 = { .base.update = observerUpdate, .name = "Observer 2" };// 将观察者添加到主题中addObserver(&subject, (Observer*)&o1);addObserver(&subject, (Observer*)&o2);// 通知所有观察者notifyObservers(&subject, "Event happened");return 0;
}