23 General utilities library [utilities]
23.8 Storage for any type [any]
class any {
public:
constexpr any() noexcept;
any(const any& other);
any(any&& other) noexcept;
template <class T> any(T&& value);
template <class T, class... Args>
explicit any(in_place_type_t<T>, Args&&...);
template <class T, class U, class... Args>
explicit any(in_place_type_t<T>, initializer_list<U>, Args&&...);
~any();
any& operator=(const any& rhs);
any& operator=(any&& rhs) noexcept;
template <class T> any& operator=(T&& rhs);
template <class T, class... Args>
decay_t<T>& emplace(Args&& ...);
template <class T, class U, class... Args>
decay_t<T>& emplace(initializer_list<U>, Args&&...);
void reset() noexcept;
void swap(any& rhs) noexcept;
bool has_value() const noexcept;
const type_info& type() const noexcept;
};
An object of class
any stores an instance of any type that satisfies the constructor requirements or it has no value,
and this is referred to as the
state of the class
any object
. The stored instance is called the
contained value,
Two states are equivalent if either they both have no value, or both have a value and the contained values are equivalent
.The non-member
any_cast functions provide type-safe access to the contained value
.Implementations should avoid the use of dynamically allocated memory for a small contained value
. [
Example: where the object constructed is holding only an
int. —
end example ]
Such small-object optimization shall only be applied to types
T for which
is_nothrow_move_constructible_v<T> is
true.constexpr any() noexcept;
Postconditions:
has_value() is
false. any(const any& other);
Effects:
If
other.has_value() is
false, constructs an object that has no value
. Otherwise, equivalent to
any(in_place<T>, any_cast<const T&>(other))
where
T is the type of the contained object
.Throws:
Any exceptions arising from calling the selected constructor for the contained value
. any(any&& other) noexcept;
Effects:
If
other.has_value() is
false, constructs an object that has no value
. Otherwise, constructs an object of type
any that
contains either the contained object of
other, or
contains an object of the same type constructed from
the contained object of
other considering that contained object as an rvalue
.Postconditions:
other is left in a valid but otherwise unspecified state
. template<class T>
any(T&& value);
Requires:
VT shall satisfy the
CopyConstructible requirements
. Effects:
Constructs an object of type
any that contains an object of type
VT direct-initialized with
std::forward<T>(value). Remarks:
This constructor shall not participate in overload resolution unless
VT is not the same type as
any,
VT is not a specialization of
in_place_type_t,
and
is_copy_constructible_v<VT> is
true. Throws:
Any exception thrown by the selected constructor of
VT. template <class T, class... Args>
explicit any(in_place_type_t<T>, Args&&... args);
Requires: VT shall satisfy the
CopyConstructible requirements
. Effects: Initializes the contained value as if direct-non-list-initializing an object of
type
VT with the arguments
std::forward<Args>(args).... Postconditions: *this contains a value of type
VT. Throws: Any exception thrown by the selected constructor of
VT. Remarks:
This constructor shall not participate in overload resolution unless
is_copy_constructible_v<VT> is
true and
is_constructible_v<VT, Args...> is
true. template <class T, class U, class... Args>
explicit any(in_place_type_t<T>, initializer_list<U> il, Args&&... args);
Requires: VT shall satisfy the
CopyConstructible requirements
. Effects: Initializes the contained value as if direct-non-list-initializing an object of
type
VT with the arguments
il, std::forward<Args>(args).... Postconditions: *this contains a value
. Throws: Any exception thrown by the selected constructor of
VT. Remarks:
This constructor shall not participate in overload resolution unless
is_copy_constructible_v<VT> is
true and
is_constructible_v<VT, initializer_list<U>&, Args...> is
true. ~any();
Effects:
As if by
reset(). any& operator=(const any& rhs);
Effects:
As if by
any(rhs).swap(*this). No effects if an exception is thrown
.Throws:
Any exceptions arising from the copy constructor for the contained value
. any& operator=(any&& rhs) noexcept;
Effects:
As if by
any(std::move(rhs)).swap(*this). Postconditions:
The state of
*this is equivalent to the original state of
rhs
and
rhs is left in a valid but otherwise unspecified state
. template<class T>
any& operator=(T&& rhs);
Requires:
VT shall satisfy the
CopyConstructible requirements
. Effects:
Constructs an object
tmp of type
any that contains an object of type
VT direct-initialized with
std::forward<T>(rhs), and
tmp.swap(*this). No effects if an exception is thrown
.Remarks:
This operator shall not participate in overload resolution unless
VT is not the same type as
any and
is_copy_constructible_v<VT> is
true. Throws:
Any exception thrown by the selected constructor of
VT. template <class T, class... Args>
decay_t<T>& emplace(Args&&... args);
Requires:
VT shall satisfy the
CopyConstructible requirements
. Then initializes the contained value as if direct-non-list-initializing
an object of type
VT with the arguments
std::forward<Args>(args).... Postconditions: *this contains a value
. Returns:
A reference to the new contained value
. Throws: Any exception thrown by the selected constructor of
VT. Remarks: If an exception is thrown during the call to
VT's constructor,
*this does not contain a value, and any previously contained value
has been destroyed
. This function shall not participate in overload resolution unless
is_copy_constructible_v<VT> is
true and
is_constructible_v<VT, Args...> is
true.template <class T, class U, class... Args>
decay_t<T>& emplace(initializer_list<U> il, Args&&... args);
Requires:
VT shall satisfy the
CopyConstructible requirements
. Then initializes the contained value
as if direct-non-list-initializing an object of type
VT with the arguments
il, std::forward<Args>(args).... Postconditions: *this contains a value
. Returns:
A reference to the new contained value
. Throws: Any exception thrown by the selected constructor of
VT. Remarks: If an exception is thrown during the call to
VT's constructor,
*this does not contain a value, and any previously contained value
has been destroyed
. The function shall not participate in overload resolution unless
is_copy_constructible_v<VT> is
true and
is_constructible_v<VT, initializer_list<U>&, Args...> is
true.void reset() noexcept;
Effects:
If
has_value() is
true, destroys the contained value
. Postconditions:
has_value() is
false. void swap(any& rhs) noexcept;
Effects:
Exchanges the states of
*this and
rhs. bool has_value() const noexcept;
Returns:
true if
*this contains an object, otherwise
false. const type_info& type() const noexcept;
Returns:
typeid(T) if
*this has a contained value of type
T,
otherwise
typeid(void). [
Note: Useful for querying against types known either at compile time or only at runtime
. —
end note ]