std::functi...function_ref(3)

🌸 NAME 🌸

okay bestie, welcome to the std::function_ref::function_ref constructor page from the C++ Standard Libary manual, section 3 💖. The header up top is std::functi...function_ref(3) (yes, the truncation is doing its little main character thing), and this whole page is literally about making a new std::function_ref.

✨ Synopsis ✨

six overloads, all (since C++26), periodt:

          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. That's the whole assignment, but the overloads have opinions 💅.

1. (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. (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. (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. (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. (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. (6) Defaulted copy constructor copies the bound-entity and thunk-ptr of other.

Now the thunk tea ☕: 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:

• (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

literally no example, bestie 😭 (the page said it, not me).

🔥 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

and that's the whole page, bestie 🫶. Source/version from the footer: http://cppreference.com, dated 2024.06.10, and the page is std::functi...function_ref(3). stay iconic, hydrate, and may your overload resolution always participate 💅✨