What Are Function Pointers and How Do I Use Them?

After this lesson, you will be able to:

• Declare function pointer variables with correct syntax
• Use typedef to create named type aliases for function pointer signatures
• Write a sort function that accepts a comparator function pointer
• Write qsort-compatible comparison functions

The Motivation

Look at your sort-by-name and sort-by-GPA functions. They’re identical except for one line — the comparison. Wouldn’t it be great to write one sort function and tell it how to compare?

That’s what function pointers do. You store a function’s address in a variable and call it later — just like you store a variable’s address in an int *. This enables callbacks, generic algorithms, and the kind of polymorphism that Java achieves with interfaces.

How Function Pointers Work

Functions Have Addresses

Just like variables, functions live at memory addresses. The function’s name (without parentheses) gives you that address:

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

printf("add lives at: %p\n", (void *)add);
printf("sub lives at: %p\n", (void *)sub);

Declaring Function Pointers

int (*op)(int, int);     // op is a pointer to a function taking two ints, returning int

The parentheses around (*op) are critical:

• int (*op)(int, int) — pointer to a function
• int *op(int, int) — function returning int * (completely different!)

Assigning and Calling

int (*op)(int, int) = add;     // Point to add function
printf("%d\n", op(3, 5));      // Calls add(3, 5) → 8

op = sub;                       // Now point to sub
printf("%d\n", op(3, 5));      // Calls sub(3, 5) → -2

Using typedef for Readability

The raw syntax is ugly. typedef helps:

typedef int (*MathOp)(int, int);

MathOp op = add;
printf("%d\n", op(3, 5));    // 8

The Real Payoff: One Sort, Any Comparison

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

void sort_roster(Student roster[], int size, Comparator cmp)
{
    for (int i = 0; i < size - 1; i++)
    {
        int min = i;
        for (int j = i + 1; j < size; j++)
        {
            if (cmp(&roster[j], &roster[min]) < 0)
            {
                min = j;
            }
        }
        if (min != i)
        {
            Student temp = roster[i];
            roster[i] = roster[min];
            roster[min] = temp;
        }
    }
}

Now write comparison functions:

int compare_by_name(const Student *a, const Student *b)
{
    return strcmp(a->name, b->name);
}

int compare_by_gpa(const Student *a, const Student *b)
{
    if (a->gpa < b->gpa) return -1;
    if (a->gpa > b->gpa) return 1;
    return 0;
}

Call with any comparison:

sort_roster(roster, count, compare_by_name);    // Sort alphabetically
sort_roster(roster, count, compare_by_gpa);     // Sort by GPA

Key Insight: The sort function doesn’t know or care what field it’s sorting by. It delegates the comparison to whatever function you pass. This is the same concept as Java’s Comparator interface — except in C, it’s a raw function pointer instead of an object.

qsort: The Standard Library’s Version

C’s standard library includes qsort, which uses function pointers for the same pattern:

#include <stdlib.h>

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

int arr[] = {5, 2, 8, 1, 4};
qsort(arr, 5, sizeof(int), compare_ints);

Common Pitfall: For integer comparisons in qsort, return a - b can overflow if a and b have very different magnitudes. Safer to use explicit if statements: if (a < b) return -1; if (a > b) return 1; return 0;

From Java: Function pointers are C’s equivalent of Java interfaces and lambdas. Where Java uses Comparator<Student> and (a, b) -> a.getName().compareTo(b.getName()), C uses int (*cmp)(const Student *, const Student *) and a named comparison function. Same concept, different syntax.

Big Picture: Function pointers turn functions into data — you can store them, pass them around, and call them later. This is the foundation of callbacks, plugin architectures, and event-driven programming. Every time you pass a comparator to a sort function, register a signal handler, or set up a callback in a GUI framework, you’re using this concept.

What’s Next

Function pointers let you parameterize behavior. But the sort function above only works with Student structs. What if you want one sort function that works with any type? That’s where void pointers come in — C’s mechanism for type erasure and generic programming.