Книга: Standard Template Library Programmer
mem_fun1_ref_t
Разделы на этой странице:
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 |
---|---|
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