Understanding typedef Function Pointers in C

By the end of this page, you will understand how function pointers work in C, why typedef is often used to simplify them, and how a declaration like typedef void (*FunctionFunc)(); creates a reusable type for pointing to functions. You will also see how this is useful when working with dynamically loaded DLL functions.

In C, a function pointer is a variable that can store the address of a function. This lets your program call a function indirectly.

That is especially useful when:

• passing functions to other functions
• selecting behavior at runtime
• working with callbacks
• loading functions from shared libraries or DLLs

The line:

typedef void (*FunctionFunc)();

means:

• FunctionFunc is a type name
• that type is a pointer to a function
• the function returns void
• the function takes an unspecified argument list in old-style C syntax

A clearer modern version is often:

typedef void (*FunctionFunc)(void);

This means: FunctionFunc is a type for "pointer to a function taking no arguments and returning nothing."

Why typedef is used

Without typedef, function pointer declarations are hard to read. gives that complicated type a simple name.

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

• The actual function lives somewhere in memory.
• The function pointer does not contain the function itself.
• It contains the location of that function.
• When you use the pointer, you are saying: "go to that location and run that function."

Now think of typedef as a label maker.

Instead of repeatedly writing a complicated type like:

void (*)(void)

you give it a simple label:

FunctionFunc

So typedef does not create a function or a pointer variable by itself. It just creates a simpler name for a type.

Basic syntax

A normal function declaration:

void greet(void);

A function pointer variable that can point to that kind of function:

void (*funcPtr)(void);

A typedef for that function pointer type:

typedef void (*FunctionFunc)(void);

A variable using that typedef:

FunctionFunc funcPtr;

Example 1: Assign and call a function pointer

#include <stdio.h>

void greet(void) {
    printf("Hello from greet()\n");
}

int main(void) {
    typedef void ;

    FunctionFunc func = greet;
    func();

     ;
}

Consider this example:

#include <stdio.h>

typedef void (*FunctionFunc)(void);

void showMessage(void) {
    printf("Message shown\n");
}

int main(void) {
    FunctionFunc func = showMessage;
    func();
    return 0;
}

Step-by-step

1. Define a function pointer type

typedef void (*FunctionFunc)(void);

This creates a new type name, FunctionFunc.

That type means: pointer to a function that:

• takes no arguments
• returns void

2. Define a real function

void  {
    ();
}

Function pointers are common in real C programs.

1. Dynamically loaded libraries and DLLs

When you load a DLL at runtime, you often get a raw function address from the system API. You cast or assign that address to a function pointer type and then call it.

Example use case:

• load a plugin
• find a function like initialize
• store it in a function pointer
• call it

2. Callbacks

Many C libraries ask you to provide a function they can call later.

Examples:

• sorting functions
• event handlers
• signal handlers
• GUI callbacks

3. Strategy selection

A program may choose one of several functions depending on configuration or user input.

For example:

• choose a compression algorithm
• choose a parser
• choose a logging function

4. Embedded systems

Function pointers are often used to connect hardware behavior to different handlers.

Examples:

• interrupt handlers
• device drivers
• command dispatch tables

5. State machines and command tables

Programs can store function pointers in arrays or structs to map commands to actions.

Example:

• command start points to startHandler

In real codebases, developers often use function pointer typedefs to make APIs easier to read and maintain.

Common patterns

1. Clear reusable type aliases

Instead of repeating complex declarations, teams define a named type once.

typedef void (*LogHandler)(const char *message);

This improves readability in structs and function parameters.

2. Validation after dynamic lookup

When loading a function from a DLL, developers usually check that the lookup succeeded before calling it.

if (func == NULL) {
    return -1;
}

This is a guard clause that prevents crashes.

3. Storing callbacks in structs

typedef void (*OnEvent)(int code);

typedef struct {
    OnEvent onStart;
    OnEvent onStop;
} Handlers;

This keeps related behavior together.

4. Dispatch tables

1. Forgetting the parentheses around *name

Broken code:

void *func(void);

This is not a pointer to a function returning void. It is a function returning void *.

Correct code:

void (*func)(void);

2. Using () when you really mean no arguments

This declaration:

typedef void (*FunctionFunc)();

uses old-style syntax meaning the parameters are not specified.

For beginners, this is safer and clearer:

typedef void (*FunctionFunc)(void);

That explicitly means no arguments.

3. Assigning a function with the wrong signature

Function pointer declaration vs typedef alias

() vs (void) in C

Quick reference

Function pointer syntax

return_type (*pointer_name)(parameter_types);

Example:

int (*op)(int, int);

Typedef for function pointer

typedef return_type (*TypeName)(parameter_types);

Example:

typedef void (*FunctionFunc)(void);

Declare a variable using the typedef

FunctionFunc func;

Assign a function

func = showMessage;

or

func = &showMessage;

Call through the pointer

func();

Why does C function pointer syntax look so strange?

C declarations are designed to resemble usage. Parentheses are needed to show that the name is a pointer to a function, not a function returning a pointer.

Does typedef void (*FunctionFunc)(); create a function?

No. It creates a type alias named FunctionFunc.

Is FunctionFunc a variable name?

No. After typedef, the name becomes a type name. You would create variables later using that type.

What is the difference between () and (void) in C?

() means the parameter list is not specified. (void) explicitly means no arguments. (void) is usually the better choice.

Can a function pointer hold any function?

No. It should only point to functions with a compatible signature.

Why are function pointers useful for DLLs?

When a DLL function is found at runtime, you receive its address. A function pointer lets you store that address and call the function.

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

Usually no. In most cases, functionName works because the function name converts to a pointer automatically.

• Pointers — Function pointers build on the general idea of storing memory addresses.
• Functions in C — You need to understand normal function declarations before function pointers make sense.
• typedef — This keyword creates aliases for complex types, including function pointer types.
• Callbacks — Function pointers are the main way callbacks are implemented in C.
• Dynamic library loading — DLL and shared library APIs often return function addresses that must be stored in function pointers.
• Structs — Function pointers are often stored inside structs to group behaviors together.
• NULL checking — Dynamically loaded function pointers should be validated before calling.
• Calling conventions — Important when using DLL functions because the pointer type must match the real function exactly.