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...)); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) volatile); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const volatile); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) &); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const &); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) volatile &); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const volatile &); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) &&); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const &&); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) volatile &&); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const volatile &&); | (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.
pm | - | pointer to member that will be wrapped |
std::mem_fn
returns a call wrapper of unspecified type that has the following members:
type | definition |
---|---|
result_type (deprecated in C++17) | the return type of pm if pm is a pointer to member function, not defined for pointer to member object |
argument_type (deprecated in C++17) | T* , possibly cv-qualified, if pm is a pointer to member function taking no arguments |
first_argument_type (deprecated in C++17) | T* if pm is a pointer to member function taking one argument |
second_argument_type (deprecated in C++17) | T1 if pm is a pointer to member function taking one argument of type T1 |
template<class... Args> /* see below */ operator()(Args&&... args); |
Let fn
be the call wrapper returned by a call to std::mem_fn
with a pointer to member pm
. Then the expression fn(t, a2, ..., aN)
is equivalent to INVOKE(pm, t, a2, ..., aN)
, where INVOKE is the operation defined in Callable
. (Thus, the return type of operator()
is std::result_of<decltype(pm)(Args&&...)>::type
.).
Each argument in args
is perfectly forwarded, as if by std::forward<Args>(args)...
.
(none). | (until C++17) |
noexcept specification: noexcept | (since C++17) |
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
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
(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) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/utility/functional/mem_fn