2025-12-088 min read

22.5 Function Pointers

Learn 22.5 Function Pointers step by step with clear examples and exercises.

Why This Matters

Function pointers are an essential feature in C programming that allows you to call functions at runtime. They offer several benefits:

Flexibility: Function pointers enable your code to adapt to different conditions by calling functions based on user input or other runtime situations.
Callback Functions: Many libraries and APIs use callback functions, which are essentially function pointers passed as arguments to other functions. This allows the called function to execute specific tasks when triggered by the main program.
Event-Driven Programming: In event-driven programming, events such as mouse clicks or keyboard input trigger certain actions. Function pointers can be used to associate these events with specific functions, making it possible for your program to respond to user interactions.
Real-world Applications: Function pointers are used extensively in various areas of software development, including operating systems, network programming, and game development.

Prerequisites

Before diving into function pointers, you should have a good understanding of the following topics:

Variables and data types
Pointers and memory management
Functions and their basic usage
Basic C syntax and control structures (if-else, loops, etc.)
Understanding the concept of function prototypes
Familiarity with the void keyword for functions that do not return a value
Knowledge of structure pointers and arrays
Understanding how to use dynamic memory allocation with malloc(), calloc(), free()
Comprehension of recursive function calls
Familiarity with the concept of linked lists

Core Concept

Declaring Function Pointers

To declare a function pointer, you replace the return type of a function declaration with void * or the specific return type of the function you want to point to:

// Declare a function pointer that can hold any function taking no arguments and returning an integer
int (*myFunction)(void);

In this case, myFunction is a variable that can store the address of a function that returns an integer and takes no arguments. You can also declare function pointers for functions with specific argument types by adjusting the parameter list in the declaration:

// Declare a function pointer for a function taking two integers as arguments and returning nothing (void)
void (*myOtherFunction)(int, int);

Assigning Function Pointers

To assign a function to a function pointer, you use the & operator to get the address of the function and then store it in the function pointer variable:

// Define a simple function that returns 42
int mySimpleFunction() {
return 42;
}

// Assign the address of mySimpleFunction to myFunction
myFunction = &mySimpleFunction;

Now, myFunction holds the address of mySimpleFunction, and you can call it like any other function:

printf("%d\n", (*myFunction)()); // Outputs: 42

Calling Function Pointers

To call a function through a function pointer, you use the dereference operator * to access the function stored in the pointer. The parentheses are also important because they tell the compiler to treat the function pointer as a function and not just a variable:

(*myFunction)(); // Calls the function pointed to by myFunction

Function Pointers with Structures and Arrays

You can use function pointers as array elements or structure fields, allowing for dynamic access to functions based on indices or specific data members. For example:

typedef struct {
char name[20];
void (*function)(void);
} FunctionStruct;

FunctionStruct functions[] = {
{"add", &myAddFunction},
{"subtract", &mySubtractFunction},
// ... more functions here
};

In this example, functions is an array of FunctionStruct objects, where each object contains a function name and the address of the corresponding function. You can iterate through this array and call the stored functions dynamically:

for (int i = 0; i < ARRAY_SIZE(functions); ++i) {
printf("%s\n", functions[i].name);
(*(functions[i].function))(); // Call the function pointed to by the current structure's function field
}

Dynamic Memory Allocation with Function Pointers

You can also use dynamic memory allocation to create and manage arrays of function pointers:

// Calculate the required size for an array of function pointers
int funcArraySize = sizeof(void*) * NUM_FUNCTIONS;

// Allocate memory for the function pointer array
void **funcArray = malloc(funcArraySize);
if (funcArray == NULL) {
printf("Error: Memory allocation failed\n");
return 1;
}

// Assign function addresses to the function pointer array
funcArray[0] = &myFunction1;
funcArray[1] = &myFunction2;
// ... assign more functions here

// Iterate through the function pointer array and call each function
for (int i = 0; i < NUM_FUNCTIONS; ++i) {
(*(funcArray[i]))(); // Call the function pointed to by the current element in the array
}

// Free the allocated memory when done
free(funcArray);

Worked Example

Let's create a simple program that uses function pointers to implement a basic calculator with user-defined operations.

#include <stdio.h>

// Declare function pointers for addition, subtraction, multiplication, and division
int (*operations[4])(int, int) = {NULL};

void setupOperations() {
// Assign functions to the operation pointers
operations[0] = &add;
operations[1] = &subtract;
operations[2] = &multiply;
operations[3] = &divide;
}

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 divide(int a, int b) {
if (b == 0) {
printf("Error: Division by zero\n");
return 0;
}
return a / b;
}

