binder1st man page on Solaris

Man page or keyword search:  
man Server   20652 pages
apropos Keyword Search (all sections)
Output format
Solaris logo
[printable version]

bind1st(3C++)			       -			 bind1st(3C++)

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 parameters, 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

Rogue Wave Software		  02 Apr 1998			 bind1st(3C++)
[top]

List of man pages available for Solaris

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net