std::meta::has_unique_object_representations

 

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

Compile-time rational arithmetic

Compile-time integer sequences

integer_sequence (C++14)

Compile-time reflection (C++26)

 

Reflection library

Checking string literals is_string_literal Types info meta::exception access_context data_member_options member_offset operators Concepts reflection_range Promoting to static storage reflect_constant_string reflect_constant_array define_static_string define_static_array define_static_object Operator representations operator_of symbol_of u8symbol_of Names and locations has_identifier identifier_of u8identifier_of display_string_of u8display_string_of source_location_of Reflection queries ➜ Member accessibility queries is_accessible has_inaccessible_nonstatic_   data_members has_inaccessible_bases has_inaccessible_subobjects

Scope identification current_function current_class current_namespace Reflection member queries members_of bases_of static_data_members_of nonstatic_data_members_of      subobjects_of enumerators_of Reflection layout queries offset_of size_of alignment_of bit_size_of Annotation reflection annotations_of annotations_of_with_type Value extraction extract Reflection substitution can_substitute substitute Expression result reflection reflect_constant reflect_object reflect_function Class definition generation data_member_spec is_data_member_spec define_aggregate

Primary type categories is_void_type is_null_pointer_type is_integral_type is_floating_point_type is_array_type is_pointer_type is_lvalue_reference_type is_rvalue_reference_type is_member_object_pointer_type is_member_function_pointer_type      is_enum_type is_union_type is_class_type is_function_type is_reflection_type Composite type categories is_reference_type is_arithmetic_type is_fundamental_type is_object_type is_scalar_type is_compound_type is_member_pointer_type Type properties ➜ Type relations is_same_type is_base_of_type is_virtual_base_of_type is_convertible_type is_nothrow_convertible_type is_layout_compatible_type is_pointer_interconvertible_   base_of_type is_invocable_type is_invocable_r_type is_nothrow_invocable_type is_nothrow_invocable_r_type

Const-volatile modifications remove_const remove_volatile remove_cv add_const add_volatile add_cv Reference modifications remove_reference add_lvalue_reference add_rvalue_reference Sign modifications make_signed make_unsigned Array modifications remove_extent remove_all_extents Pointer modifications remove_pointer add_pointer Other transformations remove_cvref decay common_type common_reference underlying_type invoke_result unwrap_reference unwrap_ref_decay tuple_size tuple_element is_applicable_type is_nothrow_applicable_type apply_result variant_size variant_alternative type_order

 

Reflection types and queries

Reflection queries type_of object_of constant_of is_public is_protected is_private is_virtual is_pure_virtual is_override is_final is_deleted is_defaulted is_user_provided is_user_declared is_explicit is_noexcept is_bit_field is_enumerator is_annotation is_const is_volatile is_mutable_member is_lvalue_reference_qualified is_rvalue_reference_qualified has_static_storage_duration has_thread_storage_duration has_automatic_storage_duration      has_internal_linkage has_module_linkage has_external_linkage has_c_language_linkage has_linkage is_complete_type is_enumerable_type is_variable is_type is_namespace is_type_alias is_namespace_alias is_function is_conversion_function is_operator_function is_literal_operator is_special_member_function is_destructor

is_constructor is_default_constructor is_copy_constructor is_move_constructor is_assignment is_copy_assignment is_move_assignment is_function_parameter is_explicit_object_parameter has_default_argument is_vararg_function is_template is_function_template is_variable_template is_class_template is_alias_template is_conversion_function_template      is_operator_function_template is_literal_operator_template is_constructor_template is_concept is_value is_object is_structured_binding is_class_member is_namespace_member is_nonstatic_data_member is_static_member is_base has_default_member_initializer has_parent parent_of dealias has_template_arguments template_of template_arguments_of parameters_of variable_of return_type_of Type properties is_const_type is_volatile_type is_trivially_copyable_type is_standard_layout_type is_empty_type

is_polymorphic_type is_abstract_type is_final_type is_aggregate_type is_structural_type is_signed_type is_unsigned_type is_bounded_array_type is_unbounded_array_type is_scoped_enum_type is_constructible_type is_trivially_constructible_type is_nothrow_constructible_type is_default_constructible_type is_trivially_default_constructible_type is_nothrow_default_constructible_type is_copy_constructible_type is_trivially_copy_constructible_type is_nothrow_copy_constructible_type is_move_constructible_type is_trivially_move_constructible_type is_nothrow_move_constructible_type is_assignable_type is_trivially_assignable_type is_nothrow_assignable_type is_copy_assignable_type is_trivially_copy_assignable_type is_nothrow_copy_assignable_type is_move_assignable_type is_trivially_move_assignable_type is_nothrow_move_assignable_type is_swappable_with_type is_swappable_type is_nothrow_swappable_with_type is_nothrow_swappable_type is_destructible_type is_trivially_destructible_type is_nothrow_destructible_type is_implicit_lifetime_type has_virtual_destructor has_unique_object_representations reference_constructs_from_temporary reference_converts_from_temporary Type property queries rank extent

 

Defined in header <meta>
consteval bool has_unique_object_representations( std::meta::info r );		(since C++26)

Returns true if r represents a trivially copyable type T and if any two objects of type T with the same value have the same object representation. For any other type T, returns false.

For the purpose of this meta-function, two arrays have the same value if their elements have the same values, two non-union classes have the same value if their direct subobjects have the same value, and two unions have the same value if they have the same active member and the value of that member is the same.

It is implementation-defined which scalar types satisfy this meta-function, but integer types that do not use padding bits are guaranteed to have unique object representations.

If std::meta::remove_all_extents(r) represents an incomplete type other than (possibly cv-qualified) void, the behavior is undefined.

Parameters

r

-

a reflection value

Return value

true if r has unique object representations; otherwise false.

Notes

This meta-function can be used to determine whether a type can be correctly hashed by hashing its object representation as a byte array.

Example

Run this code

#include <cstdint>
#include <meta>

struct unpadded
{
    std::uint32_t a, b;
};

struct likely_padded
{
    std::uint8_t c;
    std::uint16_t st;
    std::uint32_t i;
};

int main()
{
    // Every value of a char corresponds to exactly one object representation.
    static_assert(has_unique_object_representations(^^char));

    // For IEC 559 floats, assertion passes because the
    // value NaN has multiple object representations.
    static_assert(!has_unique_object_representations(^^float));
    
    // Should succeed in any sane implementation because ‘unpadded’ is
    // typically not padded, and std::uint32_t cannot contain padding bits.
    static_assert(has_unique_object_representations(^^unpadded));

    // Fails in most implementations because padding bits are inserted between
    // the data members ‘c’ and ‘st’ for the purpose of aligning ‘st’ to 16 bits.
    static_assert(!has_unique_object_representations(^^likely_padded));
    
    // Notable architectural divergence:
    static_assert(has_unique_object_representations(^^bool)); // x86
    // static_assert(!has_unique_object_representations(^^bool)); // ARM
}

See also

is_value (C++26)	checks if reflection represents a (scalar) value (function)
is_object (C++26)	checks if reflection represents a static object (function)
is_integral_type (C++26)	checks if reflected type is an integral type (function)
is_scalar_type (C++26)	checks if reflected type is a scalar type (function)
is_class_type (C++26)	checks if reflected type is a non-union class type (function)
is_union_type (C++26)	checks if reflected type is a union type (function)
is_array_type (C++26)	checks if reflected type is an array type (function)
is_standard_layout_type (C++26)	checks if reflected type is a standard-layout type (function)
hash (C++11)	hash function object (class template)
has_unique_object_representations (C++17)	checks if every bit in the type's object representation contributes to its value (class template)