Std::bit_cast-Auffüllung und undefiniertes Verhalten ⇐ C++

[Anonymous]

Ich möchte wissen, wie man std::bit_cast auf wohldefinierte Weise verwendet, insbesondere bei Vorhandensein unbestimmter Bits. Wann ist die Verwendung von std::bit_cast definiertes Verhalten, wann ist es undefiniertes Verhalten?
Daher benötige ich eine Klarstellung zum Wortlaut von cppreference zu std::bit_cast.
Ich verstehe die Bedeutung des folgenden Absatzes nicht:

Für jedes Bit in der Wertdarstellung des Ergebnisses, das unbestimmt ist, hat das kleinste Objekt, das dieses Bit enthält, eine Unbestimmtheit Wert; Das Verhalten ist undefiniert, es sei denn, das Objekt ist vom Typ unsigned char oder std::byte. Das Ergebnis enthält ansonsten keine unbestimmten Werte.

Wenn die Eingabe (

Code: Select all

From

) enthält unbestimmte Bits (merklich Füllbits). Was sind die erwähnten Objekte und was bedeutet die Unterscheidung nach ihrem Typ (

Code: Select all

std::byte

vs other)?
Lassen Sie uns ein Beispiel schreiben (keinen tatsächlichen Anwendungsfall, sondern lediglich eine Veranschaulichung einer Situation mit unbestimmten Bits):

Code: Select all

#include 
#include 
struct S40 {
std::uint8_t a = 0x51;
std::uint32_t b = 0xa353c0f1;
};
struct S3 {
std::uint8_t a : 3;
};

int main() {
S40 s40;
std::uint64_t a64 = std::bit_cast(s40);
// (3) on tested compilers, a64 is 0xa353c0f1XXXXXX51 where X is indeterminate half-byte
S3 s3;
s3.a = 0b101;
std::uint8_t a8 = std::bit_cast(s3);
// (4) on tested compilers, a8 is xxxxx101, x being indeterminate bits
}

Live

In diesem Beispiel spiele ich mit der Ausrichtung, um Auffüllbits zwischen a und b zu induzieren.

(Beachten Sie, wie Clang tatsächlich Müll in die Auffüllbits wirft).

Ist die Produktion von a64 undefiniertes Verhalten?

mit S3 habe ich es versucht Emulieren Sie einen weniger als 1-Byte-Typ mit Füllbits.

Ist die Produktion von a8 ein definiertes Verhalten, während sein Wert aufgrund des Vorhandenseins unbestimmter Bits unbestimmt ist?

Für die Aufzeichnung lasse ich hier das ursprüngliche Beispiel, das versucht hat, den möglichen Unterschied zwischen dem 1-Byte-Fall und den anderen Situationen hervorzuheben. Aber wie in einer Antwort zu Recht betont wurde, zeigt es nichts, da die Übergabe eines Bitfelds innerhalb von std::bit_cast eine Umwandlung in einen vollständig definierten Wert (des zugrunde liegenden Typs) implizierte.

Code: Select all

#include 
#include 

struct S9 {
std::uint16_t a : 9;
};
struct S7 {
std::uint8_t a : 7;
};

int main() {
S9 s9;
s9.a = 42;
std::uint16_t a16 = std::bit_cast(s9.a);
// (1) a16 may be xxxxxxx000101010, x being indeterminate bits
S7 s7;
s7.a = 42;
std::uint8_t a8 = std::bit_cast(s7.a);
// (2) a8 may be x0101010, x being indeterminate bits
}

Von welchen Objekten sprechen wir?

Wird die Produktion von a8 als definiertes Verhalten betrachtet, während sein Wert unbestimmt ist?

Wird die Produktion von a16 als undefiniertes Verhalten betrachtet, während sein Wert unbestimmt ist?