std::is_layout_compatible

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

Memory management library

Metaprogramming library (C++11)

General utilities library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library (C++17)

Concurrency support library (C++11)

Execution control library (C++26)

Technical specifications

Symbols index

External libraries

 

Metaprogramming library

Type traits (C++11)

Compile-time rational arithmetic (C++11)

Compile-time integer sequences (C++14)

integer_sequence (C++14)

Compile-time reflection (C++26)

 

Type traits

Type traits (since C++11)

Type categories is_void is_null_pointer (DR*) is_reflection (C++26) is_array is_pointer is_enum is_union is_class is_function is_reference      is_object is_scalar is_compound is_integral is_floating_point      is_fundamental is_arithmetic is_lvalue_reference is_rvalue_reference is_member_pointer is_member_object_pointer is_member_function_pointer Type properties is_const is_volatile is_empty is_polymorphic is_final (C++14) is_abstract is_aggregate (C++17) is_structural (C++26) is_implicit_lifetime (C++23) is_trivial (deprecated in C++26) is_trivially_copyable is_standard_layout is_literal_type (until C++20*) is_pod (deprecated in C++20) is_signed is_unsigned is_bounded_array (C++20) is_unbounded_array (C++20) is_scoped_enum (C++23) has_unique_object_   representations (C++17)     Type trait constants integral_constantbool_constanttrue_typefalse_type (C++17) Metafunctions conjunction (C++17) disjunction (C++17) negation (C++17)

Supported operations is_constructibleis_trivially_constructibleis_nothrow_constructible is_default_constructibleis_trivially_default_constructibleis_nothrow_default_constructible is_copy_constructibleis_trivially_copy_constructibleis_nothrow_copy_constructible is_move_constructibleis_trivially_move_constructibleis_nothrow_move_constructible is_assignableis_trivially_assignableis_nothrow_assignable is_copy_assignableis_trivially_copy_assignableis_nothrow_copy_assignable is_move_assignableis_trivially_move_assignableis_nothrow_move_assignable is_destructibleis_trivially_destructibleis_nothrow_destructible has_virtual_destructor is_swappable_withis_swappableis_nothrow_swappable_withis_nothrow_swappable (C++17)(C++17)(C++17)(C++17) Relationships and property queries is_same is_convertibleis_nothrow_convertible (C++20) is_layout_compatible (C++20) is_pointer_interconvertible_base_of (C++20) is_pointer_interconvertible_with_class (C++20)     is_corresponding_member (C++20) reference_constructs_from_temporary (C++23) reference_converts_from_temporary (C++23) alignment_of is_base_of is_virtual_base_of (C++26) rank extent is_invocableis_invocable_ris_nothrow_invocableis_nothrow_invocable_r (C++17)(C++17)(C++17)(C++17) is_applicableis_nothrow_applicable (C++26)(C++26) Type modifications remove_cvremove_constremove_volatile add_cvadd_constadd_volatile make_signed make_unsigned remove_reference add_lvalue_referenceadd_rvalue_reference remove_pointer add_pointer remove_extent remove_all_extents Type transformations aligned_storage (deprecated in C++23) aligned_union (deprecated in C++23) decay remove_cvref (C++20) result_ofinvoke_result (until C++20*)(C++17) apply_result (C++26) conditional common_type common_reference (C++20) underlying_type type_identity (C++20) enable_if void_t (C++17)

 

Defined in header <type_traits>
template< class T, class U > struct is_layout_compatible;		(since C++20)

See More

If T and U are layout-compatible types, provides the member constant value equal to true. Otherwise value is false.

Every type is layout-compatible with its any cv-qualified versions, even if it is not an object type.

If T or U is not a complete type, (possibly cv-qualified) void, or an array of unknown bound, the behavior is undefined.

If an instantiation of a template above depends, directly or indirectly, on an incomplete type, and that instantiation could yield a different result if that type were hypothetically completed, the behavior is undefined.

If the program adds specializations for std::is_layout_compatible or std::is_layout_compatible_v, the behavior is undefined.

Helper variable template

template< class T, class U > constexpr bool is_layout_compatible_v = is_layout_compatible<T, U>::value;		(since C++20)

Inherited from std::integral_constant

Member constants

value [static]

true if T and U are layout-compatible, false otherwise (public static member constant)

Member functions

operator bool	converts the object to bool, returns value (public member function)
operator() (C++14)	returns value (public member function)

Member types

Type	Definition
value_type	bool
type	std::integral_constant<bool, value>

Notes

A signed integer type and its unsigned counterpart are not layout-compatible. char is layout-compatible with neither signed char nor unsigned char.

Similar types are not layout-compatible if they are not the same type after ignoring top-level cv-qualification.

An enumeration type and its underlying type are not layout-compatible.

Array types of layout-compatible but different element types (ignoring cv-qualification) are not layout-compatible, even if they are of equal length.

Feature-test macro	Value	Std	Feature
__cpp_lib_is_layout_compatible	201907L	(C++20)	std::is_layout_compatible

Example

Run this code

#include <type_traits>

static_assert
(""
    && std::is_layout_compatible_v<const void, volatile void>
    && !std::is_layout_compatible_v<long, unsigned long>
    && std::is_layout_compatible_v<char*, char* const>
    && !std::is_layout_compatible_v<char*, const char*>
);

struct Foo
{
    int x;
    char y;
};

struct FooNua
{
    int x;
    [[no_unique_address]] char y;
};

class Bar
{
    const int u{42};
    volatile char v{'*'};
};

static_assert
(""
    && std::is_layout_compatible_v<Foo, Bar>
    && !std::is_layout_compatible_v<Foo[2], Bar[2]>
    && !std::is_layout_compatible_v<Foo, FooNua> //Note [1]
);

//[1] MSVC erroneously fails this assert

enum E0 : int {};
enum class E1 : int {};
static_assert
(""
    && !std::is_layout_compatible_v<int, E0>
    && std::is_layout_compatible_v<E0, E1>
    && !std::is_layout_compatible_v<int, E1>
);

int main() {}

See also

is_standard_layout (C++11)	checks if a type is a standard-layout type (class template)
is_layout_compatible_type (C++26)	checks if two reflected types are layout-compatible (function)