Question

What is the problem with this code ? this code is giving me lots of syntax errors. Also I would like to know why functors are used in C++.

class f
{
public:
    int operator(int a) {return a;}
} obj;

int main()
{
    cout << obj(0) << endl;
}

Answer 1

You’re missing an extra pair of parenthesis when declaring operator(). The name of the function is operator(), and it still needs the list of parameters after it. Thus it should look like:

int operator()(int a) {return a;}

Function objects (a.k.a. functors) like this are typically used where you’d use a pointer to a function. However, they have the advantage that they can use inheritance and they encapsulate state as well. Often, well designed class or function templates will be able to use them almost interchangeably with function pointers. However, a good optimizer can typically produce better code when a template object is used.

For a fairly sophisticated example of how you might use function objects, have a look at expression templates.

Here’s a small, somewhat contrived example of how they can use inheritance:

struct unary_int_func {
    virtual int operator()(int i) = 0;
};
struct negate : public unary_int_func {
    int operator()(int i) {return -i;}
};
struct one_plus : public unary_int_func {
    int operator()(int i) {return i+1;}
};

void show_it(unary_int_func &op, int v) {
    cout << op(v) << endl;
}

In this case, we create a base class with the operator as a pure virtual function. Then we derive to concrete classes that implement it. Code such as show_it() can then use any instance of a class derived from this base. While we could just have used a pointer to a function that takes an int and returns an int, this is more typesafe. Code that uses the function pointer would accept any such function pointer, whereas this way we can define a whole new hierarchy that maps an int to an int:

struct a_different_base_class {
    virtual int operator()(int i) = 0;
};

but instances of this would not be interchangeable with instances of unary_int_func.

As for state, consider a running sum function:

struct running_sum : public unary_int_func {
    int total;
    running_sum() : total(0) {}
    int operator()(int i) {return total += i;}
};

int main()
{
    running_sum s;
    cout << s(1) << endl;
    cout << s(2) << endl;
    cout << s(3) << endl;
    cout << s(4) << endl;
}

Here, the instance of running_sum keeps track of the total. It will print out 1, 3, 6 and 10. Pointers to functions have no such way of keeping state between distinct invocations. SGI’s STL page on function objects has a similar example to my running sum one, but shows how you can easily apply it to a range of elements in a container.