KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Suffixen voor unsigned en hexadecimale integerliteralen in C++

Houd het grondtal, het type van het literaal en het rekentype uit elkaar. Het suffix `u` garandeert geen 32 bits en dwingt geen 8-bits rekenwerk af.

Versie: 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.

Het voorvoegsel 0x of 0X geeft grondtal 16 aan, niet een type zonder teken. De compiler kiest uit de lijst voor het grondtal en het suffix het eerste type dat de waarde kan weergeven. Zonder suffix is de decimale lijst int, long, long long; de hexadecimale lijst is int, unsigned int, long, unsigned long, long long, unsigned long long. Daarom heeft 0xFF type int.

Als geen enkel type uit de lijst de waarde kan weergeven en het literaal geen groottesuffix heeft (z of Z, met of zonder u of U), mag de compiler een uitgebreid geheelgetaltype gebruiken dat de waarde wel kan weergeven. Bevat de lijst alleen typen met teken of alleen typen zonder teken, dan moet het uitgebreide type tot dezelfde groep behoren. Bevat de lijst beide groepen, dan mag het uitgebreide type met of zonder teken zijn. Als geen enkel toegestaan type de waarde kan weergeven, is het programma niet geldig.

Bij u of U is de volgorde unsigned int, unsigned long, unsigned long long. 0xFFu en 255u hebben dezelfde waarde en hetzelfde type, unsigned int, dat niet per se 32 bits breed is. UL begint bij unsigned long en gaat zo nodig door naar unsigned long long. ULL begint bij unsigned long long. Het onderdeel u mag voor of na het andere onderdeel staan; ll en LL zijn geldig, maar lL en Ll niet.

Sinds C++23 geeft uz het type std::size_t als de waarde past. z alleen probeert eerst het bijbehorende type met teken; alleen bij een niet-decimaal literaal is std::size_t de volgende kandidaat. Ondersteuning voor het groottesuffix kan per compiler verschillen. Geen van deze suffixen garandeert een exacte breedte. Gebruik voor precies 32 bits std::uint32_t uit <cstdint>, indien beschikbaar.

Het type van het literaal is niet noodzakelijk het rekentype. Bij de ingebouwde + worden gehele operanden met een lagere rang dan int gepromoveerd naar int als dat hun hele waardebereik kan weergeven, anders naar unsigned int. std::uint8_t promoveert naar int; 1 optellen bij een std::uint16_t kan int of unsigned int opleveren. De gebruikelijke rekenkundige conversies bepalen het gemeenschappelijke type: byte + 1 geeft int, terwijl byte + 1u unsigned int geeft.

De optelling levert eerst 256 op. Pas de conversie naar std::uint8_t levert 0 modulo 256 op; dit is geen overloop in een 8-bits berekening. Als std::uint8_t een alias voor unsigned char is, kiest std::cout << stored de tekenoverload. Met static_cast<unsigned int>(stored) kies je numerieke uitvoer.

Voorbeelden

#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';
}

Resultaat

256 0 40001

Het voorbeeld vereist C++23-modus met ondersteuning voor `uz` en de typen `std::uint8_t` en `std::uint16_t`. De verwachte regel `256 0 40001` toont de som, de geconverteerde waarde en het resultaat van de optelling met een 16-bits operand.

Gerelateerde lessen

  • C++ · Les 17 · Gevorderd · Versie: 3

Bronnen