NAME¶

std::mem_fn - std::mem_fn

Synopsis¶

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

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
the return type of pm if pm
result_type(deprecated in C++17) is a pointer to member
function, not defined for
pointer to member object
T*, possibly cv-qualified, (until C++20)
argument_type(deprecated in C++17) if pm is a pointer to member
function taking no arguments
T* if pm is a pointer to
first_argument_type(deprecated in C++17) member function taking one
argument
T1 if pm is a pointer to
second_argument_type(deprecated in C++17) member function taking one
argument of type T1

Member function¶

template<class... Args>

/* see below */ operator()(Args&&... args) /* cvref-qualifiers */ (until C++20)

noexcept(/* see below */);
template<class... Args>

constexpr /* see below */ operator()(Args&&... args) /* (since C++20)
cvref-qualifiers */

noexcept(/* see below */);

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
or 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>
#include <memory>

struct Foo {
void display_greeting() {
std::cout << "Hello, world.\n";
}
void display_number(int i) {
std::cout << "number: " << i << '\n';
}
int add_xy(int x, int y) {
return data + x + y;
}
template <typename... Args> int add_many(Args... args) {
return data + (args + ...);
}
auto add_them(auto... args) {
return data + (args + ...);
}

int data = 7;
};

int main() {
auto f = Foo{};

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';

auto add_xy = std::mem_fn(&Foo::add_xy);
std::cout << "add_xy: " << add_xy(f, 1, 2) << '\n';

// Working with smart pointer
auto u = std::make_unique<Foo>();
std::cout << "access_data(u): " << access_data(u) << '\n';
std::cout << "add_xy(u, 1, 2): " << add_xy(u, 1, 2) << '\n';

// Working with member function template with parameter pack
auto add_many = std::mem_fn(&Foo::add_many<short, int, long>);
std::cout << "add_many(u, ...): " << add_many(u, 1, 2, 3) << '\n';
auto add_them = std::mem_fn(&Foo::add_them<short, int, float, double>);
std::cout << "add_them(u, ...): " << add_them(u, 5, 7, 10.0f, 13.0) << '\n';
}

Output:¶

Hello, world.
number: 42
data: 7
add_xy: 10
access_data(u): 7
add_xy(u, 1, 2): 10
add_many(u, ...): 13
add_them(u, ...): 42

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 wraps callable object of any copy constructible type with
(C++11) specified function call signature
(class template)
move_only_function wraps callable object of any type with specified function call
(C++23) signature
(class template)
bind binds one or more arguments to a function object
(C++11) (function template)