std::function_ref(3)

💅 std::function_ref 💅

okay bestie, this is std::function_ref(3), straight outta the C++ Standard Libary manual 💖 the manual name is folded in right here so we don't have to do a boring header copy. It's giving class-template energy, and we're gonna get into every single detail. periodt.

🌸 NAME 🌸

std::function_ref — literally std::function_ref, no cap.

✨ Synopsis ✨

Defined in header <functional>
template< class... >                           (1) (since C++26)
class function_ref; // not defined
template< class R, class... Args >

class function_ref<R(Args...)>;
template< class R, class... Args >
class function_ref<R(Args...) noexcept>;       (2) (since C++26)
template< class R, class... Args >
class function_ref<R(Args...) const>;
template< class R, class... Args >

class function_ref<R(Args...) const noexcept>;

Class template std::function_ref is a non-owning function wrapper. std::function_ref objects can store and invoke a reference to a Callable target — functions, lambda expressions, bind expressions, or other function objects — but not pointers to member functions and pointers to member objects. std::nontype can be used to construct std::function_ref by passing function pointers, pointers to member functions, and pointers to member objects.

std::function_refs supports every possible combination of cv-qualifiers, and noexcept-specifiers not including volatile, provided in its template parameter.

Every specialization of std::function_ref is a TriviallyCopyable type that satisfies copyable. slay.

🎀 Member objects 🎀

Member name → Definition, because we're being thorough bestie:

• bound-entity (private) — an object that has an unspecified TriviallyCopyable type BoundEntityType, that satisfies copyable and is capable of storing a pointer to object value or pointer to function value (exposition-only member object*).
• thunk-ptr (private) — a pointer to function of type R(*)(BoundEntityType, Args&&...) noexcept(/*noex*/) where /*noex*/ is true if noexcept is present in function signature as part of the template parameter of std::function_ref (exposition-only member object*).

💅 Member functions 💅

• constructor — constructs a new function_ref object (C++26) (public member function).
• operator= — assigns a function_ref (C++26) (public member function).
• operator() — invokes the stored thunk of a function_ref (C++26) (public member function).

🦋 Deduction guides 🦋

Deduction guides, bestie ✨

⭐ Notes ⭐

• Feature-test macro: __cpp_lib_function_ref — Value: 202306L; Std: (C++26); Feature: std::function_ref.

🌈 Example 🌈

This section is incomplete.

Reason: example.

🫶 See also 🫶

• function — wraps callable object of any copy constructible type with specified function call signature (C++11) (class template).
• copyable_function — refinement of std::move_only_function that wraps callable object of any copy constructible type (C++26) (class template).
• move_only_function — wraps callable object of any type with specified function call signature (C++23) (class template).
• nontype — value construction tag.
• nontype_t — (tag) (C++26).

🧚 Category 🧚

• Todo with reason

---

xoxo, sourced from http://cppreference.com, dated 2024.06.10, page std::function_ref(3) 💖✨