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_fun1_ref instead.

If f is of type Result (X::*)(Arg) then mem_fun1_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.