How Function Pointers Work in C: Syntax, Examples, and Practical Use

By the end of this page, you will understand what a function pointer is in C, how to declare and use one, how to pass it to other functions, and where it appears in real programs such as callbacks, sorting functions, and menu dispatch systems.

A function pointer is a variable that stores the address of a function.

In C, functions live at memory addresses just like data does. Normally, you call a function directly by its name:

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

int result = add(2, 3);

But you can also store the function's address in a pointer and call it indirectly:

int (*operation)(int, int) = add;
int result = operation(2, 3);

This matters because it lets your code become more flexible. Instead of hardcoding one behavior, you can choose a function at runtime.

Common reasons function pointers matter:

• Callbacks: one function lets another function decide what action to perform
• Custom behavior: pass different logic into reusable code
• Dispatch tables: map commands or options to functions
• Library APIs: many C libraries expect callback functions

The important rule is this:

• A function pointer must match the function's return type and parameter types

For example, if a function returns int and takes two int arguments, the pointer must be declared to match that exact signature:

int (*ptr)(int, int);

Function pointers are powerful, but the syntax looks unusual at first because C must distinguish between:

• a function declaration
• a pointer declaration
• a pointer to a function declaration

Once you learn to read the declaration from the variable name outward, the syntax becomes much easier.

Think of a function pointer as a remote control button.

• The function is the device that performs the action
• The function name is like knowing the device directly
• The function pointer is a programmable button that can be set to trigger different devices

For example, suppose you have these functions:

• add
• subtract
• multiply

A function pointer lets you say:

• "Right now, this button means add"
• "Later, change it so the same button means multiply"

Your code can call the same pointer variable, but the actual function that runs can change.

That is the core idea: the call site stays the same, but the behavior can be swapped.

Basic syntax

Here is a normal function:

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

A pointer to a function with the same signature looks like this:

int (*ptr)(int, int);

Read it as:

• ptr is a pointer
• *ptr is grouped with parentheses
• it points to a function
• that takes (int, int)
• and returns int

Assigning a function to a pointer

int (*ptr)(int, int) = add;

You can also write:

int (*ptr)(int, int) = &add;

Both work in C for this use.

Calling through a function pointer

Consider this example:

#include <stdio.h>

int square(int x) {
    return x * x;
}

int main(void) {
    int (*func)(int) = square;
    int result = func(6);
    printf("%d\n", result);
    return 0;
}

Step by step:

1. The program defines square, a function that takes one int and returns one int.
2. In main, func is declared as a pointer to a function with signature int (int).
3. func = square; stores the address of square in func.
4. func(6) calls the function that func points to.

Function pointers appear in many practical C programs.

1. Callbacks in libraries

A library may let you provide your own function to handle events or data.

Examples:

• comparison functions for sorting
• signal handlers
• iteration callbacks
• GUI or embedded event handlers

2. Sorting with custom logic

The C standard library function qsort uses a function pointer so you can decide how elements should be compared.

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

3. Menu systems

A command-line tool can map user choices to functions.

void show_help(void);
void run_backup(void);
void exit_program();

In real codebases, developers usually use function pointers in structured ways rather than declaring them casually everywhere.

Common patterns

Callbacks

A function receives another function to customize behavior.

void process_items(int *items, int count, void (*handler)(int)) {
    for (int i = 0; i < count; i++) {
        handler(items[i]);
    }
}

This keeps process_items reusable.

Dispatch tables

Instead of a long chain of if or switch, developers sometimes store functions in an array.

#include <stdio.h>

void say_hello(void) { printf("Hello\n"); }
void say_bye(void)   { printf("Bye\n"); }

int  {
     (*actions[])() = { say_hello, say_bye };
    actions[]();
    actions[]();
     ;
}

1. Forgetting parentheses in the declaration

This is one of the most common mistakes.

Broken code:

int *ptr(int, int);

This does not mean “pointer to function”. It means:

• ptr is a function
• it takes two int values
• it returns int *

Correct code:

int (*ptr)(int, int);

The parentheses around *ptr are required.

2. Using the wrong function signature

Broken code:

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

void (*ptr)(int, int) = add;

Problem:

• returns

Function pointer vs normal function call

Function pointer declaration vs function declaration

Core syntax

Declare a function:

int add(int a, int b);

Declare a pointer to that kind of function:

int (*ptr)(int, int);

Assign a function:

ptr = add;

Call through the pointer:

ptr(2, 3);
(*ptr)(2, 3);

Reading the declaration

int (*ptr)(int, int);

• ptr = variable name
• *ptr = pointer
• (int, int) = points to a function taking two int
• int at the start = function returns

What is a function pointer in C?

A function pointer is a variable that stores the address of a function, allowing you to call that function indirectly.

Why are function pointers used in C?

They are used for callbacks, custom behavior, dispatch tables, event handling, and standard library functions such as qsort.

How do I declare a function pointer in C?

Match the function's return type and parameters:

int (*ptr)(int, int);

Do I need to use & when assigning a function to a function pointer?

Usually no. ptr = add; works. ptr = &add; also works in common C usage.

How do I call a function through a pointer?

You can write either:

ptr(1, 2);

or:

(*ptr)(1, 2);

What happens if the function signature does not match?

That is incorrect and may produce compiler warnings or undefined behavior. The pointer type must match the function type.

Are function pointers the same as normal pointers?

• Pointers in C — function pointers build directly on normal pointer concepts.
• Callbacks — function pointers are the mechanism C uses for callback-style programming.
• typedef in C — useful for simplifying complex function pointer declarations.
• Arrays of function pointers — common for dispatch tables and menu systems.
• qsort comparator functions — a practical standard-library example of function pointer use.
• Operator precedence in C — important for understanding declarations like (*ptr)().
• Declarations vs definitions in C — helps when reading function and pointer syntax.
• NULL checking — important when a callback may or may not be set.