Bit-casting object representations

Published Proposal,

This version:
ISO JTC1/SC22/WG21: Programming Language C++


Obtaining equivalent object representations The Right Way™.

This paper is a revision of [P0476r1], addressing LEWG comments from the 2017 Toronto meeting as well as comments from LEWG and LWG from the 2017 Albuquerque meeting. See §4 Revision History for details.

1. Background

Low-level code often seeks to interpret objects of one type as another: keep the same bits, but obtain an object of a different type. Doing so correctly is error-prone: using reinterpret_cast or union runs afoul of type-aliasing rules yet these are the intuitive solutions developers mistakenly turn to.

Attuned developers use aligned_storage with memcpy, avoiding alignment pitfalls and allowing them to bit-cast non-default-constructible types.

This proposal uses appropriate concepts to prevent misuse. As the sample implementation demonstrates we could as well use static_assert or template SFINAE, but the timing of this library feature will likely coincide with concept’s standardization.

Furthermore, it is currently impossible to implement a constexpr bit-cast function, as memcpy itself isn’t constexpr. Marking the proposed function as constexpr doesn’t require or prevent memcpy from becoming constexpr, but requires compiler support. This leaves implementations free to use their own internal solution (e.g. LLVM has a bitcast opcode).

We should standardize this oft-used idiom, and avoid the pitfalls once and for all.

2. Proposed Wording

Below, substitute the character with a number or name the editor finds appropriate for the sub-section.

In [headers] add the header <bit> to:

In the numerics section, add the following:

2.1. 29.� Bit manipulation library [bit]

2.2. 29.�.1 General [bit.general]

The header <bit> provides components to access, manipulate and process both individual bits and bit sequences.

2.3. 29.�.2 Header <bit> synopsis [bit.syn]

namespace std {
  // 29.�.3 bit_cast
  template<typename To, typename From>
  constexpr To bit_cast(const From& from) noexcept;

2.4. 29.�.3 Function template bit_cast [bit.cast]

template<typename To, typename From>
constexpr To bit_cast(const From& from) noexcept;
  1. Remarks:

    This function shall not participate in overload resolution unless:

    • sizeof(To) == sizeof(From) is true;
    • is_trivially_copyable_v<To> is true; and
    • is_trivially_copyable_v<From> is true.

    This function shall be constexpr if and only if To, From, and the types of all subobjects of To and From are types T such that:

    • is_union_v<T> is false;
    • is_pointer_v<T> is false;
    • is_member_pointer_v<T> is false;
    • is_volatile_v<T> is false; and
    • T has no non-static data members of reference type.
  2. Returns:

    An object of type To. Each bit of the value representation of the result is equal to the corresponding bit in the object representation of from. Padding bits of the To object are unspecified. If there is no value of type To corresponding to the value representation produced, the behavior is undefined. If there are multiple such values, which value is produced is unspecified.

2.5. Feature testing

The __cpp_lib_bit_cast feature test macro should be added.

3. Appendix

The Standard’s [basic.types] section explicitly blesses memcpy:

For any trivially copyable type T, if two pointers to T point to distinct T objects obj1 and obj2, where neither obj1 nor obj2 is a base-class subobject, if the underlying bytes (1.7) making up obj1 are copied into obj2, obj2 shall subsequently hold the same value as obj1.


    T* t1p;
    T* t2p;
    // provided that t2p points to an initialized object ...
    std::memcpy(t1p, t2p, sizeof(T));
    // at this point, every subobject of trivially copyable type in *t1p contains
    // the same value as the corresponding subobject in *t2p
end example]

Whereas section [class.union] says:

In a union, at most one of the non-static data members can be active at any time, that is, the value of at most one of the non-static data members can be stored in a union at any time.

4. Revision History

4.1. r1 ➡ r2

The paper was reviewed by LEWG at the 2017 Toronto meeting and feedback was provided. In the 2017 Albuquerque meeting LEWG provided feedback regarding usage of concepts while discussing [P0802r0], and EWG reviewed the paper:

4.2. r0 ➡ r1

The paper was reviewed by LEWG at the 2016 Issaquah meeting:

Straw polls:

5. Acknowledgement

Thanks to Saam Barati, Jeffrey Yasskin, and Sam Benzaquen for their early review and suggested improvements.


Informative References

JF Bastien. Bit-casting object representations. 16 October 2016. URL: https://wg21.link/p0476r0
JF Bastien. Bit-casting object representations. 11 November 2016. URL: https://wg21.link/p0476r1
Beman Dawes, Nicolai Josuttis, Walter E. Brown, Bob Steagall. Applying Concepts to the Standard Library. URL: https://wg21.link/p0802r0