C++ Functors (Function Objects)

Another option we have for implementing first-class functions in C++ is function objects. Function objects are sometimes also referred to as functors.

Creating functors involves operator overloading. We’ve previously seen how we can overload operators like ++ in our custom class code.

The syntax we use to call functions, (), is also an operator, and so can be overloaded in the same way:

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

The double set of () here 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++() {};
2

So, given we’re overloading the () operator, replacing ++ with () might make more sense.

Now, with our when we have an instance of this object, we can “call” it:

1int main() {
2  Functor MyFunctor;
3  MyFunctor();
4}
5

A common mistake here is to use the () operator with the class, rather than an object. This code will compile, but it is calling the class constructor, rather than our operator overload:

1int main() {
2  Functor();
3}
4

Given the constructor returns an instance of the object, we could chain an additional () to this expression, which would then call our overload on the object that was constructed:

1int main() {
2  Functor()();
3}
4

Using Functors as First-Class Functions

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

1void CallIfEven(int n, auto callback) {
2  if (n%2 == 0) callback();
3}
4
5int main() {
6  Functor MyFunctor;
7  CallIfEven(2, MyFunctor);
8}
9

Functor Return Values

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

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

Functor Parameters

Within the second set of brackets, we can allow our functors to accept arguments:

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);
13}
14

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 World\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}
18

1Hello World
2Hello Integer
3

Functor Benefits

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 constructors
• they can overload other operators
• they can exist within an inheritance tree

However, the most common use case for functors is simply when we require a callable with some persistent state.

For example, here, we have a functor that returns how many times it has been called:

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

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

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

Passing Functors by Reference

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 callback) {
2  if (n%2 == 0) callback();
3}
4

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

1int main() {
2  Functor MyFunctor;
3  MyFunctor();
4  CallIfEven(2, MyFunctor);
5  MyFunctor();
6}
7

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

Instead, we typically want to pass our functors by reference, using the & syntax:

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

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