Why use functors over functions?

by

At least four good reasons:

Separation of concerns

In your particular example, the functor-based approach has the advantage of separating the iteration logic from the average-calculation logic. So you can use your functor in other situations (think about all the other algorithms in the STL), and you can use other functors with for_each.

Parameterisation

You can parameterise a functor more easily. So for instance, you could have a CalculateAverageOfPowers functor that takes the average of the squares, or cubes, etc. of your data, which would be written thus:

class CalculateAverageOfPowers
{
public:
    CalculateAverageOfPowers(float p) : acc(0), n(0), p(p) {}
    void operator() (float x) { acc += pow(x, p); n++; }
    float getAverage() const { return acc / n; }
private:
    float acc;
    int   n;
    float p;
};

You could of course do the same thing with a traditional function, but then makes it difficult to use with function pointers, because it has a different prototype to CalculateAverage.

Statefulness

And as functors can be stateful, you could do something like this:

CalculateAverage avg;
avg = std::for_each(dataA.begin(), dataA.end(), avg);
avg = std::for_each(dataB.begin(), dataB.end(), avg);
avg = std::for_each(dataC.begin(), dataC.end(), avg);

to average across a number of different data-sets.

Note that almost all STL algorithms/containers that accept functors require them to be “pure” predicates, i.e. have no observable change in state over time. for_each is a special case in this regard (see e.g. Effective Standard C++ Library – for_each vs. transform).

Performance

Functors can often be inlined by the compiler (the STL is a bunch of templates, after all). Whilst the same is theoretically true of functions, compilers typically won’t inline through a function pointer. The canonical example is to compare std::sort vs qsort; the STL version is often 5-10x faster, assuming the comparison predicate itself is simple.

Summary

Of course, it’s possible to emulate the first three with traditional functions and pointers, but it becomes a great deal simpler with functors.

More Related Contents:

  1. How do I specify a pointer to an overloaded function?
  2. C++ std::set update is tedious: I can’t change an element in place
  3. How to overload std::swap()
  4. Alternative to vector
  5. Best way to extract a subvector from a vector?
  6. Is there any real risk to deriving from the C++ STL containers?
  7. maximum value of int
  8. How to avoid memory leaks when using a vector of pointers to dynamically allocated objects in C++?
  9. how to provide a swap function for my class?
  10. How can I create my own comparator for a map?
  11. GCC STL bound checking
  12. comparing iterators from different containers
  13. Does vector::erase() on a vector of object pointers destroy the object itself?
  14. How to reuse an ostringstream?
  15. Inspecting standard container (std::map) contents with gdb
  16. Is the order of iterating through std::map known (and guaranteed by the standard)?
  17. Why can’t I write to a string literal while I *can* write to a string object?
  18. Multidimensional std::array [duplicate]
  19. Why can’t I define a function inside another function?
  20. Advantages of std::for_each over for loop
  21. C++ equivalent of StringBuffer/StringBuilder?
  22. passing functor as function pointer
  23. STL Rope – when and where to use
  24. How to downsize std::vector?
  25. C++ convert vector to vector
  26. Why doesn’t std::string provide implicit conversion to char*?
  27. Getting a vector into a function that expects a vector
  28. Using std::map where V has no usable default constructor
  29. General use cases for C++ containers
  30. Syntax for using std::greater when calling std::sort in C++

Leave a Comment