std::mem_fn - cppreference.com (original) (raw)

| | | | | --------------------------------------------------------------------------------- | | ------------------------------------- | | template< class M, class T > /* unspecified */ mem_fn( M T::* pm ) noexcept; | | (since C++11) (constexpr 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.

Contents

• 1 Parameters
• 2 Return value
• 3 std::mem_fn return type
  • 3.1 Member types
  • 3.2 Member function
  • 3.3 Example
  • 3.4 Defect reports
  • 3.5 See also

[edit] Parameters

[edit] Return value

std::mem_fn returns a call wrapper fn of unspecified type that has the following members:

std::mem_fn return type

Member function

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

The expression fn(args) is equivalent to INVOKE(pmd, args), where pmd is the Callable object held by fn, it is of type M T::* and is direct-non-list-initialized with pm.

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)....

[edit] Example

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

#include #include #include   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) // C++20 required { 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';   auto u = std::make_unique(); std::cout << "access_data(u): " << access_data(u) << '\n'; std::cout << "add_xy(u, 1, 2): " << add_xy(u, 1, 2) << '\n';   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

[edit] Defect reports

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

[edit] See also

| | copyable wrapper of any copy constructible callable object (class template) [edit] | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | | move-only wrapper of any callable object that supports qualifiers in a given call signature (class template) [edit] | | | binds one or more arguments to a function object (function template) [edit] |