std::mem_fn
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
|
(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:
#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
|
(C++11)
|
wraps callable object of any copy constructible type with specified function call signature (class template) |
|
(C++23)
|
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.
https://en.cppreference.com/w/cpp/utility/functional/mem_fn
