std:: has_unique_object_representations

std::has_unique_object_representations est un UnaryTypeTrait .

Si T est trivialement copiable et si deux objets quelconques de type T ayant la même valeur possèdent la même représentation objet , fournit la constante membre value égale à true . Pour tout autre type, value vaut false .

Aux fins de ce trait, deux tableaux ont la même valeur si leurs éléments ont les mêmes valeurs, deux classes non-union ont la même valeur si leurs sous-objets directs ont la même valeur, et deux unions ont la même valeur si elles ont le même membre actif et la valeur de ce membre est la même.

Il est défini par l'implémentation quels types scalaires satisfont à ce trait, mais les types entiers non signés qui n'utilisent pas de bits de remplissage sont garantis d'avoir des représentations d'objet uniques.

Si std:: remove_all_extents_t < T > est un type incomplet autre que void (éventuellement qualifié cv), le comportement est indéfini.

Si le programme ajoute des spécialisations pour std::has_unique_object_representations ou std::has_unique_object_representations_v , le comportement est indéfini.

Paramètres du modèle

Modèle de variable d'assistance

Notes

Ce trait a été introduit pour permettre de déterminer si un type peut être correctement haché en hachant sa représentation objet comme un tableau d'octets.

Exemple

#include <cstdint>
#include <type_traits>
struct unpadded
{
    std::uint32_t a, b;
};
struct likely_padded
{
    std::uint8_t c;
    std::uint16_t st;
    std::uint32_t i;
};
int main()
{
    // Chaque valeur d'un char correspond exactement à une représentation d'objet unique.
    static_assert(std::has_unique_object_representations_v<char>);
    // Pour les flottants IEC 559, l'assertion échoue car la valeur NaN a
    // plusieurs représentations d'objet.
    static_assert(!std::has_unique_object_representations_v<float>);
    // Devrait réussir dans toute implémentation saine car unpadded
    // n'est généralement pas rempli de padding, et std::uint32_t ne peut pas contenir de bits de padding.
    static_assert(std::has_unique_object_representations_v<unpadded>);
    // Échoue dans la plupart des implémentations car des bits de padding sont insérés
    // entre les membres de données c et st pour aligner st sur 16 bits.
    static_assert(!std::has_unique_object_representations_v<likely_padded>);
    // Divergence architecturale notable :
    static_assert(std::has_unique_object_representations_v<bool>);  // x86
 // static_assert(!std::has_unique_object_representations_v<bool>); // ARM
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi