std::move_o...nly_function(3)

std::move_o...nly_function(3) — okay so this is from the C++ Standard Libary manual (yes, “Libary”, that’s canon 💅), and it’s all about the constructors for std::move_only_function.

💅 NAME 💅

The NAME line is literally std::move_only_function::move_only_function - std::move_only_function::move_only_function — it said it twice, and honestly? obsessed with the redundancy 🫶.

✨ Synopsis ✨

Creates a new std::move_only_function. Every overload here is (since C++23), bestie.

• (1) (since C++23) — move_only_function() noexcept;
• (2) (since C++23) — move_only_function( std::nullptr_t ) noexcept;
• (3) (since C++23) — move_only_function( move_only_function&& other ) noexcept;
• (4) (since C++23) — move_only_function( const move_only_function& ) = delete;
• (5) (since C++23) — template< class F > move_only_function( F&& f );
• (6) (since C++23) — template< class T, class... CArgs > explicit move_only_function( std::in_place_type_t<T>, CArgs&&... args );
• (7) (since C++23) — template< class T, class U, class... CArgs > explicit move_only_function( std::in_place_type_t<T>, std::initializer_list<U> il, CArgs&&... args );

okay so here’s the rundown of what each constructor is giving:

• 1,2) The default constructor and the constructor taking nullptr both construct an empty std::move_only_function. clean, empty, no target, no drama 💅.
• 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 construction. lowkey iconic but also don’t go reading other afterward expecting a whole personality.
• 4) Copy constructor is deleted. std::move_only_function does not satisfy CopyConstructible. no cap, it does not copy, periodt.
• 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 specialization), 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 neither 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::forward<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::forward<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. not me writing that, it’s literally the page 💀.

🧚 the /*is-callable-from*/<VT> constant 🧚

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 empty, ref empty, noexcept(noex) = noexcept(false) → std::is_invocable_r_v<R, VT, Args...> && std::is_invocable_r_v<R, VT&, Args...>
• cv empty, ref empty, noexcept(noex) = noexcept(true) → std::is_nothrow_invocable_r_v<R, VT, Args...> && std::is_nothrow_invocable_r_v<R, VT&, Args...>
• cv = const, ref empty, noexcept(noex) = noexcept(false) → std::is_invocable_r_v<R, const VT, Args...> && std::is_invocable_r_v<R, const VT&, Args...>
• cv = const, ref empty, noexcept(noex) = noexcept(true) → std::is_nothrow_invocable_r_v<R, const VT, Args...> && std::is_nothrow_invocable_r_v<R, const VT&, Args...>
• cv empty, ref = &, noexcept(noex) = noexcept(false) → std::is_invocable_r_v<R, VT&, Args...>
• cv empty, ref = &, noexcept(noex) = noexcept(true) → std::is_nothrow_invocable_r_v<R, VT&, Args...>
• cv = const, ref = &, noexcept(noex) = noexcept(false) → std::is_invocable_r_v<R, const VT&, Args...>
• cv = const, ref = &, noexcept(noex) = noexcept(true) → std::is_nothrow_invocable_r_v<R, const VT&, Args...>
• cv empty, ref = &&, noexcept(noex) = noexcept(false) → std::is_invocable_r_v<R, VT, Args...>
• cv empty, ref = &&, noexcept(noex) = noexcept(true) → std::is_nothrow_invocable_r_v<R, VT, Args...>
• cv = const, ref = &&, noexcept(noex) = noexcept(false) → std::is_invocable_r_v<R, const VT, Args...>
• cv = const, ref = &&, noexcept(noex) = 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 exception 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 🦋

bestie the Example section is literally leaving us on read:

• 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 — yes, that’s the whole category 💅

that’s the page, bestie 💖 source/version http://cppreference.com, date 2024.06.10, and the footer is std::move_o...nly_function(3). mwah 🫶✨