home | help 
std::move_o...nly_function(3)  C++ Standard Libary std::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 construct an
     empty
	std::move_only_function.
	3) Move constructor constructs a std::move_only_function whose target is
     that of
	other.	other  is  in a valid but unspecified state after move construc-
     tion.
	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 special-
     ization), 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 nei-
     ther 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 ex-
     ception
	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)
home | help