C语言仿函数(Functor)实现示例

// 示例：计数器的状态结构体
typedef struct {
    int count;   // 状态1：当前计数值
    int step;    // 状态2：计数步长（可选，扩展用）
} CounterState;

// 计数器的调用函数指针：接收结构体指针，返回当前计数值
typedef int (*CounterCallFunc)(struct Counter* self);

// 完整的计数器仿函数结构体
typedef struct Counter {
    // 状态部分：复用上面的状态结构体（或直接定义成员）
    int count;
    int step;
    // 逻辑部分：函数指针（指向具体调用逻辑）
    CounterCallFunc call;
} Counter;

// 初始化计数器仿函数：参数为初始值和步长
Counter Counter_Create(int initial, int step) {
    Counter cnt;
    // 初始化状态
    cnt.count = initial;
    cnt.step = step;
    // 绑定调用逻辑（关联具体的函数）
    cnt.call = Counter_Increment;
    return cnt;
}

#include <stdio.h>

// 1. 定义计数器仿函数结构体（状态+逻辑）
typedef struct Counter {
    // 状态：计数值、步长
    int count;
    int step;
    // 逻辑：调用函数指针（接收自身指针，返回当前值）
    int (*call)(struct Counter* self);
} Counter;

// 2. 实现调用逻辑：按步长自增并返回当前值
int Counter_Increment(Counter* self) {
    // 通过结构体指针访问内部状态
    self->count += self->step;
    return self->count;
}

// 3. 初始化函数：创建仿函数实例
Counter Counter_Create(int initial, int step) {
    Counter cnt;
    cnt.count = initial;
    cnt.step = step;
    cnt.call = Counter_Increment; // 绑定逻辑
    return cnt;
}

// 4. 辅助函数：动态修改步长（修改状态）
void Counter_SetStep(Counter* self, int new_step) {
    self->step = new_step;
}

// 主函数测试
int main() {
    // 创建仿函数实例：初始值0，步长1
    Counter cnt = Counter_Create(0, 1);
    
    // 调用仿函数（像函数一样使用）
    printf("第1次调用：%d\n", cnt.call(&cnt)); // 输出：1
    printf("第2次调用：%d\n", cnt.call(&cnt)); // 输出：2
    
    // 修改状态（步长改为3）
    Counter_SetStep(&cnt, 3);
    printf("修改步长为3后，第3次调用：%d\n", cnt.call(&cnt)); // 输出：5
    printf("第4次调用：%d\n", cnt.call(&cnt)); // 输出：8
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

// 1. 定义比较器仿函数结构体（状态+逻辑）
typedef struct Comparator {
    // 状态：排序方向（1=升序，0=降序）
    int is_ascending;
    // 逻辑：比较函数指针（接收自身、两个待比较值，返回比较结果）
    int (*compare)(struct Comparator* self, int a, int b);
} Comparator;

// 2. 实现比较逻辑：根据状态返回比较结果
int Int_Compare(Comparator* self, int a, int b) {
    if (self->is_ascending) {
        return a - b; // 升序：a>b返回正数，触发交换
    } else {
        return b - a; // 降序：b>a返回正数，触发交换
    }
}

// 3. 初始化比较器仿函数
Comparator Comparator_Create(int is_ascending) {
    Comparator cmp;
    cmp.is_ascending = is_ascending;
    cmp.compare = Int_Compare;
    return cmp;
}

// 4. 通用排序函数（接收仿函数作为参数，复用逻辑）
void Sort_With_Functor(int* arr, int len, Comparator* cmp) {
    for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - i - 1; j++) {
            // 调用仿函数的比较逻辑
            if (cmp->compare(cmp, arr[j], arr[j+1]) > 0) {
                // 交换元素
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

// 辅助函数：打印数组
void Print_Array(int* arr, int len) {
    for (int i = 0; i < len; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

// 主函数测试
int main() {
    int arr[] = {5, 2, 9, 1, 5, 6};
    int len = sizeof(arr) / sizeof(arr[0]);
    
    printf("原始数组：");
    Print_Array(arr, len); // 输出：5 2 9 1 5 6
    
    // 1. 升序排序（使用升序比较器）
    Comparator asc_cmp = Comparator_Create(1);
    Sort_With_Functor(arr, len, &asc_cmp);
    printf("升序排序后：");
    Print_Array(arr, len); // 输出：1 2 5 5 6 9
    
    // 2. 降序排序（复用排序函数，仅修改比较器状态）
    Comparator desc_cmp = Comparator_Create(0);
    Sort_With_Functor(arr, len, &desc_cmp);
    printf("降序排序后：");
    Print_Array(arr, len); // 输出：9 6 5 5 2 1
    
    return 0;
}

// 动态创建计数器仿函数（堆内存）
Counter* Counter_Create_Dynamic(int initial, int step) {
    Counter* cnt = (Counter*)malloc(sizeof(Counter));
    if (cnt != NULL) {
        cnt->count = initial;
        cnt->step = step;
        cnt->call = Counter_Increment;
    }
    return cnt;
}

// 简化前：直接在结构体中定义函数指针
typedef struct Comparator {
    int is_ascending;
    int (*compare)(struct Comparator* self, int a, int b);
} Comparator;

// 简化后：先typedef函数指针，再在结构体中使用别名
typedef int (*CompareFunc)(struct Comparator* self, int a, int b);
typedef struct Comparator {
    int is_ascending;
    CompareFunc compare; // 更简洁
} Comparator;

typedef struct RangeCounter {
    int count;
    int min;
    int max;
    int (*call)(struct RangeCounter* self); // 调用时自增，超出范围返回-1
} RangeCounter;

int RangeCounter_Increment(RangeCounter* self) {
    if (self->count >= self->max) {
        printf("已达最大值！\n");
        return -1;
    }
    self->count++;
    return self->count;
}

// 初始化：初始值0，范围[0,5]
RangeCounter RangeCounter_Create(int min, int max) {
    RangeCounter cnt;
    cnt.count = min;
    cnt.min = min;
    cnt.max = max;
    cnt.call = RangeCounter_Increment;
    return cnt;
}

int main() {
    // 创建3个不同步长的计数器
    Counter counters[3] = {
        Counter_Create(0, 1),
        Counter_Create(0, 2),
        Counter_Create(0, 3)
    };
    
    // 批量调用仿函数
    for (int i = 0; i < 3; i++) {
        printf("计数器%d第1次调用：%d\n", i+1, counters[i].call(&counters[i]));
    }
    // 输出：
    // 计数器1第1次调用：1
    // 计数器2第1次调用：2
    // 计数器3第1次调用：3
    return 0;
}