Function Pointer and Callbacks

Function pointers are one of the powerful features of the C programming language. They allow us to treat functions as variables, enabling dynamic behavior and flexibility in program design.

What are Function Pointers?

In C, functions are essentially blocks of code that can be executed. Function pointers, as the name suggests, are pointers that point to functions instead of data variables. They hold the address of a function in memory, allowing us to call that function indirectly.

Declaration and Syntax

To declare a function pointer, you need to specify the return type and parameter types of the function it will point to. The syntax is as follows:

				
					return_type (*pointer_name)(parameter_types);

				
					int (*funcPtr)(int, int);

This declares a function pointer named funcPtr that points to a function taking two int parameters and returning an int.

Assigning Functions to Pointers

Function pointers can be assigned the address of a function using the address-of operator & before the function name or directly without &. The syntax for assignment is:

				
					pointer_name = &function_name;

or simply

				
					pointer_name = function_name;

				
					int sum(int a, int b) {
    return a + b;
}

int (*funcPtr)(int, int);
funcPtr = &sum; // or funcPtr = sum;

Using Function Pointers

Now that we understand how to declare and assign function pointers, let’s explore how to use them in practical scenarios.

Calling Functions Through Pointers

Once a function is assigned to a pointer, we can call that function indirectly using the function pointer. The syntax for calling a function through a pointer is:

				
					return_type result = pointer_name(arguments);

				
					int result = (*funcPtr)(10, 5);

or simply

				
					int result = funcPtr(10, 5); // This is equivalent

Example: Function Pointers in Sorting

One common application of function pointers is in sorting algorithms, where different comparison functions can be passed to achieve various sorting orders (e.g., ascending, descending).

Consider the following example of sorting an array of integers using function pointers:

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

// Comparison function for ascending order
int compareAsc(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

// Comparison function for descending order
int compareDesc(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

// Sorting function using function pointer for comparison
void sort(int arr[], int n, int (*cmp)(const void *, const void *)) {
    qsort(arr, n, sizeof(int), cmp);
}

int main() {
    int arr[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("Original array: ");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");

    // Sort in ascending order
    sort(arr, n, compareAsc);
    printf("Sorted array (ascending): ");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");

    // Sort in descending order
    sort(arr, n, compareDesc);
    printf("Sorted array (descending): ");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");

    return 0;
}

				
					// output //
Original array: 3 1 4 1 5 9 2 6 5 3 
Sorted array (ascending): 1 1 2 3 3 4 5 5 6 9 
Sorted array (descending): 9 6 5 5 4 3 3 2 1 1

Explanation:

We include necessary header files: stdio.h for standard input/output functions and stdlib.h for functions like qsort.
We define two comparison functions: compareAsc and compareDesc. These functions will be used to sort the array in ascending and descending order, respectively.
The sort function is defined. It takes an array arr[], its size n, and a function pointer (*cmp) as arguments. This function pointer points to a comparison function.
Inside the main function:
- We initialize an array arr[] with some integers.
- We calculate the size of the array n.
- We print the original array.
- We call the sort function twice:
  - First, with compareAsc function pointer to sort the array in ascending order.
  - Second, with compareDesc function pointer to sort the array in descending order.
- We print the sorted arrays.

As we can see, the original array is printed, followed by the sorted array in ascending order, and then in descending order. The sorting is done correctly according to the comparison functions provided.

Callback Functions

Callback functions are functions that are passed as arguments to other functions. They allow for the implementation of generic algorithms by providing a way to customize behavior without modifying the original function.

Callback functions serve as a means of communication between two functions. The function that accepts the callback function as an argument can then call it during its execution.

Example: Using Callbacks for Customized Printing

Let’s consider an example where we have a function process that performs some operation on data and prints it. We want to allow users to customize the printing behavior by providing their own callback function.

				
					#include <stdio.h>

// Callback function type definition
typedef void (*Callback)(int);

// Function to process data and print using callback
void process(int data[], int size, Callback callback) {
    for (int i = 0; i < size; i++)
        callback(data[i]);
}

// Callback function for printing data
void printData(int value) {
    printf("%d ", value);
}

// Callback function for printing data in squared form
void printSquared(int value) {
    printf("%d ", value * value);
}

int main() {
    int data[] = {1, 2, 3, 4, 5};
    int size = sizeof(data) / sizeof(data[0]);

    printf("Original data: ");
    process(data, size, printData); // Print original data
    printf("\n");

    printf("Squared data: ");
    process(data, size, printSquared); // Print data squared
    printf("\n");

    return 0;
}

				
					// output //
Original data: 1 2 3 4 5 
Squared data: 1 4 9 16 25

Explanation:

We define a callback function type Callback, which is a pointer to a function taking an integer argument and returning void.
We define a function process that takes an array data[], its size size, and a callback function as arguments. Inside this function, we iterate through the array and call the callback function for each element.
We define two callback functions: printData and printSquared. The first one prints the data as it is, and the second one prints the squared value of the data.
In the main function:
- We initialize an array data[] with some integers.
- We calculate the size of the array size.
- We call the process function twice:
  - First, with printData callback function to print the original data.
  - Second, with printSquared callback function to print the squared data.

As we can see, the original data is printed first, and then the squared data is printed. The process function successfully invokes the respective callback functions (printData and printSquared) for each element of the array data[].

Function pointers and callback functions are powerful features in C that provide flexibility and enable generic programming techniques. By understanding how to use them, programmers can create more dynamic and adaptable software systems. Practice and experimentation are key to mastering these concepts, but once understood, they can significantly enhance a programmer's toolkit.Happy coding!❤️