# std::copyable_function::copyable_function

From cppreference.com
< cpp‎ | utility‎ | functional‎ | copyable function

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

Creates a new `std::copyable_function`.

1,2) Default constructor and the constructor taking nullptr construct an empty `std::copyable_function`.
3) Copy constructor constructs a `std::copyable_function` whose target is a copy of the target of other. Otherwise, constructs an empty `std::copyable_function` if other is empty.
4) Move constructor constructs a `std::copyable_function` whose target is that of other. other is in a valid but unspecified state after move construction.
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::copyable_function` (may be any other specialization), then constructs an empty `std::copyable_function`. Otherwise, constructs a `std::copyable_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 `copyable_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> or std::is_copy_constructible_v<VT> is not true.

6) Let `VT` be std::decay_t<T>. Constructs a `std::copyable_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` or std::is_copy_constructible_v<VT> is not true.

7) Let `VT` be std::decay_t<T>. Constructs a `std::copyable_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` or std::is_copy_constructible_v<VT> is not true.

For constructors (5-7), the behavior is undefined unless `VT` satisfies both Destructible and CopyConstructible requirements.

The constant /*is-callable-from*/<VT> is dependent on cv, ref, and noex in the template parameter of `std::copyable_function` as below:

cv ref noexcept(noex) | /*is-callable-from*/<VT>
noexcept(false) | std::is_invocable_r_v<R, VT, Args...> && std::is_invocable_r_v<R, VT&, Args...>
noexcept(true) | std::is_nothrow_invocable_r_v<R, VT, Args...> && std::is_nothrow_invocable_r_v<R, VT&, Args...>
const noexcept(false) | std::is_invocable_r_v<R, const VT, Args...> && std::is_invocable_r_v<R, const VT&, Args...>
const noexcept(true) | std::is_nothrow_invocable_r_v<R, const VT, Args...> && std::is_nothrow_invocable_r_v<R, const VT&, Args...>
& noexcept(false) | std::is_invocable_r_v<R, VT&, Args...>
& noexcept(true) | std::is_nothrow_invocable_r_v<R, VT&, Args...>
const & noexcept(false) | std::is_invocable_r_v<R, const VT&, Args...>
const & noexcept(true) | std::is_nothrow_invocable_r_v<R, const VT&, Args...>
&& noexcept(false) | std::is_invocable_r_v<R, VT, Args...>
&& noexcept(true) | std::is_nothrow_invocable_r_v<R, VT, Args...>
const && noexcept(false) | std::is_invocable_r_v<R, const VT, Args...>
const && noexcept(true) | std::is_nothrow_invocable_r_v<R, const VT, Args...>

### Parameters

other | - | another `std::copyable_function` to copy or 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

3) May throw std::bad_alloc on allocation failure or propagate the exception thrown by the initialization of the target.
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

| This section is incomplete Reason: no example

### See also

(constructor) | constructs a new `std::function` instance (public member function of `std::function<R(Args...)>`)
(constructor) | constructs a new `std::move_only_function` object (public member function of `std::move_only_function`)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/functional/copyable_function/copyable_function&oldid=178047"