std::function_ref::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 resolution 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 overload
       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 resolution 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