| United States |
|
|
|
Function_Objects
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
Function_Objects - Objects with an operator() defined. Function objects are used in place of pointers to functions as arguments to templated algorithms.
SYNOPSIS
#include<functional>
// typedefs
template <class Arg, class Result> struct unary_function;
template <class Arg1, class Arg2, class Result> struct binary_function;
DESCRIPTION Function objects are objects with an operator() defined. They are important for the effective use of the standard library's generic algorithms, because the interface for each algorithmic template can accept either an object with an operator() defined, or a pointer to a function. The Standard C++ Library provides both a standard set of function objects, and a pair of classes that you can use as the base for creating your own function objects.
Function objects that take one argument are called unary function objects. Unary function objects are required to provide the typedefs argument_type and result_type. Similarly, function objects that take two arguments are called binary function objects and, as such, are required to provide the typedefs first_argument_type, second_argument_type, and result_type.
The classes unary_function and binary_function make the task of c reating templated function objects easier. The necessary typedefs for a unary or binary function object are provided by inheriting from the appropriate function object class.
The function objects provided by 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.h>
//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; }
Output : The 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 need to always supply the Allocator template argument. For instance, you'll have to write :
vector<int, allocator<int> > and deque<int, allocator<int> > instead of :
vector<int> and deque<int>
SEE ALSO
binary_function, unary_function
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
divides
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
divides - Returns the result of dividing its first argument by its second.
SYNOPSIS
#include <functional>
template <class T> struct divides;
DESCRIPTION
divides is a binary function object. Its operator() returns the result of dividing x by y. You can pass a divides object to any algorithm that requires a binary function. For example, the transform algorithm applies a binary operation to corresponding values in two collections and stores the result. divides would be used in that algorithm in the following manner:
vector<int> vec1; vector<int> vec2; vector<int> vecResult; transform(vec1.begin(), vec1.end(), vec2.begin(), vecResult.begin(), divides<int>()); After this call to transform, vecResult[n] will contain vec1[n] divided by vec2[n].
INTERFACE
template <class T> struct divides : binary_function<T, T, T> { typedef typename binary_function<T, T, T>::second_argument_type second_argument_type; typedef typename binary_function<T, T, T>::first_argument_type first_argument_type; typedef typename binary_function<T, T, T>::result_type result_type;
T operator() (const T&, const T&) const; };
binary_function, function objects
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
less
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
less - Binary function object that returns true if its first argument is less than its second
SYNOPSIS
#include<functional>
template <class T> struct less : public binary_function<T, T, bool> ;
DESCRIPTION
less is a binary function object. Its operator() returns true if x is less than y. You can pass a less object to any algorithm that requires a binary function. For example, the transform algorithm applies a binary operation to corresponding values in two collections and stores the result of the function. less would be used in that algorithm in the following manner:
vector<int> vec1; vector<int> vec2; vector<int> vecResult; transform(vec1.begin(), vec1.end(), vec2.begin(), vecResult.begin(), less<int>());
After this call to transform, vecResult(n) will contain a "1" if vec1(n) was less than vec2(n) or a "0" if vec1(n) was greater than or equal to vec2(n).
INTERFACE
template <class T> struct less : binary_function<T, T, bool> { typedef typename binary_function<T, T, bool>::second_argument_type second_argument_type; typedef typename binary_function<T, T, bool>::first_argument_type first_argument_type; typedef typename binary_function<T, T, bool>::result_type result_type; bool operator() (const T&, const T&) const; };
WARNING
If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you'll have to write :
vector<int, allocator<int> >
instead of
vector<int>
SEE ALSO
binary_function, function objects
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
less_equal
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
less_equal - Binary function object that returns true if its first argument is less than or equal to its second
SYNOPSIS
#include<functional>
template <class T> struct less_equal : public binary_function<T, T, bool>;
DESCRIPTION
less_equal is a binary function object. Its operator() returns true if x is less than or equal to y. You can pass a less_equal object to any algorithm that requires a binary function. For example, the sort algorithm can accept a binary function as an alternate comparison object to sort a sequence. less_equal would be used in that algorithm in the following manner:
vector<int> vec1; sort(vec1.begin(), vec1.end(),less_equal<int>());
After this call to sort, vec1 will be sorted in ascending order.
INTERFACE
template <class T> struct less_equal : binary_function<T, T, bool> { typedef typename binary_function<T, T, bool>::second_argument_type second_argument_type; typedef typename binary_function<T, T, bool>::first_argument_type first_argument_type; typedef typename binary_function<T, T, bool>::result_type result_type; bool operator() (const T&, const T&) const; };
WARNING
If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you'll have to write :
vector<int, allocator<int> >
instead of
vector<int>
SEE ALSO
binary_function, function objects
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
logical_and
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
logical_and - Binary function object that returns true if both of its arguments are true.
SYNOPSIS
#include <functional>
template <class T> struct logical_and : public binary_function<T, T, bool>;
DESCRIPTION
logical_and is a binary function object. Its operator() returns true if both x and y are true. You can pass a logical_and object to any algorithm that requires a binary function. For example, the transform algorithm applies a binary operation to corresponding values in two collections and stores the result of the function. logical_and is used in that algorithm in the following manner:
vector<bool> vec1; vector<bool> vec2; vector<bool> vecResult; transform(vec1.begin(), vec1.end(), vec2.begin(), vecResult.begin(), logical_and<bool>());
After this call to transform, vecResult(n) will contain a "1" (true) if both vec1(n) and vec2(n) are true or a "0" (false) if either vec1(n) or vec2(n) is false.
INTERFACE
template <class T> struct logical_and : binary_function<T, T, bool> { typedef typename binary_function<T, T, bool>::second_argument_type second_argument_type; typedef typename binary_function<T, T, bool>::first_argument_type first_argument_type; typedef typename binary_function<T, T, bool>::result_type result_type; bool operator() (const T&, const T&) const; };
WARNING
If your compiler does not support default template parameters, you will need to always supply the Allocator template argument. For instance, you will have to write :
vector<bool, allocator<bool> >
instead of:
vector<bool>
SEE ALSO
binary_function, function objects
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
logical_not
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
logical_not - Unary function object that returns true if its argument is false.
SYNOPSIS
#include <functional>
template <class T> struct logical_not : unary_function<T, bool> ;
DESCRIPTION
logical_not is a unary function object. Its operator() returns true if its argument is false. You can pass a logical_not object to any algorithm that requires a unary function. For example, the replace_if algorithm replaces an element with another value if the result of a unary operation is true. logical_not is used in that algorithm in the following manner:
vector<int> vec1; void replace_if(vec1.begin(), vec1.end(), logical_not<int>(),1);
This call to replace_if replaces all zeros in the vec1 with "1".
INTERFACE
template <class T> struct logical_not : unary_function<T, bool> { typedef typename unary_function<T, bool>::argument_type argument_type; typedef typename unary_function<T, bool>::result_type result_type; bool operator() (const T&) const; };
WARNING
If your compiler does not support default template parameters, you will need to always supply the Allocator template argument. For instance, you will have to write :
vector<int, allocator<int> >
instead of :
vector<int>
SEE ALSO
function objects, unary_function
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
logical_or
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
logical_or - Binary function object that returns true if either of its arguments are true.
SYNOPSIS
#include <functional>
template <class T> struct logical_or : binary_function<T, T, bool> ;
DESCRIPTION
logical_or is a binary function object. Its operator() returns true if either x or y are true. You can pass a logical_or object to any algorithm that requires a binary function. For example, the transform algorithm applies a binary operation to corresponding values in two collections and stores the result of the function. logical_or is used in that algorithm in the following manner:
vector<bool> vec1; vector<bool> vec2; vector<bool> vecResult; transform(vec1.begin(), vec1.end(), vec2.begin(), vecResult.begin(), logical_or<bool>());
After this call to transform, vecResult(n) will contain a "1" (true) if either vec1(n) or vec2(n) is true or a "0" (false) if both vec1(n) and vec2(n) are false.
INTERFACE
template <class T> struct logical_or : binary_function<T, T, bool> { typedef typename binary_function<T, T, bool>::second_argument_type second_argument_type; typedef typename binary_function<T, T, bool>::first_argument_type first_argument_type; typedef typename binary_function<T, T, bool>::result_type result_type; bool operator() (const T&, const T&) const; };
WARNING
If your compiler does not support default template parameters, you will need to always supply the Allocator template argument. For instance, you will have to write :
vector<bool, allocator<bool> >
instead of:
vector<bool>
SEE ALSO
binary_function, function objects
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
minus
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
minus - Returns the result of subtracting its second argument from its first.
SYNOPSIS
#include<functional>
template <class T> struct minus : public binary_function<T, T, T>;
DESCRIPTION
minus is a binary function object. Its operator() returns the result of x minus y. You can pass a minus object to any algorithm that requires a binary function. For example, the transform algorithm applies a binary operation to corresponding values in two collections and stores the result. minus would be used in that algorithm in the following manner:
vector<int> vec1; vector<int> vec2; vector<int> vecResult; transform(vec1.begin(), vec1.end(), vec2.begin(), vecResult.begin(), minus<int>());
After this call to transform, vecResult(n) will contain vec1(n) minus vec2(n).
INTERFACE
template <class T> struct minus : binary_function<T, T, T> { typedef typename binary_function<T, T, T>::second_argument_type second_argument_type; typedef typename binary_function<T, T, T>::first_argument_type first_argument_type; typedef typename binary_function<T, T, T>::result_type result_type; T operator() (const T&, const T&) const; };
WARNING
If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will have to write :
vector<int, allocator<int> >
instead of :
vector<int>
SEE ALSO
binary_function, function objects
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
modulus
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
modulus - Returns the remainder obtained by dividing the first argument by the second argument.
SYNOPSIS
#include<functional>
template <class T> struct modulus : public binary_function<T, T, T> ;
DESCRIPTION
modulus is a binary function object. Its operator() returns the remainder resulting from of x divided by y. You can pass a modulus object to any algorithm that requires a binary function. For example, the transform algorithm applies a binary operation to corresponding values in two collections and stores the result. modulus would be used in that algorithm in the following manner:
vector<int> vec1; vector<int> vec2; vector<int> vecResult; transform(vec1.begin(), vec1.end(), vec2.begin(), vecResult.begin(), modulus<int>());
After this call to transform, vecResult(n) will contain the remainder of vec1(n) divided by vec2(n).
INTERFACE
template <class T> struct modulus : binary_function<T, T, T> { typedef typename binary_function<T, T, T>::second_argument_type n second_argument_type; typedef typename binary_function<T, T, T>::first_argument_type first_argument_type; typedef typename binary_function<T, T, T>::result_type result_type; T operator() (const T&, const T&) const; };
WARNING
If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :
vector<int, allocator<int> >
instead of
vector<int>
SEE ALSO
binary_function, function object
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
multiplies
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
multiplies - A binary function object that returns the result of multiplying its first and second arguments.
SYNOPSIS
#include<functional>
template <class T> struct multiplies : binary_function<T, T, T> { typedef typename binary_function<T, T, T>::second_argument_type second_argument_type; typedef typename binary_function<T, T, T>::first_argument_type first_argument_type; typedef typename binary_function<T, T, T>::result_type result_type; T operator() (const T&, const T&) const; };
DESCRIPTION
multiplies is a binary function object. Its operator() returns the result of multiplying x and y. You can pass a multiplies object to any algorithm that uses a binary function. For example, the transform algorithm applies a binary operation to corresponding values in two collections and stores the result. multiplies would be used in that algorithm in the following manner:
vector<int> vec1; vector<int> vec2; vector<int> vecResult; transform(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), vecResult.begin(), multiplies<int>());
After this call to transform, vecResult(n) will contain vec1(n) times vec2(n).
WARNING
If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will have to write :
vector<int, allocator<int> >
instead of :
vector<int>
SEE ALSO
binary_function, function objects
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
negate
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
negate - Unary function object that returns the negation of its argument.
SYNOPSIS
#include <functional>
template <class T> struct negate : public unary_function<T, T>;
DESCRIPTION
negate is a unary function object. Its operator() returns the negation of its argument, i.e., true if its argument is false, or false if its argument is true. You can pass a negate object to any algorithm that requires a unary function. For example, the transform algorithm applies a unary operation to the values in a collection and stores the result. negate could be used in that algorithm in the following manner:
vector<int> vec1; vector<int> vecResult; transform(vec1.begin(), vec1.end(), vecResult.begin(), negate<int>());
After this call to transform, vecResult(n) will contain the negation of the element in vec1(n).
INTERFACE
template <class T> struct negate : unary_function<T, T> { typedef typename unary_function<T,T>::argument_type argument_type; typedef typename unary_function<T,T>::result_type result_type; T operator() (const T&) const; };
WARNING
If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :
vector<int, allocator<int> >
instead of :
vector<int>
SEE ALSO
function objects, unary_function
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
Negators
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
Negators - Function adaptors and function objects used to reverse the sense of predicate function objects.
SYNOPSIS
#include <functional>
template <class Predicate> class unary_negate;
template <class Predicate> unary_negate<Predicate> not1(const Predicate&);
template <class Predicate> class binary_negate;
template <class Predicate> binary_negate<Predicate> not2(const Predicate&);
DESCRIPTION
Negators not1 and not2 are functions that take predicate function objects as arguments and return predicate function objects with the opposite sense. Negators work only with function objects defined as subclasses of the classes unary_function and binary_function. not1 accepts and returns unary predicate function objects. not2 accepts and returns binary predicate function objects.
unary_negate and binary_negate are function object classes that provide return types for the negators, not1 and not2.
INTERFACE
template <class Predicate> class unary_negate : public unary_function<typename Predicate::argument_type, bool> {
public: typedef typename unary_function<typename Predicate::argument_type, bool>::argument_type argument_type; typedef typename unary_function<typename Predicate::argument_type, bool>::result_type result_type; explicit unary_negate (const Predicate&); bool operator() (const argument_type&) const; };
template<class Predicate> unary_negate <Predicate> not1 (const Predicate&);
template<class Predicate> class binary_negate : public binary_function<typename Predicate::first_argument_type, typename Predicate::second_argument_type, bool> { public: typedef typename binary_function<typename Predicate::first_argument_type, typename Predicate::second_argument_type, bool>::second_argument_type second_argument_type; typedef typename binary_function<typename Predicate::first_argument_type, typename Predicate::second_argument_type, bool>::first_argument_type first_argument_type; typedef typename binary_function<typename Predicate::first_argument_type, typename Predicate::second_argument_type, bool>::result_type result_type; explicit binary_negate (const Predicate&); bool operator() (const first_argument_type&, const second_argument_type&) const; };
template <class Predicate> binary_negate<Predicate> not2 (const Predicate&);
EXAMPLE
// // negator.cpp // #include<functional> #include<algorithm> #include <iostream.h>
//Create a new predicate from unary_function template<class Arg> class is_odd : public unary_function<Arg, bool> { public: bool operator()(const Arg& arg1) const { return (arg1 % 2 ? true : false); } };
int main() { less<int> less_func;
// Use not2 on less cout << (less_func(1,4) ? "TRUE" : "FALSE") << endl; cout << (less_func(4,1) ? "TRUE" : "FALSE") << endl; cout << (not2(less<int>())(1,4) ? "TRUE" : "FALSE") << endl; cout << (not2(less<int>())(4,1) ? "TRUE" : "FALSE") << endl;
//Create an instance of our predicate is_odd<int> odd;
// Use not1 on our user defined predicate cout << (odd(1) ? "TRUE" : "FALSE") << endl; cout << (odd(4) ? "TRUE" : "FALSE") << endl; cout << (not1(odd)(1) ? "TRUE" : "FALSE") << endl; cout << (not1(odd)(4) ? "TRUE" : "FALSE") << endl;
return 0; } Output : TRUE FALSE FALSE TRUE TRUE FALSE FALSE TRUE
SEE ALSO
algorithm, binary_function, function_object, unary_function
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
not1
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
not1 - Function adaptor used to reverse the sense of a unary predicate function object.
SYNOPSIS
#include <functional>
template<class Predicate> unary_negate <Predicate> not1 (const Predicate&);
DESCRIPTION
not1 is a function adaptor, known as a negator, that takes a unary predicate function object as its argument and returns a unary predicate function object that is the complement of the original. unary_negate is a function object class that provides a return type for the not1 negator.
Note that not1 works only with function objects that are defined as subclasses of the class unary_function.
SEE ALSO
negators, not2, unary_function, unary_negate, pointer_to_unary_function
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
not2
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
not2 - Function adaptor used to reverse the sense of a binary predicate function object.
SYNOPSIS
#include <functional>
template <class Predicate> binary_negate<Predicate> not2 (const Predicate& pred);
DESCRIPTION
not2 is a function adaptor, known as a negator, that takes a binary predicate function object as its argument and returns a binary predicate function object that is the complement of the original. binary_negate is a function object class that provides a return type for the not2 negator.
Note that not2 works only with function objects that are defined as subclasses of the class binary_function.
SEE ALSO
binary_function, binary_negate, negators, not1, pointer_to_binary_function, unary_negate
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
not_equal_to
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
not_equal_to - Binary function object that returns true if its first argument is not equal to its second.
SYNOPSIS
#include <functional>
template <class T> struct not_equal_to : public binary_function<T, T, bool> ;
DESCRIPTION
not_equal_to is a binary function object. Its operator() returns true if x is not equal to y. You can pass a not_equal_to object to any algorithm that requires a binary function. For example, the transform algorithm applies a binary operation to corresponding values in two collections and stores the result. not_equal_to would be used in that algorithm in the following manner:
vector<int> vec1; vector<int> vec2; vector<int> vecResult; transform(vec1.begin(), vec1.end(), vec2.begin(), vecResult.begin(), not_equal_to<int>());
After this call to transform, vecResult(n) will contain a "1" if vec1(n) was not equal to vec2(n) or a "1" if vec1(n) was equal to vec2(n).
INTERFACE
template <class T> struct not_equal_to : binary_function<T, T, bool> { typedef typename binary_function<T, T, bool>::second_argument_type second_argument_type; typedef typename binary_function<T, T, bool>::first_argument_type first_argument_type; typedef typename binary_function<T, T, bool>::result_type result_type; bool operator() (const T&, const T&) const; };
WARNING
If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will need to write :
vector<int, allocator<int> >
instead of :
vector<int>
SEE ALSO
binary_function, function object
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
plus
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
plus - A binary function object that returns the result of adding its first and second arguments.
SYNOPSIS
#include <functional>
template<class T> struct plus : public binary_function<T, T, T> ;
DESCRIPTION
plus is a binary function object. Its operator() returns the result of adding x and y. You can pass a plus object to any algorithm that uses a binary function. For example, the transform algorithm applies a binary operation to corresponding values in two collections and stores the result. plus would be used in that algorithm in the following manner:
vector<int> vec1; vector<int> vec2; vector<int> vecResult; transform(vec1.begin(), vec1.end(), vec2.begin(), vecResult.begin(), plus<int>());
After this call to transform, vecResult(n) will contain vec1(n) plus vec2(n).
INTERFACE
template<class T> struct plus : binary_function<T, T, T> { typedef typename binary_function<T, T, T>::second_argument_type second_argument_type; typedef typename binary_function<T, T, T>::first_argument_type first_argument_type; typedef typename binary_function<T, T, T>::result_type result_type; T operator() (const T&, const T&) const; };
WARNING
If your compiler does not support default template parameters, you need to always supply the Allocator template argument. For instance, you will need to write:
vector<int, allocator<int> >
instead of :
vector<int>
SEE ALSO
binary_function, function objects
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
Predicates
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
Predicates - A function or a function object that returns a boolean (true/false) value or an integer value.
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
times
Standard C++ LibraryNAME
times - A binary function object that returns the result of multiplying its first and second arguments.
SYNOPSIS
#include<functional>
template <class T> struct times : binary_function<T, T, T> { typedef typename binary_function<T, T, T>::second_argument_type second_argument_type; typedef typename binary_function<T, T, T>::first_argument_type first_argument_type; typedef typename binary_function<T, T, T>::result_type result_type; T operator() (const T&, const T&) const; };
DESCRIPTION
times is a binary function object. Its operator() returns the result of multiplying x and y. You can pass a times object to any algorithm that uses a binary function. For example, the transform algorithm applies a binary operation to corresponding values in two collections and stores the result. times would be used in that algorithm in the following manner:
vector<int> vec1;
vector<int> vec2; vector<int> vecResult; transform(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), vecResult.begin(), times<int>());
After this call to transform, vecResult(n) will contain vec1(n) times vec2(n).
WARNING
If your compiler does not support default template parameters, then you need to always supply the Allocator template argument. For instance, you will have to write :
vector<int, allocator>
instead of :
vector<int>
SEE ALSO
binary_function, function objects
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
unary_function
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
unary_function - Base class for creating unary function objects.
SYNOPSIS
#include <functional>
template <class Arg, class Result> struct unary_function{ typedef Arg argument_type; typedef Result result_type; };
DESCRIPTION
Function objects are objects with an operator() defined. They are important for the effective use of the standard library's generic algorithms, because the interface for each algorithmic template can accept either an object with an operator() defined or a pointer to a function. The standard library provides both a standard set of function objects, and a pair of classes that you can use as the base for creating your own function objects.
Function objects that take one argument are called unary function objects. Unary function objects are required to provide the typedefs argument_type and result_type. The unary_function class makes the task of creating templated unary function objects easier by providing the necessary typedefs for a unary function object. You can create your own unary function objects by inheriting from unary_function.
SEE ALSO
function objects, and Function Objects Section in User's Guide.
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
unary_negate
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
unary_negate - Function object that returns the complement of the result of its unary predicate
SYNOPSIS
#include<functional>
template <class Predicate> class unary_negate : public unary_function<typename Predicate::argument_type, bool>;
DESCRIPTION
unary_negate is a function object class that provides a return type for the function adapter not1. not1 is a function adapter, known as a negator, that takes a unary predicate function object as its argument and returns a unary predicate function object that is the complement of the original.
Note that not1 works only with function objects that are defined as subclasses of the class unary_function.
INTERFACE
template <class Predicate> class unary_negate : public unary_function<Predicate::argument_type, bool> { typedef typename unary_function<typename Predicate::argument_type,bool>::argument_type argument_type; typedef typename unary_function<typename Predicate::argument_type,bool>::result_type result_type; public: explicit unary_negate (const Predicate&); bool operator() (const argument_type&) const; };
template<class Predicate> unary_negate <Predicate> not1 (const Predicate&);
CONSTRUCTOR
explicit unary_negate(const Predicate& pred); Construct a unary_negate object from predicate pred.
OPERATOR
bool operator()(const argument_type& x) const; Return the result of pred(x)
SEE ALSO
not1, not2, unary_function, binary_negate
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
binary_function
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
binary_function - Base class for creating binary function objects.
SYNOPSIS
#include <functional>
template <class Arg1, class Arg2, class Result> struct binary_function{ typedef Arg1 first_argument_type; typedef Arg2 second_argument_type; typedef Result result_type; };
DESCRIPTION
Function objects are objects with an operator() defined. They are important for the effective use of the standard library's generic algorithms, because the interface for each algorithmic template can accept either an object with an operator() defined or a pointer to a function. The Standard C++ Library provides both a standard set of function objects, and a pair of classes that you can use as the base for creating your own function objects.
Function objects that take two arguments are called binary function objects. Binary function objects are required to provide the typedefs first_argument_type, second_argument_type, and result_type. The binary_function class makes the task of creating templated binary function objects easier by providing the necessary typedefs for a binary function object. You can create your own binary function objects by inheriting from binary_function.
SEE ALSO
function objects_ unary_function, the Function Objects section of the User's Guide.
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
binary_negate
Standard C++ Library Copyright 1996, Rogue Wave Software, Inc.NAME
binary_negate - Function object that returns the complement of the result of its binary predicate
SYNOPSIS
#include <functional>
template<class Predicate> class binary_negate ;
DESCRIPTION
binary_negate is a function object class that provides a return type for the function adaptor not2. not2 is a function adaptor, known as a negator, that takes a binary predicate function object as its argument and returns a binary predicate function object that is the complement of the original.
Note that not2 works only with function objects that are defined as subclasses of the class binary_function.
INTERFACE
template<class Predicate> class binary_negate : public binary_function<typename predicate::first_argument_type, typename Predicate::second_argument_type, bool> { public:
typedef typename binary_function<typename Predicate::first_argument_type, typename Predicate::second_argument_type, bool>::second_argument_type second_argument_type; typedef typename binary_function<typename Predicate::first_argument_type, typename Predicate::second_argument_type, bool>::first_argument_type first_argument_type; typedef typename binary_function<typename Predicate::first_argument_type, typename Predicate::second_argument_type, bool>::result_type result_type;
explicit binary_negate (const Predicate&); bool operator() (const first_argument_type&, const second_argument_type&) const; };
// Non-member Functions
template <class Predicate> binary_negate<Predicate> not2 (const Predicate& pred);
CONSTRUCTOR
explicit binary_negate(const Predicate& pred); Construct a binary_negate object from predicate pred.
OPERATOR
bool operator()(const first_argument_type& x, const second_argument_type& y) const; Return the result of pred(x,y)
SEE ALSO
binary_function, not2, unary_negate
STANDARDS CONFORMANCE ANSI X3J16/ISO WG21 Joint C++ Committee
|
