Logo
Back

How do function pointers in C work?

In C, function pointers allow you to reference functions dynamically, much like how you use normal pointers to reference data. Instead of pointing to a memory location that stores integers or other data, a function pointer points to a specific function’s entry point in memory. Below is an overview of why and how they work, along with code examples.

1. Declaring and Defining a Function Pointer

Syntax

// General syntax pattern for a function pointer:
// return_type (*function_pointer_name)(parameter_types);

int (*funcPtr)(int, int);
  • Example: If you have a function that takes two int parameters and returns an int, you declare a pointer to such a function with the above syntax.

Example in Context

#include <stdio.h>

// A simple function matching the signature int(int, int)
int add(int a, int b) {
    return a + b;
}

int main(void) {
    // Declare the function pointer
    int (*funcPtr)(int, int);

    // Initialize it to point to 'add'
    funcPtr = add;

    // Call the function via the pointer
    int result = funcPtr(3, 4);
    printf("Result: %d\n", result);  // Output: 7

    return 0;
}
  • Declaration: int (*funcPtr)(int, int); states that funcPtr is a pointer to a function that takes two ints and returns an int.
  • Assignment: funcPtr = add; makes funcPtr point to the function add.
  • Usage: funcPtr(3, 4); calls the function just like a normal function call.

2. Why Use Function Pointers?

  1. Callbacks

    • Often used to pass a function as an argument to another function (e.g., sorting functions that accept a custom comparison function).

  2. Polymorphism in C

    • You can simulate object-oriented behavior (vtable-like structures) by storing arrays of function pointers or using function pointers in structures.

  3. Dynamic Dispatch

    • Allows you to pick which function to call at runtime based on some condition, rather than using multiple if-else or switch statements.

3. Common Examples

Callback in Sorting

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

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

int main(void) {
    int arr[] = { 42, 17, 56, 23, 5 };
    size_t size = sizeof(arr) / sizeof(arr[0]);

    // qsort takes a function pointer to compare elements
    qsort(arr, size, sizeof(int), compareInts);

    for (size_t i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    // Possible output: 5 17 23 42 56
    return 0;
}
  • qsort is part of the C standard library (stdlib.h). It uses a function pointer to let you provide a custom comparison function for different data types.

Function Pointers in Structs

#include <stdio.h>

// Define a struct that contains a function pointer
typedef struct {
    int (*operation)(int, int);
} Calculator;

// Some operations
int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }

int main(void) {
    Calculator calcAdd = { add };
    Calculator calcMul = { multiply };

    printf("Add: %d\n", calcAdd.operation(2, 3));      // 5
    printf("Mul: %d\n", calcMul.operation(2, 3));      // 6

    return 0;
}
  • This approach is similar to vtables in C++ or basic “object-oriented” patterns in C.

4. Function Pointer Arrays

It’s also possible to store multiple function pointers in an array:

#include <stdio.h>

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }

int main(void) {
    // Array of pointers to functions taking (int, int) -> int
    int (*ops[3])(int, int) = { add, sub, mul };

    // Example usage
    printf("ops[0](5,2) = %d\n", ops[0](5, 2));  // 7  (add)
    printf("ops[1](5,2) = %d\n", ops[1](5, 2));  // 3  (sub)
    printf("ops[2](5,2) = %d\n", ops[2](5, 2));  // 10 (mul)

    return 0;
}
  • This technique is handy when you need a menu of operations or a state machine that can dispatch different functions based on some external condition.

5. Caveats and Tips

  1. Match Signatures

    • The function pointer’s signature (return type and parameters) must match the function you assign to it. Mismatched signatures can cause undefined behavior.

  2. Readability

    • Function pointer syntax can be verbose and tricky. Consider using typedefs to make code more readable: 
      typedef int (*operation_t)(int, int);
operation_t funcPtr = add;

  3. Safety

    • Always ensure you initialize function pointers before calling them. Calling an uninitialized (or NULL) function pointer leads to crashes or unpredictable behavior.

  4. Casting

    • Avoid casting function pointers to or from other pointer types unless you have a very specific reason. Casting can hide potential errors.

Sharpen Your Skills Further

Mastering function pointers will significantly strengthen your understanding of C, memory management, and lower-level programming patterns. If you’re preparing for coding interviews or want to deepen your knowledge of data structures, here are two recommended courses from DesignGurus.io:

  1. Grokking Data Structures & Algorithms for Coding Interviews

    • Build a strong foundation in arrays, linked lists, graphs, sorting, and more—critical for passing technical interviews.

  2. Grokking the Coding Interview: Patterns for Coding Questions

    • Learn common coding patterns that appear repeatedly in interviews, saving you time when tackling brand-new problems.

Both courses incorporate real-world coding exercises and systematic explanations, helping you excel in both academic and industrial settings. With these under your belt, you’ll not only grasp function pointers better but also see how they fit into broader problem-solving scenarios.

Key Takeaway: Function pointers in C let you store and invoke functions at runtime. They’re declared by specifying the function’s return type, parameters, and a pointer name wrapped in parentheses (e.g., int (*funcPtr)(int, int);). When used wisely, they enable flexible callbacks, plugin-like modules, and a degree of polymorphism in plain C.

CONTRIBUTOR
TechGrind