std::mem_fn

std::mem_fn

 

C++

 

Utilities library

 

Function objects

 

Defined in header <functional>
template< class M, class T > /*unspecified*/ mem_fn(M T::* pm) noexcept;		(since C++11) (until C++20)
template< class M, class T > constexpr /*unspecified*/ mem_fn(M T::* pm) noexcept;		(since C++20)

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.

Parameters

pm

-

pointer to member that will be wrapped

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(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

(until C++20)

Member function

template<class... Args> /* see below */ operator()(Args&&... args) /* cvref-qualifiers */     noexcept(/* see below */);		(until C++20)
template<class... Args> constexpr /* see below */ operator()(Args&&... args) /* cvref-qualifiers */     noexcept(/* see below */);		(since C++20)

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&&...)>::typeor equivalently std::invoke_result_t<decltype(pm), Args&&...>, and the value in noexcept specifier is equal to std::is_nothrow_invocable_v<decltype(pm), Args&&...>) (since C++17).

Each argument in args is perfectly forwarded, as if by std::forward<Args>(args)....

Example

Use mem_fn to store and execute a member function and a member object:

Run this code

#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

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 2048	C++11	unnecessary overloads provided	removed
LWG 2489	C++11	noexcept not required	required

See also

function (C++11)	wraps callable object of any type with specified function call signature (class template)
bind (C++11)	binds one or more arguments to a function object (function template)