Function Pointers

In this lesson, we'll show how to create and use function pointers. This is one of the ways C++ implements first-class functions.

First-class functions are functions that can be treated like any other data type. For example, they can be stored in variables and passed around, even as arguments, and return values in other functions.

For function pointers, the key point is that we can imagine functions existing in an area of memory, like any other variable.

We can see this using the address of operator & with the name of one of our functions. The following program will log out a memory address:

1#include <iostream>
2
3bool isEven(int Number) {
4  return Number % 2 == 0;
5}
6
7int main() { std::cout << &isEven; }

100007FF6734B1947

Like with any other type of pointer, this memory address can be stored as a variable and passed around our application as needed. Below, we show two examples of this:

1bool isEven(int Number) {
2  return Number % 2 == 0;
3}
4
5void SomeFunction(auto Function) {
6  // ...
7}
8
9int main() {
10  auto isEvenPtr{&isEven};
11  SomeFunction(&isEven);
12}

Function Pointer Types

Above, we used auto to have the compiler figure out our data type, but it’s worth considering what data type function pointers have.

From our earlier lessons on forward declarations and prototypes, we may already be able to predict that the type of a function.

A function's type is a combination of the function’s return type, as well as the type of all of its parameters. Unfortunately, the way we specify this in C++ is quite cryptic.

To create a variable called isEvenPtr that stores a pointer to a function that returns a boolean, and accepts a single integer, we do this:

1bool (*isEvenPtr)(int);

A later lesson on standard library function helpers will provide a better way of declaring function types. But, for this lesson, we’ll use the native approach.

We can assign a value to a function pointer in the normal ways:

1bool isEven(int x){
2  return x % 0 == 2;
3};
4
5bool isOdd(int x){
6  return !isEven(x);
7};
8
9int main() {
10  // Initialisation
11  bool (*FunctionPtr)(int){&isEven};
12
13  // Updating
14  FunctionPtr = &isOdd;
15
16  // Function pointers can also be a nullptr
17  FunctionPtr = nullptr;
18}

More examples

Below, we have a pointer that stores a function that returns nothing, and accepts no arguments:

1void (*FunctionPtr)();

In this example, we have a pointer to function that returns an int, and accepts two int arguments:

1int (*FunctionPtr)(int, int);

Below, we have a function that returns nothing, and accepts two arguments: a Player pointer, and a constant Player reference

1void (*Example3)(Player*, const Player&);

const Function Pointers

Function pointers can also be marked as const, preventing that pointer from being updated:

1void SomeFunction(){};
2void AnotherFunction(){};
3
4int main() {
5  void (*const ConstExample)(){&SomeFunction};
6
7  ConstExample = &AnotherFunction;  
8}

1error: 'ConstExample': you cannot assign to a variable that is const

Type Aliases with Function Pointers

Like with other types, we can use type aliases with function pointers, via the using statement. This can help us make our code more readable, particularly if our complicated type is going to be repeated in several places. Imagine we have the following code:

1void (*FuncA)(Player*, const Player&) {
2  &MyFunction
3};
4
5void (*FuncB)(Player*, const Player&) {
6  &MyFunction
7};
8
9void (*FuncC)(Player*, const Player&) {
10  &MyFunction
11};
12
13void SomeFunction(
14  void (*F)(Player*, const Player&),
15  int SomeInt){
16  // Code
17}

This can be made much more readable by adding a using statement to alias our verbose void(*)(Player*, const Player&) type to something friendlier, like PlayerHandler:

1using PlayerHandler =
2  void(*)(Player*, const Player&);
3
4PlayerHandler FuncA{&MyFunction};
5PlayerHandler FuncB{&MyFunction};
6PlayerHandler FuncC{&MyFunction};
7
8void SomeFunction(PlayerHandler F, int SomeInt){
9  // Code
10}

Calling Functions through a Pointer

As with any other pointer, we can dereference it using the * operator. This will return a function, which we can call using the () operator as normal:

1(*isEvenPtr)(4); // returns true

Note the additional set of brackets around *isEvenPtr. This is because the () operator has higher precedence than the * operator, therefore we need to add brackets to ensure the dereferencing happens first.

