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

	  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<de-
       cltype(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
       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)	// 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)

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.1.quarterly>

home | help