[ новости /+++ | форум | теги | ]

                       Standard C++ Library
             Copyright 1998, 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 included in 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,  in  other  words, 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:

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

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

       binder2nd(const Operation&,
                 const typename
                 Operation::second_argument_type&);
       typename Operation::result_type operator()
                (const typename Operation::first_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>
     using namespace std;
     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;

      }

     Program Output



     3 3 3



WARNINGS
     If your compiler does not support default  template  parame-
     ters,  then you always need to supply the Allocator template
     argument. For instance, you have to write:

     vector<int,allocator<int> >

     instead of:

     vector<int>

     If your compiler does not support namespaces,  then  you  do
     not need the using declaration for std.



SEE ALSO
     Function_Objects

Партнёры:

Хостинг: