
Categories: functors, adaptors  Component type: type 
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++, polymorphism involves calling member functions through pointers or references.
As with many other adaptors, it is usually inconvenient to use mem_fun1_t's constructor directly. It is usually better to use the helper function mem_fun [2] instead.
struct Operation { virtual double eval(double) = 0; }; struct Square : public Operation { double eval(double x) { return x * x; } }; struct Negate : public Operation { double eval(double x) { return x; } }; int main() { vector<Operation*> operations; vector<double> operands; operations.push_back(new Square); operations.push_back(new Square); operations.push_back(new Negate); operations.push_back(new Negate); operations.push_back(new Square); operands.push_back(1); operands.push_back(2); operands.push_back(3); operands.push_back(4); operands.push_back(5); transform(operations.begin(), operations.end(), operands.begin(), ostream_iterator<double>(cout, "\n"), mem_fun(Operation::eval)); }
Parameter  Description  Default 

Result  The member function's return type.  
X  The class whose member function the mem_fun1_t invokes.  
Arg  The member function's argument type. 
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_t(Result (X::*f)(Arg)) 
mem_fun1_t  See below. 
template <class Result, class X, class Arg> mem_fun1_t<Result, X, Arg> mem_fun(Result (X::*f)(Arg)); [2] 
mem_fun1_t  See below. 
Member  Description 

explicit mem_fun1_t(Result (X::*f)(Arg)) 
The constructor. Creates a mem_fun1_t that calls the member function f. 
template <class Result, class X, class Arg> mem_fun1_t<Result, X, Arg> mem_fun(Result (X::*f)(Arg)); [2] 
If f is of type Result (X::*)(Arg) then mem_fun(f) is the same as mem_fun1_t<Result, X, Arg>(f), but is more convenient. This is a global function, not a member function. 
[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_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_t with member functions whose return type is void.
[2] This helper function was called mem_fun1 in drafts of the C++ standard, but it is called mem_fun in the final standard. This implementation provides both versions for backward compatibility, but mem_fun1 will be removed in a future release.
Contact Us  Site Map  Trademarks  Privacy  Using this site means you accept its Terms of Use 
Copyright © 2009  2017 Silicon Graphics International. All rights reserved. 