C语言实现策略模式

策略模式（Strategy Pattern）的核心是定义一系列算法，将每个算法封装起来，并使它们可以相互替换，从而让算法的变化独立于使用算法的客户端。在C语言中，可以通过函数指针（封装算法）+ 策略结构体（统一接口） 实现：客户端通过策略结构体调用不同算法，无需关心具体实现。

C语言实现策略模式的思路

1. 策略接口（Strategy）：定义算法的统一接口（函数指针结构体）。
2. 具体策略（Concrete Strategy）：实现策略接口，封装不同的算法逻辑。
3. 上下文（Context）：持有策略接口的指针，提供统一的接口供客户端调用，负责策略的切换。

示例：排序算法策略（多种排序算法可切换）

假设需要实现多种排序算法（冒泡排序、快速排序），客户端可根据场景动态选择排序策略，且无需修改排序调用逻辑。

步骤1：定义策略接口（排序算法接口）

#include <stdio.h>
#include <stdlib.h>// 策略接口：排序算法的统一接口
typedef struct SortStrategy {// 排序方法：参数为待排序数组、数组长度void (*sort)(int* arr, int length);
} SortStrategy;

步骤2：实现具体策略（不同排序算法）

2.1 冒泡排序策略

// 具体策略1：冒泡排序
static void bubble_sort(int* arr, int length) {printf("使用冒泡排序：\n");for (int i = 0; i < length - 1; i++) {for (int j = 0; j < length - i - 1; j++) {if (arr[j] > arr[j + 1]) {// 交换元素int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}
}// 初始化冒泡排序策略
SortStrategy* bubble_strategy_create() {static SortStrategy strategy; // 静态实例，避免动态分配strategy.sort = bubble_sort;return &strategy;
}

2.2 快速排序策略

// 快速排序辅助函数：分区
static int partition(int* arr, int low, int high) {int pivot = arr[high]; // 基准值int i = low - 1;       // 小于基准值的元素索引for (int j = low; j < high; j++) {if (arr[j] <= pivot) {i++;// 交换元素int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}// 交换基准值到正确位置int temp = arr[i + 1];arr[i + 1] = arr[high];arr[high] = temp;return i + 1;
}// 快速排序递归实现
static void quick_sort_recursive(int* arr, int low, int high) {if (low < high) {int pi = partition(arr, low, high); // 分区索引quick_sort_recursive(arr, low, pi - 1);  // 左分区排序quick_sort_recursive(arr, pi + 1, high); // 右分区排序}
}// 具体策略2：快速排序（对外接口）
static void quick_sort(int* arr, int length) {printf("使用快速排序：\n");if (length <= 1) return;quick_sort_recursive(arr, 0, length - 1);
}// 初始化快速排序策略
SortStrategy* quick_strategy_create() {static SortStrategy strategy;strategy.sort = quick_sort;return &strategy;
}

步骤3：实现上下文（排序器，管理策略）

上下文持有策略指针，提供统一的排序接口，并支持动态切换策略。

// 上下文：排序器（使用策略的客户端）
typedef struct {SortStrategy* strategy; // 持有策略接口指针
} Sorter;// 初始化排序器（绑定初始策略）
void sorter_init(Sorter* sorter, SortStrategy* strategy) {sorter->strategy = strategy;
}// 切换策略
void sorter_set_strategy(Sorter* sorter, SortStrategy* strategy) {sorter->strategy = strategy;
}// 执行排序（通过策略接口调用具体算法）
void sorter_execute(Sorter* sorter, int* arr, int length) {if (sorter->strategy && arr && length > 0) {sorter->strategy->sort(arr, length); // 委托给策略执行}
}// 打印数组（辅助函数）
void print_array(int* arr, int length) {for (int i = 0; i < length; i++) {printf("%d ", arr[i]);}printf("\n");
}

步骤4：使用策略模式

客户端通过上下文切换不同策略，实现算法的灵活替换。

int main() {// 待排序数组int arr1[] = {5, 2, 9, 1, 5, 6};int length1 = sizeof(arr1) / sizeof(arr1[0]);int arr2[] = {3, 8, 7, 1, 2, 5, 4};int length2 = sizeof(arr2) / sizeof(arr2[0]);// 创建具体策略SortStrategy* bubble = bubble_strategy_create();SortStrategy* quick = quick_strategy_create();// 创建上下文（排序器）Sorter sorter;// 1. 使用冒泡排序sorter_init(&sorter, bubble);printf("排序前：");print_array(arr1, length1);sorter_execute(&sorter, arr1, length1);printf("排序后：");print_array(arr1, length1);// 2. 切换为快速排序printf("\n切换策略为快速排序：\n");printf("排序前：");print_array(arr2, length2);sorter_set_strategy(&sorter, quick);sorter_execute(&sorter, arr2, length2);printf("排序后：");print_array(arr2, length2);return 0;
}

输出结果

排序前：5 2 9 1 5 6 
使用冒泡排序：
排序后：1 2 5 5 6 9 切换策略为快速排序：
排序前：3 8 7 1 2 5 4 
使用快速排序：
排序后：1 2 3 4 5 7 8 

核心思想总结

1. 算法封装与替换：每个算法（冒泡、快速排序）被封装为独立的策略，客户端通过切换策略指针实现算法替换，无需修改调用逻辑。
2. 开放-封闭原则：新增排序算法（如插入排序）时，只需实现SortStrategy接口，无需修改上下文或其他策略代码。
3. 消除条件判断：避免了用if-else或switch判断选择算法的硬编码（如if (type == 1) 冒泡; else if (type == 2) 快速;），提高代码灵活性。

C语言通过函数指针直接封装算法，结合上下文管理策略，简洁地实现了策略模式的核心。这种模式适合处理“同一问题有多种解决方案，且需要动态选择”的场景（如支付方式、压缩算法、日志输出方式等）。