Public base classes unary_function<X, Result>
Members | Member | Where defined | Description |
argument_type | Adaptable Unary Function | The type of the argument: X |
result_type | Adaptable Unary Function | The type of the result: Result |
Result operator()(X& x) const | Unary Function | Function call operator. Invokes x.f(), where f is the member function that was passed to the constructor. |
explicit mem_fun_ref_t(Result (X::*f)()) | mem_fun_ref_t | See below. |
template <class Result, class X> mem_fun_ref_t<Result, X> mem_fun_ref(Result (X::*f)()); | mem_fun_ref_t | See below. |
New members These members are not defined in the Adaptable Unary Function requirements, but are specific to mem_fun_ref_t.
| Member | Description |
explicit mem_fun_ref_t(Result (X::*f)()) | The constructor. Creates a mem_fun_ref_t that calls the member function f. |
template <class Result, class X> mem_fun_ref_t<Result, X> mem_fun_ref(Result (X::*f)()); | If f is of type Result (X::*)() then mem_fun_ref(f) is the same as mem_fun_ref_t<Result, X>(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_fun_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_fun_ref_t with member functions whose return type is void.
See also mem_fun_t, mem_fun1_t, mem_fun1_ref_t
mem_fun1_t<Result, X, Arg>
Categories: functors, adaptors
Component type: type
Description Mem_fun1_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_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_t<Result, X, Arg>'s constructor takes a pointer to one of X's member functions. Then, like all function objects, mem_fun1_t has an operator() that allows the mem_fun1_t to be invoked with ordinary function call syntax. In this case, mem_fun1_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_t that was constructed to use the member function X::f, and if x is a pointer 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_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++,
