Function Objects (Functors)

1class Functor {
2public:
3  void operator()() const {
4    std::cout << "Hello from Functor!";
5  }
6};

The double set of () in this function name might seem weird, but it is consistent with the syntax we use for other operator overloads. For example, we'd overload ++ like this:

1void operator++() {};

So, given we're overloading the () operator, we can imagine replacing the ++ in this function name with (), to give operator()()

When our type overloads the () operator, we can use it with objects of that type, creating a function-like interaction:

1#include <iostream>
2
3class Functor {
4public:
5  void operator()() const {
6    std::cout << "Hello from Functor!";
7  }
8};
9
10int main() {
11  Functor MyFunctor;
12  MyFunctor();
13}

1Hello from Functor!

Like any object, a functor can be passed to other functions, as either a copy or a reference. Therefore, functors allow us to implement the behavior of first-class functions:

1#include <iostream>
2
Functor Class|Show
3class Functor {/*...*/};
10
11void CallIfEven(int n, auto Func) {
12  if (n % 2 == 0) {
13    std::cout << "n is even, so calling Func:\n";
14    Func();
15  };
16}
17
18int main() {
19  Functor MyFunctor;
20  CallIfEven(2, MyFunctor);
21}

1n is even, so calling Func:
2Hello from Functor!

As with regular functions, we can return values from functors. We do that by replacing the void in our overload with the type we want to return, and then using appropriate return statements:

1#include <iostream>
2
3class Functor {
4 public:
5  int operator()() const { return 5; }
6};
7
8int main() {
9  Functor MyFunctor;
10  std::cout << "MyFunctor returns: "
11    << MyFunctor();
12}

1MyFunctor returns: 5

Within the second set of brackets, we can allow our functors to accept arguments. The syntax and capabilities here are exactly the same as they are when providing parameter lists to any other type of function:

1#include <iostream>
2
3class Functor {
4public:
5  int operator()(int x, int y) const {
6    return x + y;
7  }
8};
9
10int main() {
11  Functor MyFunctor;
12  std::cout << "MyFunctor(2, 3) returns: "
13    << MyFunctor(2, 3);
14}

1MyFunctor(2, 3) returns: 5

This also means we can overload the () operator multiple times within the same class, as long as our parameter lists are unique:

1#include <iostream>
2
3class Functor {
4public:
5  void operator()() const {
6    std::cout << "Hello from Functor\n";
7  }
8  void operator()(int x) const {
9    std::cout << "Hello Integer\n";
10  }
11};
12
13int main() {
14  Functor MyFunctor;
15  MyFunctor();
16  MyFunctor(5);
17}

1Hello from Functor
2Hello Integer

Functors have a lot more power than simple function pointers. Being instances of classes, we naturally have all the power that brings with it. For example:

• they can have other methods and variables accessible with the . operator
• they can have user-defined constructors
• they can overload other operators
• they can exist within an inheritance tree

The most common use case for functors is simply when we require a callable with some persistent state. For example, below, we have a functor that keeps track of how many times it has been called:

1#include <iostream>
2
3class Functor {
4public:
5  void operator()() {
6    std::cout << "I have been called "
7              << ++Invocations
8              << " time(s)\n";
9  }
10private:
11  int Invocations { 0 };
12};
13
14int main() {
15  Functor MyFunctor;
16  MyFunctor();
17  MyFunctor();
18  MyFunctor();
19}

1I have been called 1 time(s)
2I have been called 2 time(s)
3I have been called 3 time(s)

Implementing similar behavior with a regular function wouldn't be quite so easy to encapsulate.

Remember, as with any object, a functor passed to another function is going to be passed by value by default.

Here, our CallIfEven() function is receiving copies of our function object:

1void CallIfEven(int n, auto Func) {
2  if (n%2 == 0) Func();
3}

When our reason for using the functor is to maintain some internal state, this is generally not what we want to happen.

In the following example, note our functor doesn't accurately track how many times it is being called. This is because the CallIfEven() function is acting on a copy of our functor:

1#include <iostream>
2
Functor Class|Show
3class Functor {/*...*/};
14
15void CallIfEven(int n, auto Func) {
16  if (n % 2 == 0) Func();
17}
18
19int main() {
20  Functor MyFunctor;
21  MyFunctor();
22  CallIfEven(2, MyFunctor);
23  MyFunctor();
24}

1I have been called 1 time(s)
2I have been called 2 time(s)
3I have been called 2 time(s)

Instead, we typically want to pass our functors by reference, by appending & to the type in the usual way:

1#include <iostream>
2
Functor Class|Show
3class Functor {/*...*/};
14
15void CallIfEven(int n, auto& Func) {
16  if (n % 2 == 0) Func();
17}
18
main Function|Show
19int main() {/*...*/}

1I have been called 1 time(s)
2I have been called 2 time(s)
3I have been called 3 time(s)

In the previous lesson, we introduced the following scenario, where we had a function that checks if every Player object in a collection 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 or above";
33  }
34}

1Everyone is level 40 or above

The MinLevel40 function is a bit inflexible - ideally, we'd like to be able to provide the minimum Level as an argument, rather than fixing it to 40. However, we're also not able to provide the MinLevel and Player at the same time, as those arguments are stored in different places in our code.

We showed how we could solve this using a template function in the previous lesson:

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 or above";
34  }
35
36  if (!MyParty.all_of(MinLevel<50>)) {
37    std::cout << "\nBut not level 50 or above";
38  }
39}

1Everyone is level 40 or above
2But not level 50 or above

That approach works, but template parameters must be known at compile time. With our new knowledge of functors, we now have a way we could implement this at run time:

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

1Everyone is level 40 or above
2But not level 50 or above

In this example, we can imagine we have a function that requires two arguments, but we're not able to provide them at the same time or place:

• The MinLevel argument is provided in our main() function
• The Player argument is provided later, in the Party type's all_of() method

We solved this using partial application. By instantiating our LevelChecker type, we create a functor. That callable is created by providing one of the parameters it needs - the MinLevel - so it is partially applied.

It's not fully applied because it still needs one more argument - the Player - to complete its work. That argument is provided later, elsewhere in our code.

A functor is only one way of implementing this design. We cover partial application in a dedicated lesson later in the chapter.

In this lesson, we introduced function objects, or functors, which are objects that can be used like functions. The main points we learned include:

• Function objects, also known as functors, are objects that can be called like functions thanks to the overloading of the () operator.
• Operator overloading enables functors to not only mimic function calls but also accept parameters and return values.
• Functors can be used to implement first-class functions, as they can passed to and returned from functions like any other object.
• Functors can have other member functions and variables, benefit from user-defined constructors, overload other operators, and participate in inheritance hierarchies.
• A common use case for functors is to maintain persistent state across calls, which we showcased by counting invocations.
• When passing functors to functions, passing by reference (using &) is crucial for maintaining state across calls.
• Functors offer a solution for partial application, enabling arguments to be provided at different times or places in the code, thus allowing for more flexible function invocation patterns.