How to Pass a Function as a Parameter in C

By the end of this page, you will understand how C passes functions indirectly using function pointers. You will learn the syntax, how to declare and use function-pointer parameters, how calls work step by step, and where this pattern appears in real programs such as callbacks, sorting, and data processing.

In C, you do not pass a function directly in the same way you pass an int or a double. Instead, you pass a pointer to the function.

A function pointer stores the address of a function. If another function receives that address, it can call the pointed-to function later.

This matters because it lets you write generic and reusable code. Instead of hardcoding one behavior, you can let the caller decide what operation should happen.

For example, imagine you have a list of numbers and want to:

• print each number
• square each number
• check whether each number is even

Rather than writing three separate loops, you can write one reusable function that loops through the data and calls a passed-in function for each item.

In C, this pattern is common in:

• callback-based APIs
• sorting with qsort
• signal handlers
• event systems
• data transformation utilities

The key idea is:

• function name often acts like a pointer to that function
• function pointer type must match the function signature
• signature means return type + parameter types

If the signatures do not match, the behavior is incorrect and may cause warnings or bugs.

Think of a function pointer like a remote control with one programmed button.

• The function itself is the device that performs the action.
• The function pointer is the remote that knows which device to activate.
• Passing the function pointer to another function is like handing someone the remote so they can trigger that action when needed.

Another way to think about it:

• normal data variable: holds a value
• normal pointer: holds the address of data
• function pointer: holds the address of executable code

So instead of saying, "do this exact task," you are saying, "when the time comes, call whatever function lives at this address."

Basic syntax

A function pointer must match the function's signature.

For a function like this:

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

A pointer to that function can be declared as:

int (*func_ptr)(int);

This means:

• returns int
• points to a function
• function takes one int

You can assign the function to the pointer:

func_ptr = square;

And call it in either of these ways:

int result1 = func_ptr(5);
int result2 = (*func_ptr)(5);

Both are valid.

Passing a function as a parameter

#include <stdio.h>

int  {
     x * x;
}

  {
     operation(value);
}

  {
     result = apply(, square);
    (, result);
     ;
}

Consider this example:

#include <stdio.h>

int increment(int x) {
    return x + 1;
}

int apply(int value, int (*fn)(int)) {
    return fn(value);
}

int main(void) {
    int result = apply(10, increment);
    printf("%d\n", result);
    return 0;
}

Step-by-step

1. main starts running.
2. apply(10, increment) is called.
3. The value 10 is passed into apply as value.
4. The function increment is passed into apply as fn.

Function pointers are used whenever code needs to be flexible about what action should happen.

Common real-world uses

1. Sorting with custom rules

The C standard library function qsort accepts a comparison function pointer.

qsort(array, count, sizeof(int), compare_ints);

This lets you define how two items should be compared.

2. Callbacks in libraries

A library may let you register a function to be called later when something happens.

Examples:

• when data arrives
• when a timer expires
• when a button is clicked in a GUI toolkit

3. Processing collections

You can write reusable loops that apply different actions to each item.

• print each item
• validate each item
• transform each item

4. Error handling hooks

A framework may accept a custom error-reporting function.

5. Strategy selection

Different algorithms can be plugged into the same code path by passing different functions.

In real C codebases, function pointers often appear in patterns rather than isolated examples.

Common patterns

Guarding against NULL

A function pointer parameter may be optional. Developers often check it before calling.

void run_if_present(int value, void (*fn)(int)) {
    if (fn == NULL) {
        return;
    }
    fn(value);
}

This avoids crashes from calling a null function pointer.

Callbacks for configurable behavior

Instead of hardcoding behavior, code accepts a callback.

void process_event(void (*handler)(int), int code) {
    if (handler != NULL) {
        handler(code);
    }
}

Separating iteration from action

One function handles looping; another handles what to do with each element.

void for_each(int *arr, int size,  (*action)()) {
     ( i = ; i < size; i++) {
        action(arr[i]);
    }
}

1. Forgetting the parentheses in the declaration

This is one of the most common errors.

Broken code:

int *fn(int);

This does not mean “pointer to a function.” It means a function returning int *.

Correct code:

int (*fn)(int);

The parentheses are important because *fn must be grouped together.

2. Using the wrong function signature

Broken code:

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

void apply(void (*fn)(int)) {
    fn(5);
}

apply(square);

Here, apply expects a function returning void, but square returns int.

Function pointer vs normal pointer

Direct call vs function pointer call

Without vs with

Quick syntax

Declare a function

int square(int x);

Declare a pointer to that function

int (*fn)(int);

Assign a function to the pointer

fn = square;

Call through the pointer

fn(5);
(*fn)(5);

Function as parameter

int apply(int value, int (*op)(int)) {
    return op(value);
}

Using typedef

typedef int (*operation_fn)(int);

int  {
     op(value);
}

How do you pass a function to another function in C?

You pass a function pointer. The receiving function declares a parameter whose type matches the passed function's signature.

What is the syntax for a function pointer in C?

A function pointer to a function returning int and taking one int looks like this:

int (*fn)(int);

Can I call a function pointer like a normal function?

Yes. If fn is a function pointer, you can write:

fn(5);

Do I need to use & when passing a function in C?

Usually no. Writing the function name is enough:

apply(5, square);

Why are parentheses required in function pointer declarations?

Without parentheses, C reads the declaration differently because of operator precedence. int (*fn)(int) means pointer to function, while int *fn(int) means function returning pointer.

Where are function pointers used in C?

They are commonly used in callbacks, , event handling, dispatch tables, and reusable processing functions.

• Pointers — Function pointers build directly on the general idea of storing addresses.
• Callback functions — Passing a function as a parameter is the core callback pattern.
• typedef in C — Useful for making complex function pointer types easier to read.
• qsort comparator functions — A standard real-world example of function pointers in C.
• Arrays and iteration — Function pointers are often used when applying logic across collections.
• NULL checking — Important when a callback may be optional.
• Function declarations and prototypes — You need to understand function signatures to declare matching function pointers correctly.