Definition
A function pointer allows a pointer to a function to be passed as a parameter to another function. Functors (Function Objects) in C++ allows the function call operator() to be overloaded. It allows instantiated object of a class to be called like a function.
Advantages of functor compared to function pointer
- Functor fits into OOP paradigm as compared to function pointer.
- Unlike function pointer, functor can have state.
- A functor often may be inlined unlike function pointer.
- Calling the overloaded operator() can be more efficient than dereferencing a function pointer
Standard Functors
Basic functor concepts in STL:
- Generator : Functor with no arguments
- UnaryFunction: Functor with one argument
- BinaryFunction: Functor with two arguments
- UnaryPredicate: UnaryFunction returning bool
- BinaryPredicate: BinaryFunction returning bool
Standard library defines several adaptable function objects corresponding to common operators. For example,
- Comparison operators (binary predicates)
- equal_to, not_equal_to
- less, greater, less_equal, greater_equal
- Arithmetic operators
- plus, minus, multiplies, divides, modulus (binary functions)
- negate (unary function)
- Logical operators
- logical_not (unary predicate)
- logical_and, logical_or (binary predicates)
Many functions in the library, expects something like a function to be passed. For example signature of std::for_each
template< class InputIt, class UnaryFunction > UnaryFunction for_each( InputIt first, InputIt last, UnaryFunction f );
Type UnaryFunction is expected to be pass by value, and can be called like a function (f(value)). There are a couple things that satisfy this:
- Function pointers
- Functor objects, which are instances of a class that overloads operator()
- Lambdas (which are really just functor objects)
Example
Functors are objects that can be treated as though they are a function or function pointer. Below example creates a functor class with a constructor that takes an argument. When object of the class is called, it will return the result of adding the saved value and the argument to the functor.
#include <iostream>
class FunctorClass
{
public:
FunctorClass(int x)
: val(x) {
}
// Functor
double operator() (double y) {
return val + y;
}
private:
double val;
};
int main()
{
// Create object
FunctorClass obj(5);
// Call functor
// Output : 94
std::cout << obj(89);
return 0;
}In the below example, functor will be invoked for each element of the vector v, and prints out one by one after adding 10.
#include <iostream>
#include <vector>
#include <algorithm>
class FunctorSTL {
public:
FunctorSTL(int k) : val(k) {
}
void operator()(int i) {
std::cout << i + val << " ";
}
private:
int val;
};
int main(){
std::vector<int> v = { 1, 2, 3, 4, 5 };
int val = 10;
// Output: 11 12 13 14 15
for_each(v.begin(), v.end(), FunctorSTL(val));
}