C Programming Function Pointers And Callbacks Complete Guide

1. What is a Function Pointer in C?

Answer: A function pointer is a variable that stores the address of a function that can later be called using this variable name. Essentially, it allows you to refer to a function by its memory address and invoke it indirectly. Function pointers can be used for implementing callback functions, generic algorithms, etc.

2. How do you declare a Function Pointer in C?

Answer: To declare a function pointer, you need to specify the return type and the parameters of the function it points to. For example, if you have a function int foo(int x, int y), you can declare a function pointer like this:

int (*func_ptr)(int, int);

Here, func_ptr is a variable that can store the address of any function that takes two int arguments and returns an int.

3. Can you provide an example of how to use a Function Pointer?

Answer: Sure. Consider a simple example where we have a couple of math functions and a generic function that takes a function pointer to perform an operation on two values.

#include <stdio.h>

int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }

int operate(int (*operation)(int, int), int a, int b) {
    return operation(a, b);
}

int main() {
    int result = operate(add, 5, 3);
    printf("Add: %d\n", result);

    result = operate(subtract, 5, 3);
    printf("Subtract: %d\n", result);
    return 0;
}

In this example, operate() is a generic function that takes another function (either add or subtract) via a function pointer to perform the desired operation.

4. What are Callback Functions?

Answer: Callback functions are functions passed into another function as an argument (often via a function pointer) to be executed at a later time. They allow programs to call pre-determined functions when certain events occur. Callbacks are widely used in asynchronous programming, GUI applications, etc.

5. Provide an Example of a Callback Function?

Answer: Here’s an example where a callback function is used to process an array of integers using a user-defined operation (like sorting or filtering).

#include <stdio.h>

void sortAscending(int *array, int length) {
    for (int i = 0; i < length - 1; i++) {
        for (int j = 0; j < length - i - 1; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

void processArray(int *array, int length, void (*callback)(int*, int)) {
    callback(array, length);
}

int main() {
    int data[] = {5, 2, 9, 1, 5, 6};
    int length = sizeof(data)/sizeof(data[0]);
    
    processArray(data, length, sortAscending);
    
    printf("Sorted array: ");
    for (int i = 0; i < length; i++)
        printf("%d ", data[i]);

    return 0;
}

In this program, sortAscending is a callback function that gets invoked inside processArray to sort the array.

6. How do you handle Function Pointers in Headers?

Answer: In headers, you declare function pointers using a similar syntax to what you would in a code file but avoid defining them here. For instance, if you want to pass a comparator for sorting, you'd do something like this:

// my_header.h
#ifndef MY_HEADER_H_
#define MY_HEADER_H_

typedef int (*Comparator)(const void*, const void*);

void processArray(int *array, int length, Comparator cmp);

#endif // MY_HEADER_H_

The actual implementation of processArray would go in the corresponding .c file.

7. Are There Any Limitations to Using Function Pointers?

Answer: Yes, there are some limitations to function pointers:

• They cannot point to overloaded functions because C does not support overloading.
• Variadic functions (functions taking variable number of arguments like printf) cannot be pointed to by function pointers with specific signatures.
• They increase the indirection level in the code potentially making debugging harder.
• They might lead to less performance due to indirection.

8. Can a Function Pointer be NULL?

Answer: Yes, a function pointer can be set to NULL. This is useful when you want to ensure no function is executed inadvertently through the pointer. However, attempting to call a function via a NULL function pointer will cause a runtime error.

int (*func_ptr)(int, int) = NULL;
if (func_ptr != NULL) {
    func_ptr(5, 3); // Safe call
}

9. What is the Difference between Regular Functions and those Invoked Through Function Pointers?

Answer: Regular functions are called directly by their names. When calling a regular function, the compiler knows exactly which function is supposed to be executed, leading to more efficient code. In contrast, function pointers provide indirect invocation; the function to execute is determined at runtime based on the value stored in the pointer. This flexibility comes with a slight overhead and risk of errors if the wrong type is assigned to the pointer.

10. How Do You Compare Two Function Pointers?

Answer: In C, function pointers can be compared using standard comparison operators to check if they point to the same function or a different one. Both the return type and the parameters must match for two function pointers to be considered equal. If they are pointing to the same function, their addresses are also equal.

int (*func_ptr1)(int, int) = add;
int (*func_ptr2)(int, int) = subtract;
int (*func_ptr3)(int, int) = add;

if (func_ptr1 == func_ptr3) {
    printf("func_ptr1 and func_ptr3 point to the same function.\n");
} else {
    printf("Different functions.\n");
}

Here, func_ptr1 and func_ptr3 point to the same function (add), so they are equal.