Function Pointers in C: Syntax, Callbacks, and qsort

Compiled code lives in memory just like data does, so a function has an address. A function pointer is a variable that stores one - and once you can store a function, you can pass one as an argument, keep a table of them, or choose between them at runtime.

That is the capability behind sorting with a custom order, event handlers, plugin interfaces, and state machines. It is also the piece of C syntax most likely to make a reader stop and squint, so we start there.

The Declaration Syntax

Take an ordinary function:

int add(int a, int b);

To declare a pointer that can hold its address, replace the name with (*name):

int (*op)(int, int);

Read it from the inside: op is a pointer, to a function, taking (int, int), returning int.

The parentheses are not decoration. Without them, * binds to the return type instead:

int (*f)(int);   // pointer to a function taking int, returning int
int *g(int);     // FUNCTION taking int, returning int* - completely different

Here it is working end to end:

#include <stdio.h>

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

int main(void) {
    int (*op)(int, int);        // declare

    op = add;                   // assign (no & needed)
    printf("add:      %d\n", op(10, 3));

    op = subtract;              // point it somewhere else
    printf("subtract: %d\n", op(10, 3));

    op = &multiply;             // the & is allowed but redundant
    printf("multiply: %d\n", (*op)(10, 3));   // so is this call form

    printf("\nthe function itself lives at %p\n", (void *)(void (*)(void))add);
    return 0;
}

Both call forms work because a function designator converts to a pointer automatically. Write op(10, 3); the (*op)(10, 3) spelling is a holdover.

One note on that last printf: %p expects an object pointer, and function pointers are formally a separate family, so printing one is not strictly portable. The cast keeps compilers quiet on the platforms where it works at all; you will rarely need to print one.

typedef Makes It Readable

The declaration syntax gets ugly fast, and typedef is the standard remedy:

#include <stdio.h>

typedef int (*BinaryOp)(int, int);   // BinaryOp = pointer to int(int,int)

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

// now a function taking a function reads like any other declaration
int apply(BinaryOp op, int x, int y) {
    return op(x, y);
}

int main(void) {
    BinaryOp op = add;
    printf("apply(add, 4, 5)      = %d\n", apply(op, 4, 5));
    printf("apply(multiply, 4, 5) = %d\n", apply(multiply, 4, 5));
    return 0;
}

Compare int apply(BinaryOp op, int x, int y) with the raw form, int apply(int (*op)(int, int), int x, int y). Same meaning; one of them you can read at a glance. See typedef for the general rules.

Callbacks: Letting the Caller Supply Behavior

A callback is a function you hand to another function so that it can call you back at the right moment. It lets one piece of code handle the structure of a job while the caller supplies the decision.

#include <stdio.h>

typedef int (*Predicate)(int);

int is_even(int n)     { return n % 2 == 0; }
int is_positive(int n) { return n > 0; }
int is_big(int n)      { return n > 100; }

// one function, any test
int count_if(const int *arr, int n, Predicate test) {
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (test(arr[i])) {
            count++;
        }
    }
    return count;
}

int main(void) {
    int data[8] = {-4, 3, 120, 7, -9, 200, 0, 15};
    int n = 8;

    printf("even:     %d\n", count_if(data, n, is_even));
    printf("positive: %d\n", count_if(data, n, is_positive));
    printf("big:      %d\n", count_if(data, n, is_big));

    return 0;
}

Without function pointers you would write count_even, count_positive, and count_big - three copies of the same loop. With them, the loop is written once and the test is the parameter.

The Real Payoff: qsort

The standard library's qsort is the function-pointer example you will actually use. It sorts an array of anything, and it manages that by knowing nothing about the elements except their size and a comparator you provide.

void qsort(void *base, size_t nmemb, size_t size,
           int (*compar)(const void *, const void *));

The comparator receives two const void * - addresses of two elements - and returns a negative number if the first sorts before the second, zero if they tie, positive if it sorts after.

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

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;      // cast back to the real type, then read
    int y = *(const int *)b;
    if (x < y) return -1;
    if (x > y) return  1;
    return 0;
}

