用C语言能帮我实现一个策略模式的框架，方便以后我扩展自己的策略

策略模式是一种设计模式，它允许在运行时选择算法的行为。为了实现一个策略模式的框架，你可以按照以下步骤进行：

定义一个策略接口，该接口应该包含所有的算法方法。
定义一个上下文类，该类应该包含一个策略接口的指针，以及一个设置策略的方法。
实现多个具体策略类，这些类应该实现策略接口中定义的所有算法方法。
在上下文类中实现算法切换逻辑，即根据需要选择特定的策略类，并将其设置为上下文类的策略指针。

以下是一个简单的示例代码：

// 定义策略接口
typedef struct _Strategy {
    void (*method1)(void);
    void (*method2)(void);
} Strategy;

// 定义具体策略类1
typedef struct _ConcreteStrategy1 {
    Strategy strategy;
} ConcreteStrategy1;

void ConcreteStrategy1_method1(void) {
    // 实现具体算法1
}

void ConcreteStrategy1_method2(void) {
    // 实现具体算法2
}

ConcreteStrategy1 concrete_strategy1_instance = {
    .strategy = {
        .method1 = ConcreteStrategy1_method1,
        .method2 = ConcreteStrategy1_method2
    }
};

// 定义具体策略类2
typedef struct _ConcreteStrategy2 {
    Strategy strategy;
} ConcreteStrategy2;

void ConcreteStrategy2_method1(void) {
    // 实现具体算法1
}

void ConcreteStrategy2_method2(void) {
    // 实现具体算法2
}

ConcreteStrategy2 concrete_strategy2_instance = {
    .strategy = {
        .method1 = ConcreteStrategy2_method1,
        .method2 = ConcreteStrategy2_method2
    }
};

// 定义上下文类
typedef struct _Context {
    Strategy* strategy;
} Context;

void Context_setStrategy(Context* context, Strategy* strategy) {
    context->strategy = strategy;
}

void Context_executeMethod1(Context* context) {
    context->strategy->method1();
}

void Context_executeMethod2(Context* context) {
    context->strategy->method2();
}

// 使用示例
int main(void) {
    // 创建上下文对象
    Context context = {
        .strategy = NULL
    };

    // 设置具体策略类1为当前策略
    Context_setStrategy(&context, &concrete_strategy1_instance.strategy);

    // 执行算法1
    Context_executeMethod1(&context);

    // 执行算法2
    Context_executeMethod2(&context);

    // 设置具体策略类2为当前策略
    Context_setStrategy(&context, &concrete_strategy2_instance.strategy);

    // 执行算法1
    Context_executeMethod1(&context);

    // 执行算法2
    Context_executeMethod2(&context);

    return 0;
}

在这个示例中，我们定义了一个策略接口Strategy，并在具体策略类ConcreteStrategy1和ConcreteStrategy2中实现了相应的算法方法。然后我们定义了一个上下文类Context，并在其中实现了算法切换逻辑。最后，在main函数中，我们创建了上下文对象并设置了不同的具体策略类来执行算法。