Storing a Function in a Variable

Hello and welcome! Today's lesson explores a powerful feature of C++: storing functions in variables. This is useful for scenarios like callbacks, event handlers, or flexible program design. Our goal is to understand how to do this using C++ via function pointers and std::function.

By the end of this lesson, you'll know how to store functions in variables using both traditional function pointers and the modern std::function type.

Most importantly, we will learn to operate functions as objects, which will be very useful in future lessons.

First, let's look at function pointers, a classic C++ feature. A function pointer stores the address of a function, allowing dynamic behavior.

Consider a function to add two integers:

int add(int a, int b) {
    return a + b;
}

To store this function in a pointer:

#include <iostream>

int add(int a, int b) {
    return a + b;
}

int main() {
    // Declare a function pointer
    int (*fp)(int, int) = add;

    // Use the function pointer
    std::cout << "Using function pointer: " << fp(2, 3) << '\n';  // Output: Using function pointer: 5

    return 0;
}

Here, int (*fp)(int, int) = add; declares a function pointer fp that can point to any function taking two ints and returning an int. We then call fp(2, 3) to use the add function through the pointer.

Function pointers are also function objects because they can be called like ordinary functions. A function object in functional programming is essentially a function treated as a value, similar to how you treat numbers or strings. It means you can pass these functions around as arguments to other functions, return them as results from other functions, and assign them to variables.

Additionally, all types that can be implicitly converted to a function pointer are function objects, but this should be avoided. You should prefer proper function objects because they’re more powerful and easier to handle.

Next, we introduce std::function, from the <functional> header. std::function is versatile and safer than raw function pointers, able to store any callable target.

Here's a comparison using std::function for the add function:

#include <iostream>
#include <functional>

int add(int a, int b) {
    return a + b;
}

int main() {
    // Using std::function
    std::function<int(int, int)> func = add;

    std::cout << "Using std::function: " << func(2, 3) << '\n';  // Output: Using std::function: 5

    return 0;
}

Here, std::function<int(int, int)> func = add; stores the add function in a std::function object, which improves type safety and flexibility.

1. std::function: std::function<int(int, int)> func = add; creates a std::function object storing any callable entity with the int(int, int) signature.
2. Using std::function: std::cout << "Using std::function: " << func(2, 3) << '\n'; calls add via the std::function object func, yielding the desired result: 5.

std::function offers more flexibility and ease for storing various callable objects. However, it’s crucial to note that std::function can introduce noticeable performance penalties. To be able to hide the contained type and provide a common interface over all callable types, std::function uses a technique known as type erasure. Type erasure is usually based on virtual member function calls. Because virtual calls are resolved at runtime, the compiler can’t inline the call and has limited optimization opportunities.