Callbacks and Function Pointers

At this point, we’re familiar with the many ways we store and transfer objects around our program. We can pass them as arguments to functions, return them from functions, and store them as variables.

1// Passing an int to a function
2SetNumber(42);
3
4// Returning an int from a function
5int GetNumber() {
6  return 42;
7}
8
9// Storing an int to a member variable
10SomeObject.SomeMember = 42;

What might be less familiar is that we can do all of these things with functions, too:

1void SomeFunction() {
2  // ...
3];
4
5// Passing a function to a function
6SetFunction(MyFunction);
7
8// Returning a function from a function
9auto GetFunction() {
10  return MyFunction;
11}
12
13// Storing a function as a member variable
14SomeObject.SomeFunction = MyFunction;

This capability gives us a huge amount of flexibility in how we design our program and when used well, it helps us keep our code simple even as our behaviors get more and more complex.

A language that allows functions to be treated like any other data type is said to support first-class functions. C++ supports this concept in a few different ways. In the rest of this chapter, we’ll focus on one of them - function pointers.

Function Pointers

In this lesson, we’ll focus on pointers to free functions, that is, functions that are not a member of a class or struct.

1// A free function
2void SomeFunction() {/*...*/}
3
4class SomeClass {
5  // A member function
6  void SomeFunction() {/*...*/}
7};

We cover member functions in the next lesson. Creating a pointer to a function uses a similar syntax to any other data type:

• We can use the address-of operator & to create a function pointer
• We can use the dereferencing operator * to call a function through its pointer

For example:

1#include <iostream>
2
3void SomeFunction() {
4  std::cout << "Hello World";
5}
6
7int main() {
8  auto FunctionPtr{&SomeFunction};
9  (*FunctionPtr)();
10}

1Hello World

However, when working with function pointers, the & and * operators are typically unnecessary, and usually omitted in practice:

1#include <iostream>
2
3void SomeFunction() {
4  std::cout << "Hello World";
5}
6
7int main() {
8  auto FunctionPtr{SomeFunction};
9  FunctionPtr();
10}

1Hello World

Callbacks

When we use a function pointer, we intend to provide some component in our program with custom behavior that is defined outside of that component.

That other component can then decide if and when to invoke that behavior. Perhaps it invokes it only if some condition is true. Perhaps it invokes it multiple times. If the other component is an object, it can save that pointer in a member variable, and invoke it later.

A function used in this way is sometimes referred to as a callback. Below, we have a Process() function that receives some number and a callback in the form of a function pointer. The Process() function will invoke that callback only if the number is even:

1#include <iostream>
2
3void Process(int Number, auto EvenCallback) {
4  std::cout << "\nProcessing " << Number;
5  if (Number % 2 == 0) {
6    EvenCallback();
7  }
8}
9
10void LogEven() {
11  std::cout << " - that number is even";
12}
13
14int main() {
15  Process(4, LogEven);
16  Process(5, LogEven);
17  Process(6, LogEven);
18}

1Processing 4 - that number is even
2Processing 5
3Processing 6 - that number is even

Function Composition

Being able to compose functions together in this way gives us a succinct and elegant way to create complex behaviors from smaller, reusable parts.

For example, imagine we have a collection of numbers and we want to count how many of them are even. We could write this process as a single function

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5int CountEven(std::vector<int>& Numbers) {
6  int Count{0};
7  for (int& Num : Numbers) {
8    if (Number % 2 == 0) {
9      ++Count;
10    }
11  }
12  return Count;
13}
14
15int main() {
16  std::vector Numbers{1, 2, 3, 4, 5};
17  int EvenCount = CountEven(Numbers);
18
19  std::cout << "Number of even elements: "
20    << EvenCount;
21}

1Number of even elements: 2

Alternatively, we could implement it as the composition of multiple smaller functions.

The standard library includes the count_if() algorithm, which counts the number of elements in a collection that match some condition.

