table of contents
std::mem_fn(3) | C++ Standard Libary | std::mem_fn(3) |
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)
2022.07.31 | http://cppreference.com |