Standard C++	Library
 		 Copyright 1996, Rogue Wave Software, Inc.

 NAME

   bind1st, bind2nd, binder1st, binder2nd  - Templatized	utilities to
   bind values to function objects

 SYNOPSIS

   #include <functional>

   template <class Operation>
   class	binder1st : public unary_function<typename
 		    Operation::second_argument_type,
 		    typename Operation::result_type> ;

   template <class Operation, class T>
   binder1st<Operation> bind1st (const Operation&, const	T&);

   template <class Operation>
   class	binder2nd : public unary_function<typename
 		    Operation::first_argument_type,
 		    typename Operation::result_type> ;

   template <class Operation, class T>
   binder2nd<Operation> bind2nd (const Operation&, const	T&);

 DESCRIPTION

   Because so many functions provided by	the standard library take
   other	functions	as arguments, the library includes classes
   that	let you	build new function objects out of old ones. Both
   bind1st() and bind2nd()  are functions	that take as arguments
   a binary	function object	f and a	value x, and return,
   respectively,	classes	binder1st and binder2nd.   The underlying
   function object must be a subclass of	binary_function.

   Class	binder1st binds	the value to the first argument	of the binary
   function,	and binder2nd does the same thing for the second
   argument  of the function.  The resulting classes can be used in
   place	of a unary  predicate in other function calls.

   For example, you could use the count_if algorithm to count all
   elements  in a vector that are less than or equal to 7,  using the
   following:

   count_if (v.begin, v.end, bind1st(greater<int> (),7),	littleNums)

   This function	adds one to littleNums each time the predicate is
   true,	i.e., each time 7 is greater than the element.

 INTERFACE

   // Class binder1st
   template <class Operation>
   class	binder1st
      : public unary_function<typename
 			    Operation::second_argument_type,
 			    typename Operation::result_type>
   {
   public:

     typedef typename unary_function<typename
      Operation::second_argument_type, typename
      Operation::result_type>::argument_type argument_type;
     typedef typename unary_function<typename
      Operation::second_argument_type, typename
      Operation::result_type>::result_type result_type;

     binder1st(const Operation&,
 	      const typename Operation::first_argument_type&);
     result_type	operator() (const argument_type&) const;
   };

   // Class binder2nd
   template <class Operation>
   class	binder2nd
      : public unary_function<typename
 			    Operation::first_argument_type,
 			    typename Operation::result_type>
   {
   public:
     typedef typename unary_function<typename
      Operation::first_argument_type, typename
      Operation::result_type>::argument_type argument_type;
     typedef typename unary_function<typename
      Operation::first_argument_type, typename
      Operation::result_type>::result_type result_type;

     binder2nd(const Operation&,
 	      const typename Operation::second_argument_type&);
     result_type	operator() (const argument_type&) const;
   };

   // Creator bind1st

     template <class Operation, class T>
     binder1st<Operation> bind1st (const	Operation&, const T&);

   // Creator bind2nd

     template<class Operation, class T>
     binder2nd <Operation> bind2nd(const	Operation&, const T&);

 EXAMPLE

   //
   // binders.cpp
   //
    #include <functional>
    #include <algorithm>
    #include <vector>
    #include <iostream.h>
   int main()
    {
     typedef vector<int>::iterator iterator;
     int	d1[4] =	{1,2,3,4};
      //
      //	Set up a vector
      //
     vector<int>	v1(d1,d1 + 4);
      //
      //	Create an 'equal to 3' unary predicate by binding 3 to
      //	the equal_to binary predicate.
      //
     binder1st<equal_to<int> > equal_to_3 =
        bind1st(equal_to<int>(),3);
      //
      //	Now use	this new predicate in a	call to	find_if
      //
     iterator it1 = find_if(v1.begin(),v1.end(),equal_to_3);
      //
      //	Even better, construct the new predicate on the	fly
      //
     iterator it2 =
        find_if(v1.begin(),v1.end(),bind1st(equal_to<int>(),3));
      //
      //	And now	the same thing using bind2nd
      //	Same result since == is	commutative
      //
     iterator it3 =
        find_if(v1.begin(),v1.end(),bind2nd(equal_to<int>(),3));
      //
      //	it3 = v1.begin() + 2
      //
      //	Output results
      //
     cout << *it1 << " "	<< *it2	<< " " << *it3 << endl;
     return 0;
    }

   Output : 3 3 3

 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> > instead of:

   vector<int>

 SEE ALSO

   Function Object

 STANDARDS CONFORMANCE
   ANSI X3J16/ISO WG21 Joint C++	Committee