We can specify the condition we’re interested in by passing a function pointer to the algorithm. This argument will point to a function that will be invoked for every element in our collection. It will receive that element as an argument, and should return true if that element is to be included in the count:

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5bool isEven(int Number) {
6  return Number % 2 == 0;
7}
8
9int main() {
10  std::vector Numbers{1, 2, 3, 4, 5};
11  int EvenCount = std::ranges::count_if(
12    Numbers, isEven);
13
14  std::cout << "Number of even elements: "
15    << EvenCount;
16}

1Number of even elements: 2

This compositional approach has many advantages. Most notably, the count_if() and isEven() functions are more useful than our original CountEven() function, as they can be reused to solve different problems.

• The count_if() function can test for any condition, not just whether something is even
• The isEven() function can be used in any context, not just counting how many even numbers are in a collection

Let’s see another example. Below, we have a std::vector of custom Monster objects, and we want to find out how many of them are still alive:

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5struct Monster {
6  int Health;
7};
8
9bool isAlive(const Monster& Enemy) {
10  return Enemy.Health > 0;
11}
12
13int main() {
14  std::vector<Monster> Enemies{
15    {100}, {0}, {250}};
16    
17  int AliveCount = std::ranges::count_if(
18    Enemies, isAlive);
19
20  std::cout << AliveCount
21    << " enemies are still alive";
22}

12 enemies are still alive

We’ll see many more examples of the utility of first-class functions through the rest of this course, and practice with using the technique to solve practical problems.

Function Pointer Types

For simplicity, our earlier examples used auto to let the compiler deduce the type of our function pointers. Generally, we should prefer to be explicit with our types. Unfortunately, the syntax to specify function pointer types isn’t pretty:

1void FunctionA(){};
2bool FunctionB(int x) { return true; }
3bool FunctionC(int x, float y) { return true; }
4
5int main() {
6  // A function that returns nothing
7  // and accepts no arguments
8  void (*PtrA)(){FunctionA};
9
10  // A function that returns a bool
11  // and accepts an int argument
12  bool (*PtrB)(int){FunctionB};
13
14  // A function that returns a bool and
15  // accepts int and float arguments
16  bool (*PtrC)(int, float){FunctionC};
17}

When we specify a parameter type as a function pointer, we can also make it optional, allowing callers to provide a callback only if they need to.

Below, we update our earlier Process function to have a default callback of nullptr, and update our if check to prevent it from trying to invoke a callback if it wasn’t provided:

1#include <iostream>
2
3void Process(
4  int Number,
5  void (*EvenCallback)() = nullptr
6) {
7  std::cout << "\nProcessing " << Number;
8  if (EvenCallback && Number % 2 == 0) {
9    EvenCallback();
10  }
11}
12
13void LogEven() {
14  std::cout << " - that number is even";
15}
16
17int main() {
18  Process(4, LogEven);
19  Process(5, LogEven);
20  Process(6);
21}

1Processing 4 - that number is even
2Processing 5
3Processing 6

std::function

The standard library includes some helpers to make storing and transferring function pointers easier. One of the most useful is std::function, which has the immediate benefit of making our types easier to understand:

1#include <functional>
2
3void FunctionA(){};
4bool FunctionB(int x) { return true; }
5bool FunctionC(int x, float y) { return true; }
6
7int main() {
8  // A function that returns nothing
9  // and accepts no arguments
10  std::function<void()> PtrA{FunctionA};
11
12  // A function that returns a bool
13  // and accepts an int argument
14  std::function<bool(int)> PtrB{FunctionB};
15
16  // A function that returns a bool and
17  // accepts int and float arguments
18  std::function<bool(int, float)> PtrC{FunctionC};
19
20  // When we're providing an initial value, the
21  // compiler can usually infer the return and
22  // argument types using Class Template Argument
23  // Deduction (CTAD)
24  std::function PtrD{FunctionC};
25}

Using it in a function parameter looks like this:

1void Process(
2  int Number,
3  std::function<void()> EvenCallback = nullptr
4) {
5  std::cout << "\nProcessing " << Number;
6  if (EvenCallback && Number % 2 == 0) {
7    EvenCallback();
8  }
9}

