WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Suffixe für vorzeichenlose und hexadezimale Ganzzahlliterale in C++

Unterscheide die Zahlenbasis, den Literaltyp und den Rechentyp. Das Suffix `u` allein garantiert weder 32 Bit noch erzwingt es 8-Bit-Arithmetik.

Version: ISO C++23; implementation support may vary

Syntax

0x<hex-digits><optional-integer-suffix> or 0X<hex-digits><optional-integer-suffix>
Suffix components: u/U (unsigned), l/L (long), ll/LL (long long), z/Z (size, since C++23).
Use a single component or combine u/U with exactly one of l/L, ll/LL, or z/Z, in either order. lL and Ll are not valid long-long suffixes.
Examples: 0xFF, 0xFFu, 0xFFUL, 0xFFULL, 0xFFuz, 255u.

Das Präfix 0x oder 0X steht für Basis 16, nicht für einen vorzeichenlosen Typ. Der Compiler wählt aus der Liste für Basis und Suffix den ersten Typ, der den Wert darstellen kann. Ohne Suffix lautet die Liste für Dezimalliterale int, long, long long; für Hexadezimalliterale int, unsigned int, long, unsigned long, long long, unsigned long long. Daher hat 0xFF den Typ int.

Kann kein Typ aus der Liste den Wert darstellen und hat das Literal kein Größensuffix (z oder Z, mit oder ohne u bzw. U), darf der Compiler einen erweiterten Ganzzahltyp verwenden, der den Wert darstellen kann. Enthält die Liste nur vorzeichenbehaftete oder nur vorzeichenlose Typen, muss der erweiterte Typ zur selben Gruppe gehören. Enthält die Liste beide Gruppen, ist ein erweiterter Typ mit oder ohne Vorzeichen zulässig. Kann kein zulässiger Typ den Wert darstellen, ist das Programm nicht wohlgeformt.

Bei u oder U lautet die Reihenfolge unsigned int, unsigned long, unsigned long long. 0xFFu und 255u haben denselben Wert und denselben Typ unsigned int, der nicht 32 Bit breit sein muss. Bei UL folgt auf unsigned long bei Bedarf unsigned long long. Bei ULL steht unsigned long long an erster Stelle. Der Bestandteil u darf vor oder nach dem anderen Bestandteil stehen; ll und LL sind gültig, lL und Ll nicht.

Seit C++23 ergibt uz den Typ std::size_t, sofern der Wert hineinpasst. z allein prüft zuerst den entsprechenden vorzeichenbehafteten Typ; nur bei nichtdezimalen Literalen ist std::size_t der nächste Kandidat. Die Compilerunterstützung für das Größensuffix kann variieren. Keines dieser Suffixe garantiert eine exakte Bitbreite. Für genau 32 Bit verwende std::uint32_t aus <cstdint>, sofern verfügbar.

Der Literaltyp ist nicht unbedingt der Rechentyp. Beim eingebauten + werden Ganzzahloperanden mit niedrigerem Rang als int zu int befördert, wenn dieser ihren gesamten Wertebereich abdeckt, sonst zu unsigned int. std::uint8_t wird zu int befördert; die Addition von 1 zu std::uint16_t kann int oder unsigned int ergeben. Die üblichen arithmetischen Konvertierungen bestimmen den gemeinsamen Typ: byte + 1 ergibt int, byte + 1u dagegen unsigned int.

Die Addition ergibt zunächst 256. Erst die Konvertierung nach std::uint8_t ergibt modulo 256 den Wert 0; das ist kein Überlauf einer 8-Bit-Rechnung. Ist std::uint8_t ein Alias für unsigned char, wählt std::cout << stored die Zeichenüberladung. static_cast<unsigned int>(stored) führt zur numerischen Ausgabe.

Beispiele

#include <cstddef>
#include <cstdint>
#include <iostream>
#include <type_traits>

static_assert(std::is_same_v<decltype(0xFFu), unsigned int>);
static_assert(std::is_same_v<decltype(0xFFUL), unsigned long>);
static_assert(std::is_same_v<decltype(0xFFULL), unsigned long long>);
static_assert(std::is_same_v<decltype(0xFFuz), std::size_t>);

int main() {
    std::uint8_t byte{0xFFu};
    std::uint16_t word{40'000};

    static_assert(std::is_same_v<decltype(byte + 1), int>);
    static_assert(std::is_same_v<decltype(byte + 1u), unsigned int>);

    auto sum = byte + 1;
    auto stored = static_cast<std::uint8_t>(sum);
    std::cout << sum << ' ' << static_cast<unsigned int>(stored)
              << ' ' << (word + 1) << '\n';
}

Ergebnis

256 0 40001

Das Beispiel benötigt den C++23-Modus mit `uz`-Unterstützung sowie `std::uint8_t` und `std::uint16_t`. Die erwartete Zeile `256 0 40001` zeigt die Summe, den konvertierten Wert und das Ergebnis der Addition mit einem 16-Bit-Operanden.

Zugehörige Lektionen

  • C++ · Lektion 17 · Fortgeschritten · Version: 3

Quellen