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

FreeBSD Manual Pages

  
 
  

home | help 
std::move_o...nly_function(3) C++ Standard Libarystd::move_o...nly_function(3)

NAME
       std::move_only_function::move_only_function    -	  std::move_only_func-
       tion::move_only_function

Synopsis
	  move_only_function()					     noexcept;
       (1) (since C++23)
	  move_only_function(	      std::nullptr_t	    )	     noexcept;
       (2) (since C++23)
	  move_only_function(	move_only_function&&   other	)    noexcept;
       (3) (since C++23)
	  move_only_function(	 const	 move_only_function&   )   =   delete;
       (4) (since C++23)
	  template<		    class		  F		     >
       (5) (since C++23)
	  move_only_function( F&& f );
	  template< class T, class... CArgs >
	  explicit   move_only_function(  std::in_place_type_t<T>,  CArgs&&...
       (6) (since C++23)
	  args );
	  template< class T, class U, class... CArgs >

	  explicit	  move_only_function(	      std::in_place_type_t<T>,
       (7) (since C++23)

				       std::initializer_list<U>	il,
	  CArgs&&... args );

	  Creates a new	std::move_only_function.

	  1,2)	Default	 constructor  and  the constructor taking nullptr con-
       struct an empty
	  std::move_only_function.
	  3) Move constructor constructs a std::move_only_function whose  tar-
       get is that of
	  other.  other	 is  in	 a valid but unspecified state after move con-
       struction.
	  4) Copy constructor is  deleted.  std::move_only_function  does  not
       satisfy
	  CopyConstructible.
	  5)  Let  VT  be  std::decay_t<F>. If f is a null function pointer, a
       null pointer to
	  member value,	or an empty std::move_only_function (may be  any  spe-
       cialization), then
	  constructs an	empty std::move_only_function. Otherwise, constructs a
	  std::move_only_function  whose  target is of type VT and direct-non-
       list-initialized
	  with std::forward<F>(f).
	    * This overload participates in overload resolution	only if	VT  is
       neither same as
	      move_only_function nor a specialization of std::in_place_type_t,
       and
	      /*is-callable-from*/<VT> (see below) is true.
	    *  The  program is ill-formed if std::is_constructible_v<VT, F> is
       not true.
	  6) Let VT be std::decay_t<T>.	Constructs  a  std::move_only_function
       whose target is
	  of   type   VT   and	 direct-non-list-initialized   with  std::for-
       ward<CArgs>(args)....
	    * This overload participates in overload resolution	only if	both
	      std::is_constructible_v<VT,   CArgs...>	 and	/*is-callable-
       from*/<VT> (see below)
	      are true.
	    * The program is ill-formed	if VT is not the same type as T.
	  7)  Let  VT be std::decay_t<T>. Constructs a std::move_only_function
       whose target is
	  of  type  VT	and  direct-non-list-initialized  with	il,  std::for-
       ward<CArgs>(args)....
	    * This overload participates in overload resolution	only if	both
	      std::is_constructible_v<VT, std::initializer_list<U>&, CArgs...>
       and
	      /*is-callable-from*/<VT> (see below) are true.
	    * The program is ill-formed	if VT is not the same type as T.

	  For  constructors  (5-7),  the  behavior is undefined	if VT does not
       satisfy the
	  Destructible requirements,  or  std::is_move_constructible_v<VT>  is
       true but	VT does
	  not satisfy the MoveConstructible requirements.

	  The  constant	 /*is-callable-from*/<VT> is dependent on cv, ref, and
       noex in the
	  template parameter of	std::move_only_function	as below:

	   cv ref noexcept(noex)		  /*is-callable-from*/<VT>
				   std::is_invocable_r_v<R, VT,	Args...> &&
	      noexcept(false)
				   std::is_invocable_r_v<R, VT&, Args...>
				   std::is_nothrow_invocable_r_v<R,	   VT,
       Args...>	&&
	       noexcept(true)
				   std::is_nothrow_invocable_r_v<R,	  VT&,
       Args...>
				   std::is_invocable_r_v<R, const VT, Args...>
       &&
	   const noexcept(false)
				   std::is_invocable_r_v<R,	const	  VT&,
       Args...>
				   std::is_nothrow_invocable_r_v<R,  const VT,
       Args...>	&&
	    const noexcept(true)
				   std::is_nothrow_invocable_r_v<R, const VT&,
       Args...>
	     & noexcept(false)	   std::is_invocable_r_v<R, VT&, Args...>
	      &	  noexcept(true)       std::is_nothrow_invocable_r_v<R,	  VT&,
       Args...>
	  const	  &   noexcept(false)	 std::is_invocable_r_v<R,  const  VT&,
       Args...>
	   const & noexcept(true)  std::is_nothrow_invocable_r_v<R, const VT&,
       Args...>
	     &&	noexcept(false)	   std::is_invocable_r_v<R, VT,	Args...>
	     &&	  noexcept(true)       std::is_nothrow_invocable_r_v<R,	   VT,
       Args...>
	  const	&& noexcept(false) std::is_invocable_r_v<R, const VT, Args...>
	  const	 && noexcept(true)  std::is_nothrow_invocable_r_v<R, const VT,
       Args...>

Parameters
	  other	- another std::move_only_function to move from
	  f	- a function or	a Callable object to wrap
	  args	- arguments to construct the target object
	  il	- std::initializer_list	to construct the target	object

Exceptions
	  5-7) May throw std::bad_alloc	on allocation failure or propagate the
       exception
	  thrown by the	initialization of the target. No exception  is	thrown
       if VT is	a
	  function pointer type	or a specialization of std::reference_wrapper.

Example
	   This	section	is incomplete
	   Reason: no example

See also
	  constructor	constructs a new std::function instance
			(public	member function	of std::function<R(Args...)>)

Category:
	    * Todo no example

http://cppreference.com		  2024.06.10	 std::move_o...nly_function(3)

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

home | help