## mem_fun, mem_fun1, mem_fun_ref, mem_fun_ref1

    Function Adaptors

- Summary
- Data Type and Member Function Indexes
- Synopsis
- Description
- Interface
- Example
- See Also

### Summary

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

### Data Type and Member Function Indexes
(exclusive of constructors and destructors)

None

### 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 function. 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

Copyright (c) 1998, Rogue Wave Software, Inc.
Send mail to report errors or comment on the documentation.
OEM Release, June 1998