Standard Template Library Programmer's Guide

AdaptableBinaryFunction must be a model of Adaptable Binary Function. AdaptableUnaryFunction1 and AdaptableUnaryFunction2 must both be models of Adaptable Unary Function. The argument types of AdaptableUnaryFunction1 and AdaptableUnaryFunction2 must be convertible to each other. The result types of AdaptableUnaryFunction1 and AdaptableUnaryFunction2 must be convertible, respectively, to the first and second argument types of AdaptableBinaryFunction .

unary_function

These members are not defined in the Adaptable Unary Function requirements, but are specific to binary_compose .

[1] This is a form of function composition. The unary_compose adaptor allows composition of Adaptable Unary Functions; note, however, that once binary functions are introduced, there are several possible patterns of function composition. The binary_compose allows you to form a unary function by putting together two unary functions and a binary function, but you could also, for example, imagine putting together two unary functions and a binary function to form a binary function. In that case, f , g1 , and g2 would be combined into a function object h such that h(x,y) = f(g1(x), g2(y)) .

The function object overview, unary_compose , binder1st , binder2nd .

Categories: functors, adaptors

Component type: type

Mem_fun_t is an adaptor for member functions. If X is some class with a member function Result X::f() (that is, a member function that takes no arguments and that returns a value of type Result [1]), then a mem_fun_t 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_fun_t 's constructor takes a pointer to one of X 's member functions. Then, like all function objects, mem_fun_t has an operator() that allows the mem_fun_t to be invoked with ordinary function call syntax. In this case, mem_fun_t 's operator() takes an argument of type X* .

If F is a mem_fun_t that was constructed to use the member function X::f , and if x is a pointer of type X* , then the expression F(x) is equivalent to the expression x->f() . The difference is simply that F can be passed to STL algorithms whose arguments must be function objects.

Mem_fun_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_fun_t 's constructor directly. It is usually better to use the helper function mem_fun instead.

struct B {

virtual void print() = 0;

};

struct D1 : public B {

void print() { cout << "I'm a D1" << endl; }

};

struct D2 : public B {

void print() { cout << "I'm a D2" << endl; }

};

int main() {

vector V;

V.push_back(new D1);

V.push_back(new D2);

V.push_back(new D2);

V.push_back(new D1);

for_each(V.begin(), V.end(), mem_fun(&B::print));

}

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

Adaptable Unary Function

• X has at least one member function that takes no arguments and that returns a value of type Result . [1]

unary_function

These members are not defined in the Adaptable Unary Function requirements, but are specific to mem_fun_t .