mem_fun_ref1 man page on OpenIndiana

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

mem_fun(3C++)			       -			 mem_fun(3C++)

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

NAME
       mem_fun, mem_fun1, mem_fun_ref, mem_fun_ref1

	-  Function objects that adapt a pointer to a member function, to take
       the place of a global function.

SYNOPSIS
       #include <functional>
       template <class S, class T> class mem_fun_t;
       template <class S, class T, class A> class mem_fun1_t;
       template <class S, class T> class mem_fun_ref_t;
       template <class S, class T, class A> class mem_fun1_ref_t;

       template <class S, class T> class const_mem_fun_t;
       template <class S, class T, class A> class const_mem_fun1_t;
       template <class S, class T> class const_mem_fun_ref_t;
       template <class S, class T, class A>
	 class const_mem_fun1_ref_t;

template<;class S, class T> mem_fun_t<S,T>
  mem_fun(S, (T::*f)());
template<;class S, class T, class A> mem_fun1_t<S,T,A>
  mem_fun1(S, (T::*f)(A));
template<;class S, class T> mem_fun_ref_t<S,T>
  mem_fun_ref(S, (T::*f)());
template<;class S, class T, class A> mem_fun1_ref_t<S,T,A>
  mem_fun1_ref(S, (T::*f)(A));

template<;class S, class T> const_mem_fun_t<S,T>
  mem_fun(S, (T::*f)() const);
template<;class S, class T, class A> const_mem_fun1_t<S,T,A>
  mem_fun1(S, (T::*f)(A) const);
template<;class S, class T> const_mem_fun_ref_t<S,T>
  mem_fun_ref(S, (T::*f)() const);
template<;class S, class T, class A>
  const_mem_fun1_ref_t<S,T,A>
  mem_fun1_ref(S, (T::*f)(A) const);

DESCRIPTION
       The mem_fun_group of templates encapsulates a pointer to a member func‐
       tion.  Each  category  of  template (mem_fun, mem_fun1, mem_fun_ref, or
       mem_fun1_ref) includes both a class template and a  function  template,
       where  the  class  is distinguished by the addition of _t on the end of
       the name to identify it as a type. A set of class templates  for	 const
       member functions exists, each with const_ prepended to the name.

       The  class's constructor takes a pointer to a member function, and uses
       an operator() to forward the call to that member function. In this  way
       the resulting object serves as a global function object for that member
       function.

       The accompanying function template simplifies the use of this  facility
       by constructing an instance of the class on the fly.

       The  library  includes zero and one argument adaptors for containers of
       pointers and containers of references (_ref).  This  technique  can  be
       easily  extended to include adaptors for two argument functions, and so
       on.

INTERFACE
template <;class S, class T> class mem_fun_t
	  : public unary_function<T*, S> {
   public:
     explicit mem_fun_t(S (T::*p)());
     S operator()(T* p) const;
};

template <;class S, class T, class A> class mem_fun1_t
	  : public binary_function<T*, A, S> {
   public:
     explicit mem_fun1_t(S (T::*p)(A));
     S operator()(T* p, A x) const;
};

template<;class S, class T> mem_fun_t<S,T>
  mem_fun(S, (T::*f)());

template<;class S, class T, class A> mem_fun1_t<S,T,A>
   mem_fun1(S, (T::*f)(A));

template <;class S, class T> class mem_fun_ref_t
	  : public unary_function<T, S> {
   public:
     explicit mem_fun_ref_t(S (T::*p)());
     S operator()(T* p) const;
};

template <;class S, class T, class A> class mem_fun1_ref_t
	  : public binary_function<T, A, S> {
   public:
     explicit mem_fun1_ref_t(S (T::*p)(A));
     S operator()(T* p, A x) const;
};
template<;class S, class T> mem_fun_ref_t<S,T>
    mem_fun_ref(S, (T::*f)());
template<;class S, class T, class A> mem_fun1_ref_t<S,T,A>
    mem_fun1_ref(S, (T::*f)(A));

// For const member functions

template <;class S, class T> class const_mem_fun_t
	  : public unary_function<T*, S> {
   public:
     explicit const_mem_fun_t(S (T::*p)() const);
     S operator()(T* p) const;
};

template <;class S, class T, class A> class const_mem_fun1_t
	  : public binary_function<T*, A, S> {
   public:
     explicit const_mem_fun1_t(S (T::*p)(A) const);
     S operator()(T* p, A x) const;
};

template<;class S, class T> const_mem_fun_t<S,T>
  mem_fun(S, (T::*f)() const);

template<;class S, class T, class A> const_mem_fun1_t<S,T,A>
   mem_fun1(S, (T::*f)(A) const);

template <;class S, class T> class const_mem_fun_ref_t
	  : public unary_function<T, S> {
   public:
     explicit const_mem_fun_ref_t(S (T::*p)() const);
     S operator()(T* p) const;
};

template <;class S, class T, class A>
	 class const_mem_fun1_ref_t
	  : public binary_function<T, A, S> {
   public:
     explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
     S operator()(T* p, A x) const;
};
template<;class S, class T> const_mem_fun_ref_t<S,T>
    mem_fun_ref(S, (T::*f)() const);
template<;class S, class T, class A>
    const_mem_fun1_ref_t<S,T,A>
    mem_fun1_ref(S, (T::*f)(A) const);

EXAMPLE
//
// mem_fun example
//

#include <functional>
#include <list>
using namespace std;

int main(void)
{
 int a1[] = {2,1,5,6,4};
 int a2[] = {11,4,67,3,14};
 list<int> s1(a1,a1+5);
 list<int> s2(a2,a2+5);

  // Build a list of lists
 list<list<int>* > l;
 l.insert(l.begin(),s1);
 l.insert(l.begin(),s2);

  // Sort each list in the list
 for_each(l.begin(),l.end(),mem_fun(&list<int>::sort));
}

SEE ALSO
       binary_function, Function_Objects, pointer_to_unary_function, ptr_fun

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

List of man pages available for OpenIndiana

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