2026-07-157 min read

Function Pointers

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

Why This Matters

Function pointers are an essential part of C programming that allow you to manipulate functions as data. By understanding this concept, you'll be well-prepared for advanced topics like dynamic memory allocation and library functions. In this lesson, we'll delve into function pointers, explore their usage, and discuss common mistakes when working with them.

Prerequisites

Before diving into function pointers, it's important to have a solid grasp of the following concepts:

Basic C syntax and control structures (if-else, loops)
Pointers and arrays
Understanding of function declarations and calls
Comprehension of data types and their usage in C
Familiarity with the concept of call by reference and call by value

Core Concept

Function pointers are variables that store the memory address of a function. They allow you to pass functions as arguments to other functions or return them from functions. This flexibility enables you to create more dynamic and modular code.

Here's the syntax for defining a function pointer:

return_type (*function_name)(parameter_list);

For example, consider the following code snippet:

void printNum(int num) {
printf("%d\n", num);
}

void (*pf)(int) = &printNum; // Function pointer to a function that takes an integer and returns void
(*pf)(5); // Call the function through the pointer

In this example, we define a function printNum that takes an integer as input and prints it. We then create a function pointer pf that points to this function. Finally, we call the function using the pointer.

Function Pointers with Multiple Parameters

Function pointers can also have multiple parameters. To achieve this, simply list all the parameters in the function pointer definition:

void (*pf)(int a, int b) = &addNumbers; // Function pointer to a function that takes two integers and returns void
(*pf)(3, 4); // Call the function through the pointer

In this example, we create a function pointer pf pointing to a hypothetical function addNumbers that takes two integers as input.

Function Pointers with Variable Number of Parameters (Variadic Functions)

To create a function pointer for a variadic function, use the va_list and stdarg.h libraries. The function pointer's parameter list should include ellipsis (...) to represent the variable number of arguments:

void (*pf)(int, ...); // Function pointer to a variadic function that takes an integer and any number of additional arguments

Function Pointers as Return Types

Functions can also return function pointers. This is useful when you want to create factories or callbacks within your code:

void (*createPrinter(int num))(void) {
void printNum(void) {
printf("%d\n", num);
}
return &printNum;
}

void (*pf)(void) = createPrinter(5); // Create a function pointer to a printer function that prints the number 5
(*pf)(); // Call the created function

In this example, we define a function createPrinter that creates and returns a function pointer to a new function. The new function takes no arguments and prints the number passed to createPrinter.

Worked Example

Let's explore a practical example where we sort an array using a custom comparison function:

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

// Comparison function prototype
int compare(const void*, const void*);

void bubbleSort(void* arr, int size, size_t sizeOfElement, int (*compare)(const void*, const void*)) {
for (int i = 0; i < size - 1; ++i) {
for (int j = 0; j < size - i - 1; ++j) {
if ((*compare)((char*)arr + i * sizeOfElement, (char*)arr + (j + 1) * sizeOfElement) > 0) {
void* temp = ((char*)arr + j * sizeOfElement);
memcpy((char*)arr + j * sizeOfElement, (char*)arr + (j + 1) * sizeOfElement, sizeOfElement);
memcpy((char*)arr + (j + 1) * sizeOfElement, temp, sizeOfElement);
}
}
}
}

// Comparison function implementation
int compare(const void* left, const void* right) {
return (*(int*)left - *(int*)right); // Swap larger numbers to the end
}

int main() {
int arr[] = {10, 5, 20, 3, 15};
int size = sizeof(arr) / sizeof(arr[0]);

bubbleSort(&arr, size, sizeof(arr[0]), &compare);

for (int i = 0; i < size; ++i) {
printf("%d ", arr[i]);
}
printf("\n");

return 0;
}

In this example, we define a bubbleSort function that takes an array, its size, the size of each element in the array, and a comparison function as arguments. The comparison function is a function pointer pointing to the compare function implementation. We then call the bubbleSort function with our custom comparison function to sort the array in descending order.

Common Mistakes

Forgetting to dereference the function pointer when calling the function:

void (*pf)(int) = &printNum; // Correct
(*pf)(5); // Correct

pf(5); // Incorrect, forgetting the asterisk

Not matching the function pointer's parameter list with the actual function's parameter list:

void (*pf)(int) = &printNum; // Function pointer to a function that takes an integer and returns void
(*pf)(5.0); // Incorrect, passing a float instead of an integer

Failing to return the correct data type from the comparison function:

int compare(const void* left, const void* right) {
return *(int*)left - *(int*)right; // Correct
}

// Incorrect implementation with an int instead of void*
int compare(int left, int right) {
return left - right;
}

Not properly handling the variable number of arguments in a function pointer:

void (*pf)(int, ...); // Function pointer to a variadic function that takes an integer and any number of additional arguments
(*pf)(5, 3.14); // Incorrect, passing a float instead of another integer

Common Mistakes (Continued)

Not properly freeing memory allocated with malloc when using function pointers:

void (*pf)(char*) = &free; // Function pointer to the free function
char* arr = malloc(10);
(*pf)(arr); // Correct, free memory after allocation

// Incorrect implementation without dereferencing the function pointer
pf(arr);

Failing to consider the order of function arguments when using function pointers:

void (*pf)(int, char*); // Function pointer to a function that takes an integer and a string as arguments
(*pf)(5, "Hello"); // Correct, passing arguments in the correct order

// Incorrect implementation with reversed arguments
(*pf)("Hello", 5);

Practice Questions

Write a function swapNumbers that takes two integer pointers as arguments and swaps their values using a function pointer:

void swapNumbers(int* num1, int* num2, void (*pf)(int*, int*)) {
(*pf)(num1, num2); // Call the function pointer to swap the numbers
}

Modify the bubbleSort example to sort an array of strings using a custom comparison function:

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

// Comparison function prototype
int compare(const void*, const void*);

void bubbleSort(void* arr, int size, size_t sizeOfElement, int (*compare)(const void*, const void*)) {
for (int i = 0; i < size - 1; ++i) {
for (int j = 0; j < size - i - 1; ++j) {
if ((*compare)((char*)arr + i * sizeOfElement, (char*)arr + (j + 1) * sizeOfElement) > 0) {
void* temp = ((char*)arr + j * sizeOfElement);
memcpy((char*)arr + j * sizeOfElement, (char*)arr + (j + 1) * sizeOfElement, sizeOfElement);
memcpy((char*)arr + (j + 1) * sizeOfElement, temp, sizeOfElement);
}
}
}
}

// Comparison function implementation
int compare(const void* left, const void* right) {
return strcmp((char*)left, (char*)right); // Compare strings lexicographically
}

int main() {
char arr[][10] = {"apple", "banana", "kiwi", "mango"};
int size = sizeof(arr) / sizeof(arr[0]);

bubbleSort(&arr, size, sizeof(arr[0]), &compare);

for (int i = 0; i < size; ++i) {
printf("%s\n", arr[i]);
}
return 0;
}

Create a function createAdditionFunction that takes two integers as arguments and returns a function pointer to a new function that performs addition with those numbers:

void (*createAdditionFunction(int num1, int num2))(int) {
void addNumbers(int num) {
printf("%d\n", num + num1 + num2);
}
return &addNumbers;
}

int main() {
void (*pf)(int) = createAdditionFunction(3, 4); // Create a function pointer to an addition function with numbers 3 and 4
(*pf)(5); // Call the created function with argument 5
return 0;
}

FAQ

Why use function pointers? Function pointers provide flexibility by allowing you to pass functions as arguments or return them from other functions. This enables dynamic and modular code.
How do I create a function pointer for a variadic function? To create a function pointer for a variadic function, use the va_list and stdarg.h libraries. The function pointer's parameter list should include ellipsis (...) to represent the variable number of arguments.
What are common mistakes when working with function pointers? Common mistakes include forgetting to dereference the function pointer, not matching the function pointer's parameter list with the actual function's parameter list, failing to return the correct data type from the comparison function, and not properly handling the variable number of arguments in a function pointer.
How can I pass a function as an argument to another function? To pass a function as an argument to another function, define the function pointer with the appropriate parameter list and assign it the address of the function you want to pass. Then, pass this function pointer as an argument to the other function.
How can I return a function from another function using a function pointer? To return a function from another function using a function pointer, create a new function within the returning function and assign its address to the function pointer. Finally, return the function pointer.