int compare_desc(const void *a, const void *b) {
    return compare_ints(b, a);    // swap the arguments to reverse the order
}

int main(void) {
    int data[8] = {42, 7, 19, 3, 88, 1, 55, 23};
    int n = sizeof data / sizeof data[0];

    qsort(data, n, sizeof data[0], compare_ints);
    printf("ascending:  ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);

    qsort(data, n, sizeof data[0], compare_desc);
    printf("\ndescending: ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);
    printf("\n");

    return 0;
}

Two habits to carry from that comparator. Never write return x - y; - it looks clever and overflows for large or negative values, producing a wrong sign and a mis-sorted array. Cast before dereferencing, not after: *(const int *)a, because *a on a void * has nothing to read.

The same machinery sorts structs by any field you like:

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

typedef struct {
    char name[20];
    int  score;
} Player;

int by_score(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return (q->score > p->score) - (q->score < p->score);   // highest first
}

int by_name(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return strcmp(p->name, q->name);
}

int main(void) {
    Player players[4] = {
        {"Ada",   91},
        {"Grace", 78},
        {"Linus", 91},
        {"Ken",   85}
    };
    int n = 4;

    qsort(players, n, sizeof players[0], by_score);
    printf("by score:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    qsort(players, n, sizeof players[0], by_name);
    printf("by name:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    return 0;
}

The (q->score > p->score) - (q->score < p->score) idiom returns exactly -1, 0, or 1 with no subtraction and no overflow. And strcmp already has the right return convention, so a string comparator is a one-liner.

Tables of Function Pointers

An array of function pointers turns a chain of if/else into a lookup. This is how interpreters dispatch opcodes and how menu systems run commands.

#include <stdio.h>

typedef double (*Operation)(double, double);

double op_add(double a, double b) { return a + b; }
double op_sub(double a, double b) { return a - b; }
double op_mul(double a, double b) { return a * b; }
double op_div(double a, double b) { return b == 0 ? 0.0 : a / b; }

typedef struct {
    char      symbol;
    Operation fn;
    const char *name;
} Entry;

int main(void) {
    Entry table[] = {
        {'+', op_add, "add"},
        {'-', op_sub, "subtract"},
        {'*', op_mul, "multiply"},
        {'/', op_div, "divide"}
    };
    int n = sizeof table / sizeof table[0];

    double x = 12.0, y = 4.0;

    for (int i = 0; i < n; i++) {
        printf("%.1f %c %.1f = %.2f   (%s)\n",
               x, table[i].symbol, y, table[i].fn(x, y), table[i].name);
    }

    // dispatch on a character, without a switch
    char wanted = '*';
    for (int i = 0; i < n; i++) {
        if (table[i].symbol == wanted) {
            printf("\ndispatched '%c' -> %.2f\n", wanted, table[i].fn(x, y));
            break;
        }
    }

    return 0;
}

Adding an operation is now adding a row, not editing a switch. Pair that with structs and you have the standard C plugin shape: a struct of function pointers is what "an interface" means in this language.

Things That Bite

Signatures must match exactly. A function pointer's type includes its parameter types and return type. Assigning a mismatched function is a constraint violation, and calling through a wrongly-typed pointer is undefined behavior even when it "works". Do not cast a comparator's signature to silence a warning - fix the comparator.

A null function pointer is still a null pointer. Initialize to NULL and check before calling, exactly as with data pointers:

if (handler != NULL) {
    handler(event);
}

See null pointers for why that check earns its keep.

Void pointers lose type safety, and you are the type system. Inside a qsort comparator, nothing stops you casting to the wrong type. If you sort an array of double with compare_ints, it compiles cleanly and produces nonsense.

The declarator syntax nests. A function returning a function pointer is int (*get_op(char c))(int, int);. When you find yourself writing that, reach for typedef:

typedef int (*BinaryOp)(int, int);
BinaryOp get_op(char c);           // the same thing, readable