返回值類型 (*指針變量名)(參數(shù)列表);

int (*func_ptr)(int, int);

#include <stdio.h>

// 定義回調(diào)函數(shù)類型
typedef void (*CallbackFunction)(int);

// 回調(diào)函數(shù)實現(xiàn)
void myCallback(int value) {
    printf("Callback received value: %d\n", value);
}

// 執(zhí)行回調(diào)的函數(shù)
void performCallback(CallbackFunction callback, int data) {
    callback(data);
}

int main() {
    // 聲明函數(shù)指針并指向回調(diào)函數(shù)
    CallbackFunction ptr = myCallback;

    // 調(diào)用執(zhí)行回調(diào)的函數(shù)，并傳遞函數(shù)指針和數(shù)據(jù)
    performCallback(ptr, 42);

    return 0;
}

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

// 交換兩個元素的位置
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 冒泡排序函數(shù)，使用回調(diào)函數(shù)進行比較
void bubbleSort(int arr[], int n, int (*compare)(int, int)) {
    int i, j;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (compare(arr[j], arr[j + 1])) {
                swap(&arr[j], &arr[j + 1]);
            }
        }
    }
}

// 升序比較函數(shù)
int ascendingCompare(int a, int b) {
    return a > b;
}

// 降序比較函數(shù)
int descendingCompare(int a, int b) {
    return a < b;
}

// 打印數(shù)組函數(shù)
void printArray(int arr[], int size) {
    int i;
    for (i = 0; i < size; i++)
        printf("%d ", arr[i]);
    printf("\n");
}

int main() {
    int arr1[] = {64, 34, 25, 12, 22, 11, 90};
    int arr2[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr1) / sizeof(arr1[0]);

    printf("Original array: ");
    printArray(arr1, n);

    // 按升序排序
    bubbleSort(arr1, n, ascendingCompare);
    printf("Sorted in ascending order: ");
    printArray(arr1, n);

    printf("Original array: ");
    printArray(arr2, n);

    // 按降序排序
    bubbleSort(arr2, n, descendingCompare);
    printf("Sorted in descending order: ");
    printArray(arr2, n);

    return 0;
}

#include <stdio.h>

// 定義錯誤碼枚舉
typedef enum {
    ERROR_NONE = 0,
    ERROR_INVALID_INPUT,
    ERROR_OUT_OF_MEMORY
} ErrorCode;

// 定義回調(diào)函數(shù)類型，包含錯誤碼返回值
typedef ErrorCode (*CallbackFunctionWithError)(int, int, ErrorCode*);

// 回調(diào)函數(shù)實現(xiàn)，處理錯誤
ErrorCode myCallbackWithError(int value1, int value2, ErrorCode* error) {
    if (value1 < 0 || value2 < 0) {
        *error = ERROR_INVALID_INPUT;
        return ERROR_INVALID_INPUT;
    }
    // 正常處理邏輯
    printf("Callback received values: %d and %d\n", value1, value2);
    *error = ERROR_NONE;
    return ERROR_NONE;
}

// 執(zhí)行回調(diào)的函數(shù)，處理錯誤返回
void performCallbackWithError(CallbackFunctionWithError callback, int data1, int data2) {
    ErrorCode error;
    ErrorCode result = callback(data1, data2, &error);
    if (result!= ERROR_NONE) {
        printf("Error occurred: ");
        switch (error) {
            case ERROR_INVALID_INPUT:
                printf("Invalid input\n");
                break;
            case ERROR_OUT_OF_MEMORY:
                printf("Out of memory\n");
                break;
            default:
                printf("Unknown error\n");
        }
    }
}

int main() {
    // 聲明函數(shù)指針并指向回調(diào)函數(shù)
    CallbackFunctionWithError ptr = myCallbackWithError;

    // 正常調(diào)用
    performCallbackWithError(ptr, 5, 10);

    // 錯誤調(diào)用
    performCallbackWithError(ptr, -5, 10);

    return 0;
}

#include <stdio.h>
#include <pthread.h>

// 共享數(shù)據(jù)
int sharedData = 0;

// 互斥鎖
pthread_mutex_t mutex;

// 回調(diào)函數(shù)
void* myCallbackInThread(void* arg) {
    pthread_mutex_lock(&mutex);
    sharedData++;
    printf("In callback: Shared data is now %d\n", sharedData);
    pthread_mutex_unlock(&mutex);
    return NULL;
}

// 線程函數(shù)
void* threadFunction(void* arg) {
    // 調(diào)用回調(diào)函數(shù)
    myCallbackInThread(NULL);
    return NULL;
}

int main() {
    pthread_t thread1, thread2;

    // 初始化互斥鎖
    pthread_mutex_init(&mutex, NULL);

    // 創(chuàng)建線程
    pthread_create(&thread1, NULL, threadFunction, NULL);
    pthread_create(&thread2, NULL, threadFunction, NULL);

    // 等待線程結(jié)束
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    // 銷毀互斥鎖
    pthread_mutex_destroy(&mutex);

    return 0;
}

#include <stdio.h>
#include <unistd.h>

// 異步操作完成的回調(diào)函數(shù)
void asyncOperationComplete(int result, void (*callback)(int)) {
    printf("Async operation completed with result: %d\n", result);
    callback(result);
}

// 異步操作完成后的處理回調(diào)函數(shù)
void handleAsyncResult(int result) {
    printf("Handling async result: %d\n", result);
}

int main() {
    // 模擬異步操作
    asyncOperationComplete(42, handleAsyncResult);

    return 0;
}