1#include <iostream>
2
3bool isEven(int Number) {
4  return Number % 2 == 0;
5}
6
7int main() {
8  auto isEvenPtr{&isEven};
9  bool is4Even{(*isEvenPtr)(4)};
10  if (is4Even) std::cout << "4 is even";
11}

14 is even

As function pointers can be nullptr, we should generally ensure this isn’t the case before we call it. We can do that using an if statement, in the same way we handle other pointers:

1#include <iostream>
2
3bool isEven(int Number) {
4  return Number % 2 == 0;
5}
6
7int main() {
8  auto isEvenPtr{&isEven};
9  if (isEvenPtr) {
10    std::cout << "isEvenPtr is available";
11    std::cout << "\n4 is "
12      << ((*isEvenPtr)(4) ? "even" : "odd");
13  }
14
15  bool (*isOddPtr)(int){nullptr};
16  if (!isOddPtr) {
17    std::cout << "\nisOddPtr is a nullptr";
18  }
19}

1isEvenPtr is available
24 is even
3isOddPtr is a nullptr

Implicit Referencing and Dereferencing

In these examples, we’ve been adding the address-of operator & and the dereferencing operator * in the same places we would do were we dealing with a pointer to any other data type.

In the case of function pointers, this is not strictly necessary. When our variables are storing function pointers, the compiler can implicitly take care of this for us, meaning code like this:

1auto isEvenPtr { &isEven };
2(*isEvenPtr)(4);

Can be simplified to this:

1auto isEvenPtr { isEven };
2isEvenPtr(4);

A Complete Example

In the previous lesson, we introduced a scenario where we’d want to be able to pass a function to another function in our code. We had a Party class, and we wanted to be able to determine if every Player in that party met some requirements.

This program is very similar to what we created in the previous lesson. The main difference is we’ve now updated our all_of() function to specify that it explicitly requires a function pointer, whereas previously we were using a template function.

The type of function pointer it accepts has been aliased to Handler:

1#include <iostream>
2
Player Class|Show
3class Player {/*...*/};
10
11class Party {
12 public:
13  using Handler = bool (*)(const Player&);
14  bool all_of(Handler Predicate) {
15    return Predicate(PlayerOne) &&
16      Predicate(PlayerTwo) &&
17      Predicate(PlayerThree);
18  }
19
Private Members|Show
20 private:
25};
26
27bool PlayerIsAlive(const Player& P) {
28  return P.isAlive();
29}
30
31bool PlayerIsOnline(const Player& P) {
32  return P.isOnline();
33}
34
35bool PlayerIsAtLeastLevel50(const Player& P) {
36  return P.GetLevel() >= 50;
37}
38
39int main() {
40  Party MyParty;
41
42  if (MyParty.all_of(PlayerIsAlive)) {
43    std::cout << "Everyone is alive";
44  }
45
46  if (MyParty.all_of(PlayerIsOnline)) {
47    std::cout << "\nEveryone is online";
48  }
49
50  if (!MyParty.all_of(PlayerIsAtLeastLevel50)) {
51    std::cout << "\nNot everyone is level 50+";
52  }
53}

1Everyone is alive
2Everyone is online
3Not everyone is level 50+

Just like that, our Party class offers a huge amount of flexibility to anyone who uses it. And, critically, it does so without violating principles like encapsulation. Arbitrary code can ask an infinite number of questions of our Party class and the Player objects it manages, but the Party class maintains full control over that process.

If we want to change how our party works by, for example, expanding the size of the party, or changing how the underlying Player objects are stored, we only need to modify our Party class and the all_of() function within it.

all_of(), any_of(), and for_each()

Above, we only implemented an all_of() function, but in real scenarios, we often need a few more. For example, our class becomes more useful if it offers a few different variations of this idea:

• An ell_of() function, which we implemented above, returns true if every object we’re managing satisfies a provided predicate. A function that implements this is sometimes alternatively called all() or every()
• An any_of() function, which returns true if any object we’re managing satisfies a provided predicate. A common alternative name for this function is any() or some()
• A for_each() function, which simply provides every object we’re managing to a function, for that function to implement whatever logic is required.

We’ve updated our example Party class with all of these methods below:

