Functor vs Function Performance

In general, functors and regular functions have similar performance characteristics in C++. However, there are a few factors that can affect their performance:

1. Inlining: Functors defined inside a class can be easier for the compiler to inline compared to regular functions, especially if the functor is used in a template context. Inlining eliminates the function call overhead and can lead to better performance.
2. Complexity: For simple operations, functors and regular functions should have comparable performance. However, if the functor contains additional data members or complex logic, it may introduce slight overhead compared to a simple function.
3. Compiler optimizations: Modern compilers are quite good at optimizing both functors and regular functions. In many cases, the compiler can generate equally efficient code for both.

Here's an example comparing the performance of a functor and a regular function:

1#include <algorithm>
2#include <chrono>
3#include <iostream>
4#include <vector>
5
6class Functor {
7 public:
8  int operator()(int x) const {
9    return x * 2;  
10  }
11};
12
13int FuncDouble(int x) {
14  return x * 2;  
15}
16
17int main() {
18  using namespace std::chrono;
19
20  std::vector<int> large_vec(10000000, 42);
21
22  auto start = high_resolution_clock::now();
23
24  std::transform(
25    large_vec.begin(), large_vec.end(),
26    large_vec.begin(), Functor());
27
28  auto end = high_resolution_clock::now();
29  duration<double> diff = end - start;
30  std::cout << "Functor time: "
31    << diff.count() << " s\n";
32
33  start = high_resolution_clock::now();
34  std::transform(
35    large_vec.begin(), large_vec.end(),
36    large_vec.begin(), FuncDouble);
37
38  end = high_resolution_clock::now();
39  diff = end - start;
40  std::cout << "Function time: "
41    << diff.count() << " s\n";
42}

1Functor time: 0.0221406 s
2Function time: 0.0254901 s

In this example, we have a functor Functor and a regular function FuncDouble, both of which double their input. We use std::transform to apply these callables to a large vector of integers and measure the execution time using std::chrono.

On a typical modern compiler with optimizations enabled, the performance difference between the functor and the regular function should be negligible.

It's important to profile and measure performance in your specific use case to determine if using a functor or a regular function has any significant impact. In most cases, the choice between a functor and a function should be based on design considerations, such as the need for state or the desire for a function object, rather than performance concerns.