home | help 
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 fn 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 */);

	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<de-
     cltype(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::for-
     ward<Args>(args)....

Example
	Use  std::mem_fn to store and execute a member function and a member ob-
     ject:

     // 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) // 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<Foo>();
	  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,  dou-
     ble>);
	  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 retroac-
     tively 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)

http://cppreference.com 	   2024.06.10			  std::mem_fn(3)
home | help