std::mem_fn
| Defined in header  <functional> | ||
| template< class R, class T > /*unspecified*/ mem_fn(R T::* pm); | (1) | (since C++11) | 
| template< class R, class T, class... Args >  /*unspecified*/ mem_fn(R (T::* pm)(Args...)); | (2) | (since C++11) (until C++14) | 
Function template std::mem_fn generates wrapper objects for pointers to members, which can store, copy, and invoke a pointer to member. Both references and pointers (including smart pointers) to an object can be used when invoking a std::mem_fn.
The overloads (2) were introduced in C++11 but removed in C++14 as defect #2048
| Contents | 
[edit] Parameters
| pm | - | pointer to member that will be wrapped | 
[edit] Return value
std::mem_fn returns a call wrapper of unspecified type that has the following members:
std::mem_fn Return type
Member types
| type | definition | 
| result_type | the return type of pm if pm is a pointer to member function, not defined for pointer to member object | 
| argument_type | T*, possibly cv-qualified, if pm is a pointer to member function taking no arguments | 
| first_argument_type | T*if pm is a pointer to member function taking one argument | 
| second_argument_type | T1if pm is a pointer to member function taking one argument of typeT1 | 
Member function
| operator() | invokes the target on a specified object, with optional parameters (public member function) | 
[edit] Exceptions
None.
[edit] Example 1
 Use mem_fn to store and execute a member function and a member object:
 
#include <functional> #include <iostream> struct Foo { void display_greeting() { std::cout << "Hello, world.\n"; } void display_number(int i) { std::cout << "number: " << i << '\n'; } int data = 7; }; int main() { Foo f; auto greet = std::mem_fn(&Foo::display_greeting); greet(f); auto print_num = std::mem_fn(&Foo::display_number); print_num(f, 42); auto access_data = std::mem_fn(&Foo::data); std::cout << "data: " << access_data(f) << '\n'; }
Output:
Hello, world. number: 42 data: 7
[edit] Example 2
Pass a member function to std::transform to create a sequence of numbers:
#include <iostream> #include <functional> #include <iterator> #include <memory> #include <string> #include <vector> #include <algorithm> int main() { std::vector<std::string> words = {"This", "is", "a", "test"}; std::vector<std::unique_ptr<std::string>> words2; words2.emplace_back(new std::string("another")); words2.emplace_back(new std::string("test")); std::vector<std::size_t> lengths; std::transform(words.begin(), words.end(), std::back_inserter(lengths), std::mem_fn(&std::string::size)); // uses references to strings std::transform(words2.begin(), words2.end(), std::back_inserter(lengths), std::mem_fn(&std::string::size)); // uses unique_ptr to strings std::cout << "The string lengths are "; for(auto n : lengths) std::cout << n << ' '; std::cout << '\n'; }
Output:
The string lengths are 4 2 1 4 7 4
[edit] Example 3
Demonstrates the effect of the C++14 changes to the specification of std::mem_fn
#include <iostream> #include <functional> struct X { int x; int& easy() {return x;} int& get() {return x;} const int& get() const {return x;} }; int main(void) { auto a = std::mem_fn (&X::easy); // no problem at all // auto b = std::mem_fn<int& >(&X::get ); // no longer works in C++14 auto c = std::mem_fn<int&()>(&X::get ); // works with both C++11 and C++14 auto d = [] (X& x) {return x.get();}; // another approach to overload resolution X x = {33}; std::cout << "a() = " << a(x) << '\n'; std::cout << "c() = " << c(x) << '\n'; std::cout << "d() = " << d(x) << '\n'; }
Output:
a() = 33 c() = 33 d() = 33
[edit] See also
| (C++11) | wraps callable object of any type with specified function call signature (class template) | 
| (C++11) | binds one or more arguments to a function object (function template) | 


