函数指针数组

#include <stdio.h>

int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }
int divide(int a, int b) { return a / b; }

int main() {
    // 定义一个函数指针数组
    int (*func_ptr[4])(int, int) = { add, subtract, multiply, divide };

    int a = 20, b = 5;

    //1. 使用函数指针数组
    printf("Add: %d\n", func_ptr[0](a, b));        // 输出：Add: 25
    printf("Subtract: %d\n", func_ptr[1](a, b));   // 输出：Subtract: 15
    printf("Multiply: %d\n", func_ptr[2](a, b));   // 输出：Multiply: 100
    printf("Divide: %d\n", func_ptr[3](a, b));     // 输出：Divide: 4
      // 2. 可以使用for循环调用，类似于工厂模式的设计
    return 0;
}

回调函数

回调函数是一个通过函数指针调用的函数，通常用于事件驱动的程序或函数作为参数传递：

#include <stdio.h>

// 回调函数类型
typedef void (*callback_t)(int);

// 示例回调函数
void my_callback(int a) {
    printf("Callback called with value: %d\n", a);
}

// 函数接受一个回调函数作为参数
void register_callback(callback_t cb, int value) {
    // 调用回调函数
    cb(value);
}

int main() {
    // 注册并调用回调函数
    register_callback(my_callback, 42); // 输出：Callback called with value: 42

    return 0;
}

模拟面向对象编程

通过结构体和函数指针可以模拟C++中的类和方法：

#include <stdio.h>

// 定义“类”的结构体
typedef struct {
    int x;
    int y;
    void (*set_values)(struct Point*, int, int);
    void (*print)(struct Point*);
} Point;

// 函数定义
void set_values(Point* p, int a, int b) {
    p->x = a;
    p->y = b;
}

void print(Point* p) {
    printf("Point(%d, %d)\n", p->x, p->y);
}

int main() {
    // 定义并初始化Point实例
    Point p;
    p.set_values = set_values;
    p.print = print;

    // 使用函数指针调用方法
    p.set_values(&p, 10, 20);
    p.print(&p); // 输出：Point(10, 20)

    return 0;
}

策略模式

策略模式是一种行为设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以互换。

#include <stdio.h>

// 定义策略接口
typedef struct {
    int (*execute)(int, int);
} Strategy;

// 不同的策略实现
int add_strategy(int a, int b) {
    return a + b;
}

int subtract_strategy(int a, int b) {
    return a - b;
}

// 定义上下文结构体
typedef struct {
    Strategy* strategy;
} Context;

// 上下文执行策略
int context_execute_strategy(Context* context, int a, int b) {
    return context->strategy->execute(a, b);
}

int main() {
    // 定义策略
    Strategy add = { add_strategy };
    Strategy subtract = { subtract_strategy };

    // 定义上下文并设置策略
    Context context;
    context.strategy = &add;
    printf("Add: %d\n", context_execute_strategy(&context, 10, 5)); // 输出：Add: 15

    context.strategy = &subtract;
    printf("Subtract: %d\n", context_execute_strategy(&context, 10, 5)); // 输出：Subtract: 5

    return 0;
}