Introduction

This article describes a simple STL function object. A function object is a way to create a function that
maintains state. This is especially useful in sorting situations where a simple less-than or greater-than comparison
just won't do.

std::sort

Like C's ancient qsort function, the STL std::sort function can accept a comparison function as
one of its parameters. This comparison function is called by the sort function when it needs to compare two values
from the array. A typical STL comparison function is:

The other 1%

What if you need to sort the array based on information that isn't in either of the two objects, as might happen
if the comparison needs access to some other non-global variable; or what if you want to sort one array based on the
contents of another array? You could, of course, do this with global variables, but that's not nice. A function
object, of course, can help you do it in a nice OO/C++ manner.

binary_function

A binary_function is a template that, in effect, allows you to define a class that can act as a binary operator - it
accepts two inputs of type A and B and returns a single output of type C. It acts as a class, but also as a function,
when used in functions such as std::sort. So, you can store things in the class, and use it to perform comparisons
(or any binary operation, really) like the compare_myObjects function above.

Sorting one array based on another

For the following example, we have two vectors: one vector is an array of employee objects;
the other is an array of integers. The array of integers is an array of indexes into the first array and we'll sort
these based on the objects in the employee array. Assume there's some good reason why we can't just sort the
employee array itself, like maybe it's been sorted already and we don't want to destroy its current order.

First, an employee:

class employee
{
public:
int m_salary;
string m_name;
};

Second, a binary function:

// this is our function object class.
// it holds a reference to a vector of employees.
class employeecomp : public std::binary_function<int,int,bool>
{
// the vector reference
const vector<employee> &m_employees;
public:
// constructor which takes a reference to a vector of employees
employeecomp( const vector<employee> & employees ) : m_employees(employees) {}
// comparison operator. this will be called by std::sort with two
// integers. we'll perform a comparison operation on the inputs and
// return the result of the comparison.
bool operator()(int a, int b) const
{
// a typical comparison operator compares the two input parameters.
// this one uses the two input parameters as indexes into the m_employees vector.
return (m_employees.at(a).m_salary) <(m_employees.at(b).m_salary);}};

Sort! This is where it all comes together. The first two parameters are the start and end of the vector we
wish to sort. The third parameter is known as the 'predicate'. In this case, the predicate is an employeecomp
object that we're initializing with the employee vector. For every comparison that std::sort needs to do, it
will call Pr(x,y), where Pr is the comparison function. In this case the comparison function is the
"()" operator of the employeecomp object; x and y are two items from indexVector.

...the results:

As you can see, the indexVector has changed. But what did it change to? The values in indexVector now
show the indexes of the items in employeeVector, sorted by increasing salary. And, though I didn't show it
here, the employeeVector was not modified at all.

This is a very basic example of what a function operator can do. Still, it's a technique that can be extremely
useful in some situations. Because the binary_function template creates a fully functional class, there is no
limit to the amount of complexity you can add to it (sort a vector of function objects, for example). Also,
this technique isn't limited to std::sort; you can use it in many of the STL algorithms.

Enjoy responsibly.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.