Standard C++ LibraryCopyright 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



privacy and legal statement