What is the point of function pointers in C?

Function pointers are highly valuable in C programming, primarily serving two key purposes: enhancing software flexibility and supporting callback functions.

Enhancing Software Flexibility

Function pointers enable passing functions as arguments to other functions, significantly increasing program flexibility. For instance, when implementing a sorting algorithm, we can pass different comparison functions via function pointers, allowing the same sorting algorithm to work with different data types or sorting criteria.

Example Code:

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

int compare_ints(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

void sort(void* arr, size_t n, size_t elem_size, int (*compare)(const void*, const void*)) {
    qsort(arr, n, elem_size, compare);
}

int main() {
    int arr[] = {5, 2, 9, 1, 5, 6};
    sort(arr, 6, sizeof(int), compare_ints);
    for (int i = 0; i < 6; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

In this example, the sort function accepts a function pointer compare to allow users to customize the comparison logic.

Supporting Callback Functions

Function pointers enable the implementation of callback mechanisms, where one function invokes another after completion. This pattern is common in event-driven programming, particularly in Graphical User Interface (GUI) programming. Through callback functions, libraries or frameworks allow users to insert their own code to execute when specific events occur.

Example Code:

c
#include <stdio.h>

void eventHandler(void (*callback)(void)) {
    // Simulate event processing
    printf("Event processing started...
");
    callback();
    printf("Event processing completed.
");
}

void onEvent() {
    printf("Executing operations in callback function.
");
}

int main() {
    eventHandler(onEvent);
    return 0;
}

In this example, the eventHandler function accepts a function pointer callback as a parameter, which is invoked when event processing requires executing user-defined operations.

Overall, the use of function pointers provides modularization and flexibility in code, enabling developers to write more generic, reusable, and configurable code.