C++ FAQ Celebrating Twenty-One Years of the C++ FAQ!!!
(Click here for a personal note from Marshall Cline.)
Section 33:
[33.15] What's the difference between a functionoid and a functor?

A functionoid is an object that has one major method. It's basically the OO extension of a C-like function such as printf(). One would use a functionoid whenever the function has more than one entry point (i.e., more than one "method") and/or needs to maintain state between calls in a thread-safe manner (the C-style approach to maintaining state between calls is to add a local "static" variable to the function, but that is horribly unsafe in a multi-threaded environment).

A functor is a special case of a functionoid: it is a functionoid whose method is the "function-call operator," operator()(). Since it overloads the function-call operator, code can call its major method using the same syntax they would for a function call. E.g., if "foo" is a functor, to call the "operator()()" method on the "foo" object one would say "foo()". The benefit of this is in templates, since then the template can have a template parameter that will be used as a function, and this parameter can be either the name of a function or a functor-object. There is a performance advantage of it being a functor object since the "operator()()" method can be inlined (whereas if you pass the address of a function it must, necessarily, be non-inlined).

This is very useful for things like the "comparison" function on sorted containers. In C, the comparison function is always passed by pointer (e.g., see the signature to "qsort()"), but in C++ the parameter can come in either as a pointer to function OR as the name of a functor-object, and the result is that sorted containers in C++ can be, in some cases, a lot faster (and never slower) than the equivalent in C.

Since Java has nothing similar to templates, it must use dynamic binding for all this stuff, and dynamic binding of necessity means a function call. Normally not a big deal, but in C++ we want to enable extremely high performance code. That is, C++ has a "pay for it only if you use it" philosophy, which means the language must never arbitrarily impose any overhead over what the physical machine is capable of performing (of course a programmer may, optionally, use techniques such as dynamic binding that will, in general, impose some overhead in exchange for flexibility or some other "ility", but it's up to the designer and programmer to decide whether they want the benefits (and costs) of such constructs).