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

FreeBSD Manual Pages

  
 
  

home | help 
std::move_only_function(3)    C++ Standard Libary   std::move_only_function(3)

NAME
       std::move_only_function - std::move_only_function

Synopsis
	  Defined in header <functional>
	  template<  class...  >				    (1)	(since
       C++23)
	  class	move_only_function; // not defined
	  template< class R, class... Args >

	  class	move_only_function<R(Args...)>;
	  template< class R, class... Args >
	  class	move_only_function<R(Args...) noexcept>;
	  template< class R, class... Args >
	  class	move_only_function<R(Args...) &>;
	  template< class R, class... Args >
	  class	move_only_function<R(Args...) &	noexcept>;
	  template< class R, class... Args >
	  class	move_only_function<R(Args...) &&>;
	  template< class R, class... Args >
	  class	move_only_function<R(Args...) && noexcept>;	   (2)	(since
       C++23)
	  template< class R, class... Args >
	  class	move_only_function<R(Args...) const>;
	  template< class R, class... Args >
	  class	move_only_function<R(Args...) const noexcept>;
	  template< class R, class... Args >
	  class	move_only_function<R(Args...) const &>;
	  template< class R, class... Args >
	  class	move_only_function<R(Args...) const & noexcept>;
	  template< class R, class... Args >
	  class	move_only_function<R(Args...) const &&>;
	  template< class R, class... Args >

	  class	move_only_function<R(Args...) const && noexcept>;

	  Class	template std::move_only_function is a general-purpose polymor-
       phic function
	  wrapper.  std::move_only_function  objects  can store	and invoke any
       constructible (not
	  required to  be  move	 constructible)	 Callable  target   functions,
       lambda expressions,
	  bind	expressions, or	other function objects,	as well	as pointers to
       member functions
	  and pointers to member objects.

	  The	stored	 callable   object   is	  called   the	  target    of
       std::move_only_function.	If a
	  std::move_only_function  contains no target, it is called empty. Un-
       like
	  std::function, invoking an empty std::move_only_function results  in
       undefined
	  behavior.

	  std::move_only_functions  supports every possible combination	of cv-
       qualifiers,
	  ref-qualifiers, and noexcept-specifiers not including	volatile  pro-
       vided in	its
	  template  parameter.	These  qualifiers  and	specifier (if any) are
       added to	its
	  operator().

	  std::move_only_function  satisfies  the  requirements	 of   MoveCon-
       structible and
	  MoveAssignable,  but	does  not satisfy CopyConstructible or CopyAs-
       signable.

Member types
	  Type	      Definition
	  result_type R

Member functions
	  constructor	constructs a new std::move_only_function object
	  (C++23)	(public	member function)
	  destructor	destroys a std::move_only_function object
	  (C++23)	(public	member function)
	  operator=	replaces or destroys the target
	  (C++23)	(public	member function)
	  swap		swaps the targets of two  std::move_only_function  ob-
       jects
	  (C++23)	(public	member function)
	  operator bool	checks if the std::move_only_function has a target
	  (C++23)	(public	member function)
	  operator()	invokes	the target
	  (C++23)	(public	member function)

Non-member functions
	  swap(std::move_only_function)	overloads the std::swap	algorithm
	  (C++23)			(function)
	  operator==			  compares  a  std::move_only_function
       with nullptr
	  (C++23)			(function)

Notes
	  Implementations may store a callable object of small size within the
	  std::move_only_function object. Such small  object  optimization  is
       effectively
	  required  for	 function pointers and std::reference_wrapper special-
       izations, and can
	  only be applied  to  types  T	 for  which  std::is_nothrow_move_con-
       structible_v<T> is
	  true.

	  If  a	 std::move_only_function  returning a reference	is initialized
       from a function or
	  function object returning a prvalue (including a  lambda  expression
       without a
	  trailing-return-type), the program is	ill-formed because binding the
       returned
	  reference to a temporary object is forbidden.	See also std::function
       Notes.

	       Feature-test macro	Value	 Std	       Feature
	  __cpp_lib_move_only_function 202110L (C++23) std::move_only_function

Example
       // Run this code

	#include <functional>
	#include <future>
	#include <iostream>

	int main()
	{
	    std::packaged_task<double()>  packaged_task([](){  return 3.14159;
       });

	    std::future<double>	future = packaged_task.get_future();

	    auto  lambda  =  [task  =  std::move(packaged_task)]()  mutable  {
       task(); };

	//  std::function<void()> function = std::move(lambda);	// Error
	    std::move_only_function<void()>  function  = std::move(lambda); //
       OK

	    function();

	    std::cout << future.get();
	}

Output:
	3.14159

See also
	  function wraps callable object of any	copy constructible  type  with
       specified
	  (C++11)  function call signature
		   (class template)

http://cppreference.com		  2024.06.10	    std::move_only_function(3)

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

home | help