>
> * If r is an expression of type T, the expression std::bit_cast<T>(r)
> shall be equivalent to copy constructing the result from r, except that the
> expression treats copy constructors which are defined as deleted as though
> they were defined as default instead, and does not call move constructors
> even if r is an rvalue.


std::bit_cast only works for types that are TriviallyCopyable, and will
emit a compiler error otherwise. This "Reflexive" case seems perhaps
unnecessary then.


On Thu, Sep 24, 2020 at 7:13 AM connor horman via Std-Proposals <
std-proposals_at_[hidden]> wrote:

> C++20 added the function std::bit_cast to the standard library. While the
> result of it is defined, simply reinterpreting the bytes making up the
> object-representation, there are actually no defined results (beyond the
> identity case, which is simply copy-constructing the result from the
> input). This seeks to add limitations on the results of std::bit_cast,
> which are believed to be reasonable, and may be expected in practice.
>
> Reflexive:
> (Included for completeness)
> * If r is an expression of type T, the expression std::bit_cast<T>(r)
> shall be equivalent to copy constructing the result from r, except that the
> expression treats copy constructors which are defined as deleted as though
> they were defined as default instead, and does not call move constructors
> even if r is an rvalue.
>
> Enumerations and Integral types:
> * If r is an expression of a (potentially cv-qualified) integral type
> other than bool or an enumeration type, and U is a
> (potentially cv-qualified) integral type other than bool or an enumeration
> type, the expression std::bit_cast<U>(r), if well formed, shall be an
> equivalent expression to static_cast<U>(r)
>
>
> Pointer types:
> * If r is an expression of type (potentially cv-qualified) pointer to void
> or pointer to a character type, and U such a type, let P be the same
> pointer type as the type or r, but with the same cv-qualifiers (ignoring
> top-level cv-qualifiers) as U, the expression std::bit_cast<U>(r) shall be
> well-formed and shall be an equivalent expression as
> reinterpret_cast<U>(const_cast<P>(r))
> * If r is an expression of type T*, and U is the same type as T ignoring
> top level cv-qualifiers, then the expression std::bit_cast<U>(r) shall be
> well-formed, and shall be an equivalent expression to const_cast<U*>(r)
>
> Pointer-interconvertible:
> * If r is an (potentially const-qualified) lvalue, designating an object
> a, and U is a type, such that (ignoring all top-level cv-qualifiers), there
> is an object of type U, b, that is *pointer-interconvertible* with a,
> then the expression std::bit_cast<U>(r), if well formed, is equivalent to
> copy-constructing the result from a const-qualified lvalue designating b.
>
> Union:
> * If r is an expression of type T, and U is a union type which has at
> least one member of type T which is not a bitfield, if the expression
> std::bit_cast<U>(r), if well-formed, shall yield a union where the active
> member is the member of type T and is initialized as though by
> std::bit_cast<T>(r). If there are multiple such members, the active member
> is the first such member accessed by the program, or otherwise an
> unspecified member of that type. If the union has a member of a reference
> type, the behaviour is undefined.
>
> reference_wrapper:
> * If r is an expression of type std::reference_wrapper<T>and U is
> (possibly differently cv-qualified) T, then the expression
> std::bit_cast<U*>(r), shall be well-formed and an equivalent expression to
> const_cast<U*>(std::addressof(static_cast<T&>(r)))
> * If r is an expression of type T*, which points to an object, and U is
> (possibly differently cv-qualified) T, then the expression
> std::bit_cast<std::reference_wrapper<U>>(r) shall be well-formed, and an
> equivalent expression to std::ref(*const_cast<U*>(r)). If r does not point
> to an object, the behaviour is undefined. If T is an incomplete type other
> than (possibly cv-qualified) void or an array of unknown bound, the
> expression treats T as though it was completed. If T is an array of unknown
> bound, the expression treats T as though it were an array with length 1.
>
>
> Unresolved Questions:
> std::optional<std::reference_wrapper<T>> is currently not treated
> separately. It may be nice to apply a similar pair of rules as for regular
> std::reference_wrapper, with the additional clause that an empty optional
> bit_casts to a null pointer and the reverse. However, unlike the
> reference_wrapper requirements which are effective in libstdc++ and libc++
> (because its implemented with a single raw pointer member),
> std::optional<std::reference_wrapper<T>> is not implemented as such (though
> libc++ interestingly implements the storage for std::optional<T&> in case
> the standard ever decides to permit it, and this is done simply using a raw
> pointer). A possibility is not enforcing well-formedness, but keeping the
> behaviour if it is well-formed.
>
> These rules allow you to construct union values (provided the union is the
> same size as the member). Would it be reasonable to also allow the
> construction of Trivially Copyable, Standard Layout structure types with a
> single member of the source type?
>
> None of these rules cover transitive bit casts. Would it be reasonable to
> require such over all of these rules, or just a limited case (for example,
> void*->reference_wrapper<char>)?
>
> The reference_wrapper rules don't allow void*->reference_wrapper<void>. Is
> there a reason to allow this? Can reference_wrapper<void> exist?
> --
> Std-Proposals mailing list
> Std-Proposals_at_[hidden]
> https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals
>