// Define additional functions for user-defined operations
int myCustomOperation1(int a, int b) {
// Custom logic for this operation goes here
// ...
return result;
}

int myCustomOperation2(int a, int b) {
// Custom logic for this operation goes here
// ...
return result;
}

int main() {
setupOperations(); // Initialize the operation pointers

int num1, num2;
char operator;

printf("Enter two numbers and an operator (e.g., 5 3 +):\n");
scanf("%d %c %d", &num1, &operator, &num2);

// Check if the entered operator corresponds to a user-defined operation
if (operator >= 'A' && operator <= 'D') {
// User-defined operations have custom names starting with an uppercase letter
int operationIndex = operator - 'A';
// Call the appropriate user-defined function using the function pointer
int result = operations[operationIndex + 4](num1, num2);
printf("Result: %d\n", result);
} else {
// Call the appropriate built-in operation using the function pointer
int result = operations[operator - '+'](num1, num2);
printf("Result: %d\n", result);
}

return 0;
}

This program defines four functions for basic arithmetic operations and sets up a function pointer array to call the appropriate operation based on the user-entered operator. It also includes two user-defined operations, myCustomOperation1 and myCustomOperation2, which can be called using the same function pointer array by checking if the entered operator corresponds to one of these custom functions. When you run this code, it prompts you to enter two numbers and an operator, performs the specified operation using the function pointer, and outputs the result.

Common Mistakes

Forgetting to dereference the function pointer: If you forget to use * when calling a function through a pointer, you'll get a compile error because the compiler doesn't know how to treat the pointer as a function.
Passing incorrect argument types: If you declare a function pointer for a specific set of arguments and then try to call it with different argument types, you'll get a compile error. Make sure that the functions you assign to your function pointers have compatible argument lists.
Not initializing function pointers: If you don't initialize function pointers before using them, they will contain random values, which can lead to undefined behavior and errors when called. Always ensure that your function pointers are properly initialized before use.
Mixing up void * and specific return types: It's important to remember that function pointer declarations should match the actual functions you want to point to. If you declare a function pointer with void * but assign it an address of a function with a different return type, you may encounter problems when trying to call the function through the pointer.
Using incorrect types for structure fields: Make sure that the types of structure fields match the expected function pointer types. For example, if you declare a structure field as int (*func)(void), it should be assigned an address of a function with no arguments and returning an integer.
Memory leaks: Be aware of memory leaks when using dynamic memory allocation with function pointers. Always remember to free the allocated memory when it's no longer needed.
Recursive function calls with function pointers: When using recursive functions with function pointers, ensure that the base case is properly handled and avoid infinite loops.

Practice Questions

Write a program that uses function pointers to implement a simple sorting algorithm (e.g., bubble sort, quicksort, or merge sort). The user should be able to choose the sorting algorithm at runtime.
Create a function pointer for a function that takes two floating-point numbers as arguments and returns their average. Write a program that uses this function pointer to calculate the average of three sets of two numbers entered by the user.
Implement a simple text editor using function pointers for event handling (e.g., keyboard input, mouse clicks). The user should be able to define custom functions for specific events and call them dynamically based on the event that occurred.

FAQ

What is the purpose of function pointers in C?

Function pointers allow you to call functions at runtime, providing flexibility and enabling the use of callback functions in libraries and APIs.

How do I declare a function pointer in C?

To declare a function pointer, replace the return type of a function declaration with void * or the specific return type of the function you want to point to. For example:

int (*myFunction)(void); // Declare a function pointer that can hold any function taking no arguments and returning an integer

How do I assign a function to a function pointer in C?

To assign a function to a function pointer, you use the & operator to get the address of the function and then store it in the function pointer variable:

int mySimpleFunction() {
return 42;
}

// Assign the address of mySimpleFunction to myFunction
myFunction = &mySimpleFunction;

How do I call a function through a function pointer in C?

(*myFunction)(); // Calls the function pointed to by myFunction

Can I use function pointers with structures or arrays in C?

Yes, you can use function pointers as array elements or structure fields, allowing for dynamic access to functions based on indices or specific data members. For example:

typedef struct {
char name[20];
void (*function)(void);
} FunctionStruct;

FunctionStruct functions[] = {
{"add", &myAddFunction},
{"subtract", &mySubtractFunction},
// ... more functions here
};