Asynchronous Callbacks

So far, our examples have passed a function pointer to another function that invokes (or conditionally invokes) the callback during execution. However, function pointers can also be used asynchronously. That is, in scenarios where the execution is delayed or triggered by events.

A common way to implement this is by storing function pointers as member variables in objects. The object can then invoke the function later in response to some event or situation, effectively decoupling the definition of behavior from its execution time.

For example, let's create a Player class that notifies an external system when the player is defeated:

1// Player.h
2#pragma once
3#include <iostream>
4#include <functional>
5
6class Player {
7public:
8  void TakeDamage (int Damage) {
9   Health -= Damage;
10   if (DefeatCallback && Health <= 0) {
11     DefeatCallback();
12   }
13  }
14
15  int Health;
16  std::function<void()> DefeatCallback{nullptr};
17};

Now, other systems can define arbitrary behaviors, whilst giving the Player object control over when those behaviors are executed:

1#include <iostream>
2#include "Player.h"
3
4void OnDefeat() {
5  std::cout << "Game Over";
6}
7
8int main() {
9  Player PlayerOne{100, OnDefeat};
10  PlayerOne.TakeDamage(150);
11}

1Game Over

This is the basic foundation of a powerful software design principle called the observer pattern. We’ll expand on this system and explore its benefits in more detail later in the chapter.

Returning Functions

The final tenet of the first class functions concept involves returning functions from other functions. Function pointers in C++ support this in the way we might expect. We simply list the return type in the function prototype, and return a pointer that matches that type:

1#include <functional>
2#include <iostream>
3
4void Greet() {
5  std::cout << "Hello World\n";
6}
7
8std::function<void()> GetFunction() {
9  return Greet;
10}
11
12int main() {
13  auto Func{GetFunction()};
14  Func();
15
16  // Alternatively:
17  GetFunction()();
18}

1Hello World
2Hello World

While this technique may be less commonly used than the others we've introduced, it does have valuable applications in certain scenarios.

For example, let’s imagine we have a SuggestAction() function that evaluates a few different actions (functions). It returns a function pointer with its recommended action, and updates a Utility integer, estimating the usefulness of that action:

1// Actions.h
2#pragma once
3#include <functional>
4#include <iostream>
5
6void Heal() {
7  std::cout << "Healing...\n";
8}
9void Attack() {
10  std::cout << "Attacking...\n";
11}
12void RunAway() {
13  std::cout << "Running away...\n";
14}
15
16bool canHeal() { return false; }
17bool canAttack() { return false; }
18int GetAttackDamage() { return 100; }
19
20std::function<void()> SuggestAction(int& Utility) {
21  if (canHeal()) {
22    Utility = 150;
23    return Heal;
24  } else if (canAttack()) {
25    Utility = GetAttackDamage();
26    return Attack;
27  } else {
28    Utility = 25;
29    return RunAway;
30  }
31}

Elsewhere in our code, we can ask this function for its recommended action, but only perform that action if it would be sufficiently impactful:

1#include <iostream>
2#include "Actions.h"
3
4int main() {
5  int Utility;
6  auto Action{SuggestAction(Utility)};
7
8  if (Utility >= 100) {
9    Action();
10  } else {
11    std::cout << "Utility (" << Utility << ")"
12      " is too low - taking no action";
13    // ...
14  }
15}

1Utility (25) is too low - taking no action

This is a simplistic example of a utility system, often used to control the behavior of AI agents in games and other contexts. We’ll expand on this more later in the chapter when we work with pointers to functions that are members of a class or struct.

Summary

This lesson covered the basics of first-class functions in C++.

• We examined how to use, pass, and store function pointers.
• Practical examples included callbacks, composition, and asynchronous patterns.
• std::function was introduced as a more readable alternative to raw function pointers.

These techniques enable more flexible and modular code design.

Next Lesson

Member Function Pointers and Binding

Explore advanced techniques for working with class member functions

ContinueView Course