The benefit of function objects?

Question

I have known that the function objects used in STL is just simple object that we can operator it like a function. That I can say the works of function and function objects is the same. If it's true, then why we should used function object rather than function?

Answer 1

The primary benefit is that calls to function objects (functors) are generally inlineable, where as calls to function pointers are generally not (prime example is comparing C's qsort to C++'s std::sort). For non-trivial objects/comparators, C++ should kill C's performance for sorting.

There are other benefits, for example you could possibly bind or store state in a functor, with which a raw function you cannot do.

Edit Apologies for no direct reference, but Scott Meyers claims 670% improvement under certain circumstances: Performance of qsort vs std::sort?

Edit 2 The passage with the performance note is this:

The fact that function pointer parameters inhibit inlining explains an observation that long-time C programmers often find hard to believe: C++’s sort virtually always embarrasses C’s qsort when it comes to speed. Sure, C++ has function and class templates to instantiate and funny-looking operator() functions to invoke while C makes a simple function call, but all that C++ “overhead” is absorbed during compilation. At runtime, sort makes inline calls to its comparison function (assuming the comparison function has been declared inline and its body is available during compilation) while qsort calls its comparison function through a pointer. The end result is that sort runs faster. In my tests on a vector of a million doubles, it ran up to 670% faster, but don’t take my word for it, try it yourself. It’s easy to verify that when comparing function objects and real functions as algorithm parameters, there’s an abstraction bonus.

-Scott Meyers "Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library" - Item 46

Answer 2

The benefit of a function object over a function is that it can hold state (from wikipedia):

#include <iostream>
#include <iterator>
#include <algorithm>

class CountFrom {
private:
  int &count;
public:
  CountFrom(int &n) : count(n) {}
  int operator()() { return count++; }
};

int main() {
  int state(10);
  std::generate_n(std::ostream_iterator<int>(std::cout, "\n"), 11, CountFrom(state));
  return 0;
}

A regular function cannot hold state like a function object. If I remember correctly it was the way of getting around not having lambdas and closures (before C++11 wikipedia section)...

Answer 3

I think that the best thing about functors are that they can store information internally. Back in those days without std::bind, one would have to write lots of unary comparison functions so that it can be passed to certain routines like remove_if.

Answer 4

See http://cs.stmarys.ca/~porter/csc/ref/stl/function_objects.html.

STL uses function objects (functors) as a callback for sorting/searching containers. Functors are templates and thus easier to implement as classes. Try saying greater<T> with a function pointer... considering that containers in STL are templates, too.