Function_Objects(3C++) - Function_Objects(3C++)
Standard C++ Library Copyright 1998, Rogue Wave Software, Inc.
NAMEFunction_Objects
- Function objects are objects with an operator() defined. They are
used as arguments to templatized algorithms, in place of pointers to
functions.
SYNOPSIS
#include<functional>
DESCRIPTION
Function objects are objects with an operator() defined. They are
important for the effective use of the standard library's generic algo‐
rithms, because the interface for each algorithmic template can accept
either an object with an operator() defined, or a pointer to a func‐
tion. The Standard C++ Library includes both a standard set of function
objects, and a pair of classes that you can use as the base for creat‐
ing your own function objects.
Function objects that take one argument are called unary function
objects. Unary function objects must include the typedefs argument_type
and result_type. Similarly, function objects that take two arguments
are called binary function objects and, as such, must include the type‐
defs first_argument_type, second_argument_type, and result_type.
The classes unary_function and binary_function make the task of creat‐
ing templatized function objects easier. The necessary typedefs for a
unary or binary function object are included by inheriting from the
appropriate function object class.
The function objects in the standard library are listed below, together
with a brief description of their operation. This class reference also
includes an alphabetic entry for each function.
NAME OPERATION
arithmetic functions
plus addition x + y
minus subtraction x - y
multiplies multiplication x * y
divides division x / y
modulus remainder x % y
negate negation - x
comparison functions
equal_to equality test x == y
not_equal_to inequality test x != y
greater greater comparison x > y
less less-than comparison x < y
greater_equal greater than or equal comparison x >= y
less_equal less than or equal comparison x <= y
logical functions
logical_and logical conjunction x && y
logical_or logical disjunction x || y
logical_not logical negation ! x
INTERFACE
template <class Arg, class Result>
struct unary_function{
typedef Arg argument_type;
typedef Result result_type;
};
template <class Arg1, class Arg2, class Result>
struct binary_function{
typedef Arg1 first_argument_type;
typedef Arg2 second_argument_type;
typedef Result result_type;
};
// Arithmetic Operations
template<class T>
struct plus : binary_function<T, T, T> {
T operator() (const T&, const T&) const;
};
template <class T>
struct minus : binary_function<T, T, T> {
T operator() (const T&, const T&) const;
};
template <class T>
struct multiplies : binary_function<T, T, T> {
T operator() (const T&, const T&) const;
};
template <class T>
struct divides : binary_function<T, T, T> {
T operator() (const T&, const T&) const;
};
template <class T>
struct modulus : binary_function<T, T, T> {
T operator() (const T&, const T&) const;
};
template <class T>
struct negate : unary_function<T, T> {
T operator() (const T&) const;
};
// Comparisons
template <class T>
struct equal_to : binary_function<T, T, bool> {
bool operator() (const T&, const T&) const;
};
template <class T>
struct not_equal_to : binary_function<T, T, bool> {
bool operator() (const T&, const T&) const;
};
template <class T>
struct greater : binary_function<T, T, bool> {
bool operator() (const T&, const T&) const;
};
template <class T>
struct less : binary_function<T, T, bool> {
bool operator() (const T&, const T&) const;
};
template <class T>
struct greater_equal : binary_function<T, T, bool> {
bool operator() (const T&, const T&) const;
};
template <class T>
struct less_equal : binary_function<T, T, bool> {
bool operator() (const T&, const T&) const;
};
// Logical Comparisons
template <class T>
struct logical_and : binary_function<T, T, bool> {
bool operator() (const T&, const T&) const;
};
template <class T>
struct logical_or : binary_function<T, T, bool> {
bool operator() (const T&, const T&) const;
};
template <class T>
struct logical_not : unary_function<T, T, bool> {
bool operator() (const T&, const T&) const;
};
EXAMPLE
//
// funct_ob.cpp
//
#include<functional>
#include<deque>
#include<vector>
#include<algorithm>
#include <iostream>
using namespace std;
//Create a new function object from unary_function
template<class Arg>
class factorial : public unary_function<Arg, Arg>
{
public:
Arg operator()(const Arg& arg)
{
Arg a = 1;
for(Arg i = 2; i <= arg; i++)
a *= i;
return a;
}
};
int main()
{
//Initialize a deque with an array of ints
int init[7] = {1,2,3,4,5,6,7};
deque<int> d(init, init+7);
//Create an empty vector to store the factorials
vector<int> v((size_t)7);
//Transform the numbers in the deque to their factorials
//and store in the vector
transform(d.begin(), d.end(), v.begin(),
factorial<int>());
//Print the results
cout << "The following numbers: " << endl << " ";
copy(d.begin(),d.end(),
ostream_iterator<int,char>(cout," "));
cout << endl << endl;
cout << "Have the factorials: " << endl << " ";
copy(v.begin(),v.end(),
ostream_iterator<int,char>(cout," "));
return 0;
}
Program OutputThe following numbers:
1 2 3 4 5 6 7
Have the factorials:
1 2 6 24 120 720 5040
WARNINGS
If your compiler does not support default template parameters, then you
always need to supply the Allocator template argument. For instance,
you have to write:
vector<int, allocator<int> > and deque<int, allocator<int> >
instead of:
vector<int> and deque<int>
If your compiler does not support namespaces, then you do not need the
using declaration for std.
SEE ALSO
binary_function, unary_function
Rogue Wave Software 02 Apr 1998 Function_Objects(3C++)