00000007_C语言设计模式

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;

    // 使用策略A
    strategy.execute = strategyA;
    strategy.execute();

    // 切换为策略B
    strategy.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;
}