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:

1#include <iostream>
2using namespace std;
3
4bool isEven(int Number) {
5  cout << "Calling isEven" << endl;
6  return Number % 2 == 0;
7}
8
9int main() {
10  cout << &isEven << endl;
11}
12

This will log out a memory address, like 0x001627a0

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

1auto isEvenPtr { &isEven };
2SomeFunction(isEvenPtr);
3

Function Pointer Data Types

Above, we used auto to have the compiler figure out our data type, but it’s worth considering what data type function pointers actually 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);
2

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

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

1// Initialisation
2bool (*isEvenPtr)(int) { &isEven };
3
4// Updating
5isEvenPtr = &SomeOtherFunction;
6
7// Function pointers can also be nullptr
8isEvenPtr = nullptr;
9

Here are some more examples of function pointer types:

1// A function that returns nothing, and accepts
2// no arguments
3void (*Example1)();
4
5// A function that returns an int, and accepts
6// two int arguments
7int (*Example2)(int, int);
8
9// A function that returns nothing, and accepts
10// two arguments
11//  - A Character pointer
12//  - A constant Character reference
13void (*Example3)(Character*, const Character&);
14

Function pointers can also be marked as const:

1void (*const ConstExample)();
2
3// Error - cannot update a const variable
4ConstExample = nullptr;
5

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. Sections of code that look like this:

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

Can be made much more readable by adding a using statement:

1using CharacterHandler =
2  void(*)(Character*, const Character&);
3
4CharacterHandler FuncA{&MyFunction};
5CharacterHandler FuncB{&MyFunction};
6CharacterHandler FuncC{&MyFunction};
7
8void SomeFunction(
9  CharacterHandler Handler, int SomeInt){
10  // Code
11}
12
13

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
2

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.

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>
2using namespace std;
3
4bool isEven(int Number) {
5  cout << "Calling isEven" << endl;
6  return Number % 2 == 0;
7}
8
9int main() {
10  auto isEvenPtr { &isEven };
11  if (isEvenPtr) {
12    (*isEvenPtr)(4); // returns true
13  }
14  
15  bool (*isOddPtr)(int) { nullptr };
16  if (isOddPtr) {
17    (*isOddPtr)(4); // never called
18  }
19}
20

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);
3

Can be simplified to this:

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

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 Character in that party met some requirements:

1#include <iostream>
2#include <memory>
3
4using std::unique_ptr, std::make_unique,
5  std::cout;
6
7class Character {
8public:
9  bool isAlive() const{ return true; }
10};
11
12
13class Party {
14public:
15  // TODO: add an "every" function
16
17private:
18  unique_ptr<Character> PlayerOne{
19    make_unique<Character>()
20  };
21  unique_ptr<Character> PlayerTwo{
22    make_unique<Character>()
23  };
24  unique_ptr<Character> PlayerThree{
25    make_unique<Character>()
26  };
27  unique_ptr<Character> PlayerFour{
28    make_unique<Character>()
29  };
30};
31
32bool isCharacterAlive(
33  const Character& Character){
34  return Character.isAlive();
35};
36
37int main(){
38  Party MyParty;
39  if (MyParty.every(isCharacterAlive)) {
40    cout << "Everyone is alive!\n";
41  }
42}
43

We can now make this work by adding the every function to our Party class, and letting it accept a pointer to a function that accepts a const Character& as an argument, and returns a bool:

1class Party {
2public:
3  using Handler = bool (*)(const Character&);
4  bool every(Handler Predicate) {
5    return (
6      Predicate(*PlayerOne) &&
7      Predicate(*PlayerTwo) &&
8      Predicate(*PlayerThree) &&
9      Predicate(*PlayerFour)
10    );
11  }
12// The rest of the class is unchanged
13};
14

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 Character 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 Character objects are stored, we only need to modify our Party class and the every function within it.

1bool isCharacterAlive(
2  const Character& Character){
3  return Character.isAlive();
4}
5
6// is everyone alive?
7MyParty.every(isCharacterAlive);
8

1bool isCharacterAlive(
2  const Character& Character){
3  return Character.isAlive();
4}
5
6// is anyone alive?
7MyParty.some(isCharacterAlive);
8

1void Revive(Character& Character) {
2  Character.Revive();
3}
4
5// Revive everyone
6MyParty.forEach(Revive);
7