策略模式（Strategy Pattern）的核心是定义一系列算法，将每个算法封装起来，并使它们可以相互替换 ，从而让算法的变化独立于使用算法的客户端。在C语言中，可以通过函数指针（封装算法）+ 策略结构体（统一接口） 实现：客户端通过策略结构体调用不同算法，无需关心具体实现。
C语言实现策略模式的思路
- 策略接口（Strategy）：定义算法的统一接口（函数指针结构体）。
- 具体策略（Concrete Strategy）：实现策略接口，封装不同的算法逻辑。
- 上下文（Context）：持有策略接口的指针，提供统一的接口供客户端调用，负责策略的切换。
示例：排序算法策略（多种排序算法可切换）
假设需要实现多种排序算法（冒泡排序、快速排序），客户端可根据场景动态选择排序策略，且无需修改排序调用逻辑。
步骤1：定义策略接口（排序算法接口）
c
#include <stdio.h>
#include <stdlib.h>
// 策略接口：排序算法的统一接口
typedef struct SortStrategy {
// 排序方法：参数为待排序数组、数组长度
void (*sort)(int* arr, int length);
} SortStrategy;步骤2：实现具体策略（不同排序算法）
2.1 冒泡排序策略
c
// 具体策略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 快速排序策略
c
// 快速排序辅助函数：分区
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：实现上下文（排序器，管理策略）
上下文持有策略指针，提供统一的排序接口，并支持动态切换策略。
c
// 上下文：排序器（使用策略的客户端）
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：使用策略模式
客户端通过上下文切换不同策略，实现算法的灵活替换。
c
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 核心思想总结
- 算法封装与替换：每个算法（冒泡、快速排序）被封装为独立的策略，客户端通过切换策略指针实现算法替换，无需修改调用逻辑。
- 开放-封闭原则 ：新增排序算法（如插入排序）时，只需实现
SortStrategy接口，无需修改上下文或其他策略代码。 - 消除条件判断 ：避免了用
if-else或switch判断选择算法的硬编码（如if (type == 1) 冒泡; else if (type == 2) 快速;），提高代码灵活性。
C语言通过函数指针直接封装算法，结合上下文管理策略，简洁地实现了策略模式的核心。这种模式适合处理"同一问题有多种解决方案，且需要动态选择"的场景（如支付方式、压缩算法、日志输出方式等）。