# mem_fun1_ref_t<Result, X, Arg>

Categories: functors, adaptors | Component type: type

### Description

`Mem_fun1_ref_t` is an adaptor for member functions. If `X` is some class with a member function `Result X::f(Arg)` (that is, a member function that takes one argument of type `Arg` and that returns a value of type `Result` [1]), then a `mem_fun1_ref_t<Result, X, Arg>` is a function object adaptor that makes it possible to call `f` as if it were an ordinary function instead of a member function.

`Mem_fun1_ref_t<Result, X, Arg>`'s constructor takes a pointer to one of `X`'s member functions. Then, like all function objects, `mem_fun1_ref_t` has an `operator()` that allows the `mem_fun1_ref_t` to be invoked with ordinary function call syntax. In this case, `mem_fun1_ref_t`'s `operator()` takes two arguments; the first is of type `X` and the second is of type `Arg`.

If `F` is a `mem_fun1_ref_t` that was constructed to use the member function `X::f`, and if `x` is an object of type `X` and `a` is a value of type `Arg`, then the expression `F(x, a)` is equivalent to the expression `x.f(a)`. The difference is simply that `F` can be passed to STL algorithms whose arguments must be function objects.

`Mem_fun1_ref_t` is one of a family of member function adaptors. These adaptors are useful if you want to combine generic programming with inheritance and polymorphism, since, in C++, polymorphism involves calling member functions through pointers or references. In fact, though, `mem_fun1_ref_t` is usually not as useful as `mem_fun1_t`. The difference between the two is that `mem_fun1_t`'s first argument is a pointer to an object while `mem_fun1_ref_t`'s argument is a reference to an object. References, unlike pointers, can't be stored in STL containers: pointers are objects in their own right, but references are merely aliases.

As with many other adaptors, it is usually inconvenient to use `mem_fun1_ref_t`'s constructor directly. It is usually better to use the helper function `mem_fun_ref` [2] instead.

### Example

Given a vector of vectors, extract one element from each vector.

    int main() {
      int A1[5] = {1, 2, 3, 4, 5};
      int A2[5] = {1, 1, 2, 3, 5};
      int A3[5] = {1, 4, 1, 5, 9};

      vector<vector<int> > V;
      V.push_back(vector<int>(A1, A1 + 5));
      V.push_back(vector<int>(A2, A2 + 5));
      V.push_back(vector<int>(A3, A3 + 5));

      int indices[3] = {0, 2, 4};

      int& (vector<int>::*extract)(vector<int>::size_type);
      extract = vector<int>::operator[];
      transform(V.begin(), V.end(), indices,
                ostream_iterator<int>(cout, "\n"),
                mem_fun_ref(extract));
    }

### Definition

Defined in the standard header functional, and in the nonstandard backward-compatibility header function.h.

### Template parameters

Parameter | Description | Default
--- | --- | ---
`Result` | The member function's return type. |
`X` | The class whose member function the `mem_fun1_ref_t` invokes. |
`Arg` | The member function's argument type. |

### Model of

Adaptable Binary Function

### Type requirements

- `X` has at least one member function that takes a single argument of type `Arg` and that returns a value of type `Result`. [1]

### Public base classes

`binary_function<X, Arg, Result>`

### Members

Member | Where defined | Description
--- | --- | ---
`first_argument_type` | Adaptable Binary Function | The type of the first argument: `X`
`second_argument_type` | Adaptable Binary Function | The type of the second argument: `Arg`
`result_type` | Adaptable Binary Function | The type of the result: `Result`
    Result operator()(X& x, Arg a) const
| Binary Function | Function call operator. Invokes `x.f(a)`, where `f` is the member function that was passed to the constructor.
    explicit mem_fun1_ref_t(Result (X::*f)(Arg))
| `mem_fun1_ref_t` | See below.
    template <class Result, class X, class Arg>
    mem_fun1_ref_t<Result, X, Arg>
    mem_fun_ref(Result (X::*f)(Arg)); [2]
| `mem_fun1_ref_t` | See below.

### New members

These members are not defined in the Adaptable Binary Function requirements, but are specific to `mem_fun1_ref_t`.

Member | Description
--- | ---
    explicit mem_fun1_ref_t(Result (X::*f)(Arg))
| The constructor. Creates a `mem_fun1_ref_t` that calls the member function `f`.
    template <class Result, class X, class Arg>
    mem_fun1_ref_t<Result, X, Arg>
    mem_fun1_ref(Result (X::*f)(Arg)); [2]
| If `f` is of type `Result (X::*)(Arg)` then `mem_fun_ref(f)` is the same as `mem_fun1_ref_t<Result, X, Arg>(f)`, but is more convenient. This is a global function, not a member function.

### Notes

[1] The type `Result` is permitted to be `void`. That is, this adaptor may be used for functions that return no value. However, this presents implementation difficulties. According to the draft C++ standard, it is possible to return from a `void` function by writing `return void` instead of just `return`. At present, however (early 1998), very few compilers support that feature. As a substitute, then, `mem_fun1_ref_t` uses partial specialization to support `void` member functions. If your compiler has not implemented partial specialization, then you will not be able to use `mem_fun1_ref_t` with member functions whose return type is `void`.

[2] This helper function was called `mem_fun1_ref` in drafts of the C++ standard, but it is called `mem_fun_ref` in the final standard. This implementation provides both versions for backward compatibility, but `mem_fun1_ref` will be removed in a future release.

### See also

`mem_fun_t`, `mem_fun_ref_t`, `mem_fun1_t`

Copyright © 1999 Silicon Graphics, Inc. All Rights Reserved. TrademarkInformation