Understanding Function Pointer In C, With Examples

Are you tired of rewriting commands every time you need to use a particular function? With a function pointer in C, you can do away with excessive “if-else” or “switch” statements and just point to the tool you want to use.

But how do you implement such a useful program? It’s a lot easier than you might expect. In this article, we explain what a function pointer in C does, how it works, and how you might use it. We even include the syntax to make your life that much easier. So what are you waiting for? Let’s get started with this incredibly useful tool.

What Is a Function Pointer in C and How Does It Work?

In the C programming language, you can use function pointers to call back to an existing function. This allows you to access a variety of functions as though they were data, keeping you from having to write them out.

Function pointers in C work by storing the address of a function. The mechanics of this process are fairly simple:

1. Declare a function pointer variable
2. Assign a function address to the variable
3. Use the variable to call the function

Let’s show you what this looks like with a simple example.

Say you want to call an “add” function. Before you can do this, you’ll need to set up a function pointer variable. Here’s what that might look like in C:

int (*funcPtr)(int, int);  // Declaration of a function pointer variable

Now that your variable is set up, you can assign your “add” function to it. Here’s how you might do that:

funcPtr = add;  // Assigning the address of the 'add' function to the function pointer

With your “add” function assigned to your function pointer, you’re ready to call it when you need. For example, if you wanted to find the sum of 3 and 4, you might call your “add” function like this:

int result = funcPtr(3, 4);  // Calling the function using the function pointer

You can see how simple it is to use a function pointer in C to utilize a whole list of functions on command. While the above example seems rudimentary, we can begin to see how the program becomes useful.

What are the Applications of a Function Pointer in C?

Using function pointers in C to call “add” functions might seem simple, but you can apply them to access major tools. Some of the more common uses for this tool include implementing callbacks, function tables, and dynamic function dispatch. Let’s take a look at some examples of these applications in practice.

Implementing Callbacks

In the following example, we have a program that performs an operation on a particular value. However, the action that’s taken after the operation differs depending on the value. To make sure these actions occur as intended, we use function pointers. Here’s what that might look like:

#include 

// Callback function type
typedef void (*Callback)(int);

// Function that takes a callback function as an argument
void performOperation(int value, Callback callback) {
    // Perform some operation
    printf("Performing operation with value: %d\n", value);

    // Call the callback function
    callback(value);
}

// Callback function implementations
void callbackA(int value) {
    printf("Callback A executed with value: %d\n", value);
}

void callbackB(int value) {
    printf("Callback B executed with value: %d\n", value);
}

int main() {
    // Call the performOperation function with different callbacks
    performOperation(5, callbackA);
    performOperation(8, callbackB);

    return 0;
}

Creating a Function Table

We can also use a function pointer in C to create function tables, preparing each function for use depending on particular conditions or user input. For example, let’s say we want to create a table with three different functions. Here’s how you would write it:

#include 

// Function pointer type for the functions in the table
typedef void (*FunctionPtr)();

// Function table structure
typedef struct {
    int id;
    FunctionPtr function;
} FunctionTableEntry;

// Function implementations
void functionA() {
    printf("Function A called\n");
}

void functionB() {
    printf("Function B called\n");
}

void functionC() {
    printf("Function C called\n");
}

int main() {
    // Define the function table
    FunctionTableEntry table[] = {
        {1, functionA},
        {2, functionB},
        {3, functionC}
    };

    // Iterate over the function table and call each function
    int tableSize = sizeof(table) / sizeof(table[0]);
    for (int i = 0; i < tableSize; i++) {
        printf("Calling function with ID: %d\n", table[i].id);
        table[i].function();  // Call the function using the function pointer
    }

    return 0;
}

Dynamic Function Dispatch

To handle various cases or options more efficiently, you might enable a dynamic dispatch. This makes it easy to use different functions without needing a series of “if-else” or “switch” statements. Here’s a basic example for creating a dynamic dispatch using three simple functions (“add,” ”subtract,” and ”multiply”):

#include 

// Function pointer type
typedef void (*Operation)(int, int);

// Addition function
void add(int a, int b) {
    printf("Addition: %d\n", a + b);
}

// Subtraction function
void subtract(int a, int b) {
    printf("Subtraction: %d\n", a - b);
}

// Multiplication function
void multiply(int a, int b) {
    printf("Multiplication: %d\n", a * b);
}

int main() {
    // Function pointer variable
    Operation operation;

    int choice;
    int num1, num2;

    printf("Enter operation (1: add, 2: subtract, 3: multiply): ");
    scanf("%d", &choice);

    printf("Enter two numbers: ");
    scanf("%d %d", &num1, &num2);

    // Dynamic function dispatch based on user choice
    switch (choice) {
        case 1:
            operation = add;
            break;
        case 2:
            operation = subtract;
            break;
        case 3:
            operation = multiply;
            break;
        default:
            printf("Invalid choice!\n");
            return 1;
    }

    // Call the selected operation using the function pointer
    operation(num1, num2);

    return 0;
}