// 示例：計(jì)數(shù)器的狀態(tài)結(jié)構(gòu)體
typedef struct {
    int count;   // 狀態(tài)1：當(dāng)前計(jì)數(shù)值
    int step;    // 狀態(tài)2：計(jì)數(shù)步長(zhǎng)（可選，擴(kuò)展用）
} CounterState;

// 計(jì)數(shù)器的調(diào)用函數(shù)指針：接收結(jié)構(gòu)體指針，返回當(dāng)前計(jì)數(shù)值
typedef int (*CounterCallFunc)(struct Counter* self);

// 完整的計(jì)數(shù)器仿函數(shù)結(jié)構(gòu)體
typedef struct Counter {
    // 狀態(tài)部分：復(fù)用上面的狀態(tài)結(jié)構(gòu)體（或直接定義成員）
    int count;
    int step;
    // 邏輯部分：函數(shù)指針（指向具體調(diào)用邏輯）
    CounterCallFunc call;
} Counter;

// 初始化計(jì)數(shù)器仿函數(shù)：參數(shù)為初始值和步長(zhǎng)
Counter Counter_Create(int initial, int step) {
    Counter cnt;
    // 初始化狀態(tài)
    cnt.count = initial;
    cnt.step = step;
    // 綁定調(diào)用邏輯（關(guān)聯(lián)具體的函數(shù)）
    cnt.call = Counter_Increment;
    return cnt;
}

#include <stdio.h>

// 1. 定義計(jì)數(shù)器仿函數(shù)結(jié)構(gòu)體（狀態(tài)+邏輯）
typedef struct Counter {
    // 狀態(tài)：計(jì)數(shù)值、步長(zhǎng)
    int count;
    int step;
    // 邏輯：調(diào)用函數(shù)指針（接收自身指針，返回當(dāng)前值）
    int (*call)(struct Counter* self);
} Counter;

// 2. 實(shí)現(xiàn)調(diào)用邏輯：按步長(zhǎng)自增并返回當(dāng)前值
int Counter_Increment(Counter* self) {
    // 通過(guò)結(jié)構(gòu)體指針訪問(wèn)內(nèi)部狀態(tài)
    self->count += self->step;
    return self->count;
}

// 3. 初始化函數(shù)：創(chuàng)建仿函數(shù)實(shí)例
Counter Counter_Create(int initial, int step) {
    Counter cnt;
    cnt.count = initial;
    cnt.step = step;
    cnt.call = Counter_Increment; // 綁定邏輯
    return cnt;
}

// 4. 輔助函數(shù)：動(dòng)態(tài)修改步長(zhǎng)（修改狀態(tài)）
void Counter_SetStep(Counter* self, int new_step) {
    self->step = new_step;
}

// 主函數(shù)測(cè)試
int main() {
    // 創(chuàng)建仿函數(shù)實(shí)例：初始值0，步長(zhǎng)1
    Counter cnt = Counter_Create(0, 1);
    
    // 調(diào)用仿函數(shù)（像函數(shù)一樣使用）
    printf("第1次調(diào)用：%d\n", cnt.call(&cnt)); // 輸出：1
    printf("第2次調(diào)用：%d\n", cnt.call(&cnt)); // 輸出：2
    
    // 修改狀態(tài)（步長(zhǎng)改為3）
    Counter_SetStep(&cnt, 3);
    printf("修改步長(zhǎng)為3后，第3次調(diào)用：%d\n", cnt.call(&cnt)); // 輸出：5
    printf("第4次調(diào)用：%d\n", cnt.call(&cnt)); // 輸出：8
    
    return 0;
}

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

// 1. 定義比較器仿函數(shù)結(jié)構(gòu)體（狀態(tài)+邏輯）
typedef struct Comparator {
    // 狀態(tài)：排序方向（1=升序，0=降序）
    int is_ascending;
    // 邏輯：比較函數(shù)指針（接收自身、兩個(gè)待比較值，返回比較結(jié)果）
    int (*compare)(struct Comparator* self, int a, int b);
} Comparator;

// 2. 實(shí)現(xiàn)比較邏輯：根據(jù)狀態(tài)返回比較結(jié)果
int Int_Compare(Comparator* self, int a, int b) {
    if (self->is_ascending) {
        return a - b; // 升序：a>b返回正數(shù)，觸發(fā)交換
    } else {
        return b - a; // 降序：b>a返回正數(shù)，觸發(fā)交換
    }
}

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

// 4. 通用排序函數(shù)（接收仿函數(shù)作為參數(shù)，復(fù)用邏輯）
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++) {
            // 調(diào)用仿函數(shù)的比較邏輯
            if (cmp->compare(cmp, arr[j], arr[j+1]) > 0) {
                // 交換元素
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

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

// 主函數(shù)測(cè)試
int main() {
    int arr[] = {5, 2, 9, 1, 5, 6};
    int len = sizeof(arr) / sizeof(arr[0]);
    
    printf("原始數(shù)組：");
    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. 降序排序（復(fù)用排序函數(shù)，僅修改比較器狀態(tài)）
    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;
}

// 動(dòng)態(tài)創(chuàng)建計(jì)數(shù)器仿函數(shù)（堆內(nèi)存）
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;
}

// 簡(jiǎn)化前：直接在結(jié)構(gòu)體中定義函數(shù)指針
typedef struct Comparator {
    int is_ascending;
    int (*compare)(struct Comparator* self, int a, int b);
} Comparator;

// 簡(jiǎn)化后：先typedef函數(shù)指針，再在結(jié)構(gòu)體中使用別名
typedef int (*CompareFunc)(struct Comparator* self, int a, int b);
typedef struct Comparator {
    int is_ascending;
    CompareFunc compare; // 更簡(jiǎn)潔
} Comparator;

typedef struct RangeCounter {
    int count;
    int min;
    int max;
    int (*call)(struct RangeCounter* self); // 調(diào)用時(shí)自增，超出范圍返回-1
} RangeCounter;

int RangeCounter_Increment(RangeCounter* self) {
    if (self->count >= self->max) {
        printf("已達(dá)最大值！\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() {
    // 創(chuàng)建3個(gè)不同步長(zhǎng)的計(jì)數(shù)器
    Counter counters[3] = {
        Counter_Create(0, 1),
        Counter_Create(0, 2),
        Counter_Create(0, 3)
    };
    
    // 批量調(diào)用仿函數(shù)
    for (int i = 0; i < 3; i++) {
        printf("計(jì)數(shù)器%d第1次調(diào)用：%d\n", i+1, counters[i].call(&counters[i]));
    }
    // 輸出：
    // 計(jì)數(shù)器1第1次調(diào)用：1
    // 計(jì)數(shù)器2第1次調(diào)用：2
    // 計(jì)數(shù)器3第1次調(diào)用：3
    return 0;
}