22 General utilities library [utilities]
22.7 Storage for any type [any]
namespace std {
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 meets the constructor requirements or it has no value,
and this is referred to as the
state of the class
any object
.Two states are equivalent if either they both have no value, or they both have a value and the contained values are equivalent
.Implementations should avoid the use of dynamically allocated memory for a small contained value
.However, any such small-object optimization shall only be applied to types
T for which
is_nothrow_move_constructible_v<T> is
true.[
Example 1:
A contained value of type
int could be stored in an internal buffer,
not in separately-allocated memory
. —
end example]
constexpr any() noexcept;
Postconditions:
has_value() is
false. Effects: If
other.has_value() is
false, constructs an object that has no value
. Otherwise, equivalent to
any(in_place_type<T>, any_cast<const T&>(other))
where
T is the type of the contained value
.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 value of
other, or
contains an object of the same type constructed from
the contained value of
other considering that contained value as an rvalue
.template<class T>
any(T&& value);
Constraints:
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);
Constraints:
is_copy_constructible_v<VT> is
true and
is_constructible_v<VT, Args..> is
true. Effects: Direct-non-list-initializes the contained value of type
VT
with
std::forward<Args>(args).. Throws: Any exception thrown by the selected constructor of
VT. template<class T, class U, class. Args>
explicit any(in_place_type_t<T>, initializer_list<U> il, Args&&. args);
Constraints:
is_copy_constructible_v<VT> is
true and
is_constructible_v<VT, initializer_list<U>&, Args..> is
true. Effects: Direct-non-list-initializes the contained value of type
VT
with
il, std::forward<Args>(args).. Throws: Any exception thrown by the selected constructor of
VT. Effects: As if by
reset(). any& operator=(const any& rhs);
Throws: Any exceptions arising from the copy constructor for the contained value
. any& operator=(any&& rhs) noexcept;
template<class T>
any& operator=(T&& rhs);
Constraints:
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);
Constraints:
is_copy_constructible_v<VT> is
true and
is_constructible_v<VT, Args..> is
true. Then direct-non-list-initializes the contained value of type
VT
with
std::forward<Args>(args).. 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
. template<class T, class U, class. Args>
decay_t<T>& emplace(initializer_list<U> il, Args&&. args);
Constraints:
is_copy_constructible_v<VT> is
true and
is_constructible_v<VT, initializer_list<U>&, Args..> is
true. Then direct-non-list-initializes the contained value
of type
VT with
il, std::forward<Args>(args).. 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
. 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 1:
Useful for querying against types known either at compile time or only at runtime
. —
end note]