What is a Functor?

In C++, a functor is an object that can be used like a function. This is achieved by providing an overload of the operator() in a class. When you create an instance of such a class, you can use this instance as if it were a function by invoking it with the same syntax as a function call. This makes functors very flexible, as they can store state and have properties like regular objects, while still being usable as functions.

Here's a simple example of a functor in C++:

#include <iostream>

using namespace std;

class Adder {
public:
    Adder(int n) : n_(n) {}

    int operator()(int x) const {
        return x + n_;
    }

private:
    int n_;
};

int main() {
    Adder addFive(5);
    cout << "Result: " << addFive(3) << endl; // Result: 8
    return 0;
}

In this example, Adder is a functor. It is initialized with a number, and when it is called as a function, it adds this number to its argument. The operator() method makes this possible. This pattern is particularly useful in C++ for things like custom comparison functions in sorting algorithms, or for creating small function objects that carry state.

Why is functor useful?

The key difference between using a functor and simply passing an additional variable to a function in C++ lies in the encapsulation of both state and behavior, as well as the potential for increased flexibility and efficiency.

1. Encapsulation of State and Behavior:

   • A functor encapsulates both data (state) and a specific operation (behavior) in one object. In the Adder example, the state is the value to add (n_), and the behavior is the addition operation itself.
   • In contrast, passing an extra variable to a function only provides additional data. The function's behavior is fixed and cannot be changed unless you modify the function's code.

2. Object-Oriented Approach:

   • Functors align well with object-oriented programming principles. They allow you to bundle data and functionality together, and they can also inherit from other classes or implement interfaces.
   • Passing additional variables does not inherently leverage object-oriented principles.

3. Flexibility and Reusability:

   • Functors can be more flexible. For instance, you can create different functor classes that implement the same interface but perform different operations. This makes it easy to swap out one functor for another without changing the code that uses them.
   • With a simple variable, this level of flexibility is not achievable. The function that uses the variable is limited to a specific operation defined in its implementation.

4. Efficiency in Certain Contexts:

   • In some cases, using functors can be more efficient, especially in templated code like in the Standard Template Library (STL). Functors can be inlined by the compiler, potentially leading to more efficient code than using a pointer to a function.
   • Passing a variable doesn't have this potential for compiler optimization in the context of the operation's implementation.

5. Compatibility with STL and Other Libraries:

   • Functors are widely used in C++ standard libraries, such as for custom comparison functions in sorting algorithms. They are designed to be used where the library expects an object that can be called like a function.
   • While passing variables is a common practice, it doesn't serve the same purpose as a functor in the context of these libraries.

In summary, functors offer a more encapsulated, flexible, and potentially efficient way to bundle data and operations together, aligning with object-oriented principles and offering advantages particularly in templated and library code. Passing additional variables to functions is a simpler approach but lacks these advantages.