std:: is_layout_compatible

Si T et U sont des types layout-compatibles , fournit la constante membre value égale à true . Sinon value est false .

Chaque type est compatible en disposition avec ses versions éventuellement qualifiées cv, même s'il ne s'agit pas d'un type objet.

Si T ou U n'est pas un type complet, (éventuellement qualifié cv) void , ou un tableau de limite inconnue, le comportement est indéfini.

Si l'instanciation d'un template ci-dessus dépend, directement ou indirectement, d'un type incomplet, et que cette instanciation pourrait produire un résultat différent si ce type était hypothétiquement complété, le comportement est indéfini.

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

Modèle de variable d'assistance

Notes

Un type entier signé et sa contrepartie non signée ne sont pas compatibles en mémoire. char n'est compatible en mémoire ni avec signed char ni avec unsigned char .

Types similaires ne sont pas compatibles en mémoire s'ils ne sont pas le même type après avoir ignoré les qualifications cv de plus haut niveau.

Un type énumération et son type sous-jacent ne sont pas compatibles de disposition.

Les types de tableaux ayant des types d'éléments compatibles en disposition mais différents (en ignorant les qualifications cv) ne sont pas compatibles en disposition, même s'ils sont de longueur égale.

Exemple

#include <iomanip>
#include <iostream>
#include <type_traits>
struct Foo
{
    int x;
    char y;
};
struct FooNua
{
    int x;
    [[no_unique_address]] char y;
};
class Bar
{
    const int u = 42;
    volatile char v = '*';
};
enum E0 : int {};
enum class E1 : int {};
static_assert
(
    std::is_layout_compatible_v<const void, volatile void> == true  and
    std::is_layout_compatible_v<Foo, Bar>                  == true  and
    std::is_layout_compatible_v<Foo[2], Bar[2]>            == false and
    std::is_layout_compatible_v<int, E0>                   == false and
    std::is_layout_compatible_v<E0, E1>                    == true  and
    std::is_layout_compatible_v<long, unsigned long>       == false and
    std::is_layout_compatible_v<char*, const char*>        == false and
    std::is_layout_compatible_v<char*, char* const>        == true  and
    std::is_layout_compatible_v<Foo, FooNua>               == false // Note [1]
);
// [1] MSVC échoue erronément sur cette assertion
int main() {}

Voir aussi