Pointers to functions

Pointers to functions act as a way to store and work with the memory address of a function within a program. They let a program track where a function resides in memory. This feature isn't just for show; it has many practical uses. For example, it allows functions to be passed to other functions as arguments, returned from functions, and even put in arrays. This makes things a lot easier in cases like callback setups, where you need to call a function after certain events happen, and in event-driven programming, which depends on reacting to different events like user actions or system alerts.

Function composition

What do you know about functions in C++? They have a name (identifier), a return type, and might have one or more parameters. Here's what a simple sum() function looks like:

#include <iostream>

int sum(int one, int two) {
    int result = one + two;
    return result;
}


int main() {
    std::cout << sum(2, 5);
    return 0;
}

sum is the name of the function. It takes two integer parameters and returns an integer. However, the function itself also has a type. What type might that be?

Functions have their unique l-value type. Like variables, functions also have an address in memory. When you use () in the line std::cout << sum(2, 5);, you call the function; that is, you refer to its address in memory. This means the program's execution moves to the function's address. After the function runs, you go back and store the result in a variable s.

Rather than calling the sum() function and printing the return value, you could try std::cout << sum;. Doing this would print the function's address on the screen, as you're sending the output stream a pointer to the function's name.

Since this involves a pointer, you can, if you want, define more pointers to this function. A pointer to a function is just a variable that holds the memory address of a function. You can use it to call the function it points to, much like a regular function call.

Understanding pointers to functions

The general way to declare a pointer to a function looks like this (don't worry, even though it seems tricky, it's not often used):

ReturnType (*PointerName)(ParameterTypes);

Brackets around the pointer are needed to clearly show the order of operations.

To create a pointer to our sum function, you must figure out the type of the function pointer that fits the sum function. The sum function takes two integers as parameters and returns an integer.

#include <iostream>

int sum(int one, int two) {
    int result = one + two;
    return result;
}


int main() {
    // Defining a pointer to a function and initializing it
    int (*sumPtr)(int, int) = sum;

    // Using a function pointer to call a function
    // The call is similar to a standard function
    std::cout << "Result: " << sumPtr(2, 5) << std::endl;

    return 0;
}

Areas of application

1. Function tables or arrays of functions: You can use function pointers to make tables of functions. This allows you to choose algorithms while the program is running.

2. Callbacks: One popular use of function pointers is to pass a function as an argument to another function. These are known as callback functions. This lets the program decide which function to call in response to a specific event or condition, making the code more flexible and modular.

3. Design patterns: For some design patterns, like Strategy, function pointers can be used to change how an object acts during runtime.

4. Function interfaces: You can use function pointers to create standard interfaces, which makes it easier for different parts of a system to interact.

5. Asynchronous programming: In asynchronous programming, function pointers can run code in reaction to events that happen out of sequence or when operations are completed.

6. Dynamic code loading: You can use function pointers for the dynamic loading and calling of functions from shared libraries, like DLLs in Windows or .so files in Linux.

7. Testing and mocking: Function pointers can be handy in testing. You can swap real functions with mock versions to test different aspects of a program's behavior.

Array of function pointers

Consider an example of using an array to store function pointers; you'll learn other uses later. First, see the template algorithm for using an array of function pointers. Here is the standard algorithm:

• Define functions that carry out certain actions;

• Set up an array with pointers to these functions;

• Go through the array and run the functions.

// Let's define the functions that we will store in the array and call later.
void actionOne() { /* ... */ }
void actionTwo() { /* ... */ }

int main() {
    // Define and initialize the array of pointers to functions
    void (*actions[2])() = {actionOne, actionTwo};

    // Run all functions
    for (auto & action : actions) {
        action();
    }
}

Now, let's explore working with arrays of function pointers using a real example. Imagine you're making a console app with various command options. You could use an array of function pointers to handle different commands, instead of a lengthy series of checks (if or switch statements).

Step 1: Defining command functions.

Start by defining several functions that represent the different commands in your app.

void command1() {
    std::cout << "Command execution 1" << std::endl;
}

void command2() {
    std::cout << "Command execution 2" << std::endl;
}

void command3() {
    std::cout << "Command execution 3" << std::endl;
}

Step 2: Creating an array of function pointers.

Now, put together an array of pointers to these functions. The type of each element in the array is a pointer to a function that doesn't take arguments or return a value:

void (*commands[])() = {command1, command2, command3};

Step 3: Selecting and running a function from the array.

Then, depending on the user input or another condition, pick and run the right function.

int main() {
    int commandNumber;
    std::cout << "Enter the command number (1-3):";
    std::cin >> commandNumber;

    if (commandNumber >= 1 && commandNumber <= 3) {
        (*commands[commandNumber - 1])(); // Running the function by the selected number
    } else {
        std::cout << "Incorrect command number" << std::endl;
    }

    return 0;
}

This method is often used in situations like:

• Menu systems: Like in the example above, for various menu commands.

• Finite state machines: In games or systems where each state is a function.

• Event handlers: In systems where different events require different responses.

Using a table of function pointers enhances the versatility of your code and makes it easier to add new features: you just add a new function and its pointer to the array.

Advantages & disadvantages

Advantages:

1. Flexibility: Allows for different functions to be called at runtime.

2. Modularity: Separates the creation and usage of functions, promoting a modular design.

Disadvantages:

1. Complexity: The method of writing it can be challenging to master, potentially leading to errors or confusion.

2. Safety: You must ensure the function pointer really points to a function.

3. Readability: This could make the code harder to read, especially for those who are unfamiliar with the concept.

Conclusion

Pointers to functions in C++ are very useful for making programs that are flexible and dynamic. They let you handle functions in a similar way to variables, providing a means to pass functions around, use them as callbacks, and keep them for later. If you understand and use function pointers well, you can significantly enhance the capabilities of a C++ program, making it more modular and flexible.