Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

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	refer-
       ences 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 mem-
       ber
						    function  taking  no argu-
       ments
						    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<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<de-
       cltype(pm), Args&&...>)
	  (since C++17).

	  Each	argument  in  args  is perfectly forwarded, as if by std::for-
       ward<Args>(args)....

Example
	  Use 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)	{
		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, 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		  2022.07.31			std::mem_fn(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::mem_fn&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help