home | help 
std::functi...function_ref(3)  C++ Standard Libary std::functi...function_ref(3)

NAME
     std::function_ref::function_ref - std::function_ref::function_ref

Synopsis
	template<  class  F  >					      (1) (since
     C++26)
	function_ref( F* f ) noexcept;
	template< class F  >					     (2)  (since
     C++26)
	function_ref( F&& f ) noexcept;
	template<  auto  f  >					      (3) (since
     C++26)
	function_ref( std::nontype_t<f> ) noexcept;
	template< auto f, class U  >				     (4)  (since
     C++26)
	function_ref( std::nontype_t<f>, U&& obj ) noexcept;
	template<  auto  f,  class T >				      (5) (since
     C++26)
	function_ref( std::nontype_t<f>, /*cv*/ T* obj ) noexcept;
	function_ref( const function_ref& other ) =  default;	     (6)  (since
     C++26)

	Creates a new std::function_ref.

	1)  Initializes bound-entity with f, and thunk-ptr with the address of a
     function
	thunk. The behavior is undefined if f is a null pointer.
	  * This overload participates in overload resolution only if both
	    std::is_function_v<F> and /*is-invocable-using*/<F> are true.
	2) Initializes bound-entity with std::addressof(f), and  thunk-ptr  with
     the address
	of a function thunk.
	  *  Let  T be std::remove_reference_t<F>. This overload participates in
     overload
	    resolution only if :
	       * std::remove_cvref_t<F> is not the same type as function_ref,
	       * std::is_member_pointer_v<T> is false, and
	       * /*is-invocable-using*/</*cv*/ T&> is true.
	3) Initializes bound-entity with a pointer to an unspecified  object  or
     null pointer
	value, and thunk-ptr with the address of a function thunk.
	  * Let F be decltype(f). This overload participates in overload resolu-
     tion only if
	    /*is-invocable-using*/<F> is true.
	  *   The   program  is  ill-formed  if  f  !=	nullptr  is  false  when
     std::is_pointer_v<F> ||
	    std::is_member_pointer_v<F> is true.
	4) Initializes bound-entity with std::addressof(obj), and thunk-ptr with
     the address
	of a function thunk.
	  * Let T be std::remove_reference_t<U> and F be decltype(f). This over-
     load
	    participates in overload resolution only if :
	       * std::is_rvalue_reference_v<U&&> is false, and
	       * /*is-invocable-using*/<F, /*cv*/ T&> is true.
	  *  The  program  is  ill-formed  if  f  !=  nullptr  is   false   when
     std::is_pointer_v<F> ||
	    std::is_member_pointer_v<F> is true.
	5)  Initializes bound-entity with obj, and thunk-ptr with the address of
     a function
	thunk. The behavior is undefined if obj is a null pointer when
	std::is_member_pointer_v<F> is true.
	  * Let F be decltype(f). This overload participates in overload resolu-
     tion only if
	    /*is-invocable-using*/<F, /*cv*/ T*> is true.
	  *  The  program  is  ill-formed  if  f  !=  nullptr  is   false   when
     std::is_pointer_v<F> ||
	    std::is_member_pointer_v<F> is true.
	6)  Defaulted  copy constructor copies the bound-entity and thunk-ptr of
     other.

	The address of a function thunk is used  to  initialize  thunk-ptr  such
     that a call to
	thunk(bound-entity, call-args...) is expression-equivalent to:

	Overloads		    Expression-equivalence
	  (1,3)   std::invoke_r<R>(f, call-args...)
	   (2)	  std::invoke_r<R>(static_cast<cv T&>(f), call-args...)
	   (4)	  std::invoke_r<R>(f, static_cast<cv T&>(obj), call-args...)
	   (5)	  std::invoke_r<R>(f, obj, call-args...)

	/*is-invocable-using*/<T...> is true if and only if:

	  *  std::is_nothrow_invocable_r_v<R,  T..., Args...> is true if noex is
     true, or
	  * std::is_invocable_r_v<R, T..., Args...> is true

Parameters
	other - another function_ref to copy from
	f     - a function or a Callable object to wrap
	obj   - an object or pointer to bound

Example
	 This section is incomplete
	 Reason: no example

See also
	constructor   constructs a new std::move_only_function object
	(C++23)       (public member function of std::move_only_function)

Category:
	  * Todo no example

http://cppreference.com 	   2024.06.10	   std::functi...function_ref(3)
home | help