1#include <iostream>
2
Player Class|Show
3class Player {/*...*/};
13
14class Party {
15 public:
16  using PlayerPred = bool (*)(const Player&);
17  bool all_of(PlayerPred Predicate) {
18    return Predicate(PlayerOne) &&
19      Predicate(PlayerTwo) &&
20      Predicate(PlayerThree);
21  }
22
23  bool any_of(PlayerPred Predicate) {
24    return Predicate(PlayerOne) ||
25      Predicate(PlayerTwo) ||
26      Predicate(PlayerThree);
27  }
28
29  using PlayerHandler = void (*)(const Player&);
30  void for_each(PlayerHandler Function) {
31    Function(PlayerOne);
32    Function(PlayerTwo);
33    Function(PlayerThree);
34  }
35
Private Members|Show
36 private:
41};
42
43bool PlayerIsOnline(const Player& P) {
44  return P.isOnline();
45}
46
47bool PlayerIsHealer(const Player& P) {
48  return P.isHealer();
49}
50
51void ReadyCheck(const Player& P) {
52  std::cout << P.GetName() << " is Ready!\n";
53}
54
55int main() {
56  Party MyParty;
57
58  if (MyParty.all_of(PlayerIsOnline)) {
59    std::cout << "Everyone is Online\n";
60  }
61
62  if (MyParty.any_of(PlayerIsHealer)) {
63    std::cout << "Someone is a Healer\n";
64  }
65
66  MyParty.for_each(ReadyCheck);
67}

1Everyone is Online
2Someone is a Healer
3Roderick is Ready!
4Anna is Ready!
5Robert is Ready!

Using Template Functions

When using these techniques, a common requirement we’ll have is the ability to provide additional arguments to our functions. In the following example, we check if every Player is at least level 40:

1#include <iostream>
2
Player Class|Show
3class Player {/*...*/};
8
Party Class|Show
9class Party {/*...*/};
23
24bool MinLevel40(const Player& P) {
25  return P.GetLevel() >= 40;
26}
27
28int main() {
29  Party MyParty;
30
31  if (MyParty.all_of(MinLevel40)) {
32    std::cout << "Everyone is level 40+";
33  }
34}

1Everyone is level 40+

Fixing the level check to 40 like this is not particularly flexible - we’ll want to be able to change that value, so it should be a parameter. But, when dealing with first-class functions, it might not be especially obvious how to do that.

If the values we want to check are known at compile time, we could solve this using a function template:

1#include <iostream>
2
Player Class|Show
3class Player {/*...*/};
8
Party Class|Show
9class Party {/*...*/};
23
24template <int Min>
25bool MinLevel(const Player& P) {
26  return P.GetLevel() >= Min;
27}
28
29int main() {
30  Party MyParty;
31
32  if (MyParty.all_of(MinLevel<40>)) {
33    std::cout << "Everyone is level 40+";
34  }
35
36  if (!MyParty.all_of(MinLevel<50>)) {
37    std::cout << " but not level 50+";
38  }
39}

1Everyone is level 40+ but not level 50+

If these values are not known at compile time, there are a few other ways we could solve this problem. We’ll cover them throughout this chapter, starting with functors in the next lesson.

Summary

In this lesson, we've explored how function pointers enable the storage and passing of functions just like any other data type. The main points we learned include:

• Function pointers allow functions to be stored in variables and passed around within a program.
• The syntax for declaring function pointers includes the return type, parameter list, and an asterisk (*) to denote a pointer.
• Using auto can simplify the declaration of function pointers when the compiler can deduce the type, and we’ll introduce friendler ways to declare functional types later in the chapter.
• Function pointers can be passed as arguments to functions, enabling callback mechanisms.
• Function pointers can be nullptr, and checking for this before dereferencing is a good practice.
• Implicit referencing and dereferencing are available with function pointers, allowing for cleaner syntax in certain cases.
• Template functions can be used in conjunction with function pointers to provide additional flexibility, such as passing extra arguments to the pointed-to functions.

Next Lesson

Function Objects (Functors)

This lesson introduces function objects, or functors. This concept allows us to create objects that can be used as functions, including state management and parameter handling.

ContinueView Course