I was wondering if an implementation of std::variant
must necessarily be "flat" or whether it is allowed to dynamically allocate memory for its members, such that a sequence of variants would degenerate to a sequence of pointers, thereby destroying cache locality.
No, very explicitly. From [variant.variant]:
Any instance of
variant
at any given time either holds a value of one of its alternative types, or it holds no value. When an instance ofvariant
holds a value of alternative typeT
, it means that a value of typeT
, referred to as the variant object's contained value, is allocated within the storage of thevariant
object. Implementations are not permitted to use additional storage, such as dynamic memory, to allocate the contained value. The contained value shall be allocated in a region of thevariant
storage suitably aligned for all types inTypes...
. It is implementation-defined whether over-aligned types are supported.
tuple
doesn't have similar wording, despite the fact that there's basically no implementation of it that would dynamically allocate storage for the members. –
Tedmann pair
. –
Eleonoreeleoptene tuple
does require For each tuple constructor, an exception is thrown only if the construction of one of the types in Types throws an exception. AFAIK, that means it can't dynamically allocate. –
Indentation According to cppreference ::std::variant
must not allocate dynamic memory.
As with unions, if a variant holds a value of some object type T, the object representation of T is allocated directly within the object representation of the variant itself. Variant is not allowed to allocate additional (dynamic) memory.
© 2022 - 2024 — McMap. All rights reserved.