Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

Přípony celočíselných literálů bez znaménka a šestnáctkových literálů v C++

Rozlišuj základ zápisu, typ literálu a typ výpočtu. Samotná přípona `u` nezaručuje šířku 32 bitů ani nevynucuje osmibitovou aritmetiku.

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

Syntaxe

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.

Předpona 0x nebo 0X označuje základ 16, nikoli typ bez znaménka. Překladač vybere první typ ze seznamu pro daný základ a příponu, který dokáže hodnotu reprezentovat. Bez přípony je seznam pro desítkové literály int, long, long long; pro šestnáctkové int, unsigned int, long, unsigned long, long long, unsigned long long. Proto má 0xFF typ int.

Pokud žádný typ ze seznamu nedokáže hodnotu reprezentovat a literál nemá příponu pro typ velikosti (z nebo Z, s u či U nebo bez nich), může překladač použít rozšířený celočíselný typ, který hodnotu reprezentovat dokáže. Obsahuje-li seznam pouze typy se znaménkem nebo pouze typy bez znaménka, musí rozšířený typ patřit do stejné skupiny. Obsahuje-li seznam obě skupiny, rozšířený typ může být se znaménkem i bez znaménka. Pokud hodnotu nedokáže reprezentovat žádný povolený typ, program není správně utvořený.

S příponou u nebo U je pořadí unsigned int, unsigned long, unsigned long long. 0xFFu a 255u mají stejnou hodnotu a stejný typ unsigned int, který nemusí být 32bitový. UL začíná typem unsigned long a v případě potřeby přejde na unsigned long long. ULL začíná typem unsigned long long. Část u může stát před druhou částí nebo za ní; ll a LL jsou platné, lL a Ll nikoli.

Od C++23 dává uz typ std::size_t, pokud se do něj hodnota vejde. Samotné z nejprve zkouší odpovídající typ se znaménkem; std::size_t je dalším kandidátem jen u nedesítkového literálu. Podpora přípony pro typ velikosti závisí na překladači. Žádná z těchto přípon nezaručuje přesnou šířku; pro přesně 32 bitů použij std::uint32_t z <cstdint>, pokud je dostupný.

Typ literálu nemusí být typem výpočtu. U vestavěného + se celočíselné operandy s nižší konverzní hodností než int povýší na int, pokud pojme celý jejich rozsah, jinak na unsigned int. std::uint8_t se povýší na int; přičtení 1 k std::uint16_t může dát int nebo unsigned int. Obvyklé aritmetické konverze určí společný typ: byte + 1 dává int, zatímco byte + 1u dává unsigned int.

Součet nejprve vyjde 256. Teprve převod na std::uint8_t dá 0 modulo 256; nejde o přetečení při osmibitovém výpočtu. Pokud je std::uint8_t alias typu unsigned char, std::cout << stored vybere přetížení pro znak. static_cast<unsigned int>(stored) zvolí číselný výstup.

Příklady

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

Výsledek

256 0 40001

Příklad vyžaduje režim C++23 s podporou `uz` a typy `std::uint8_t` a `std::uint16_t`. Očekávaný řádek `256 0 40001` ukazuje součet, převedenou hodnotu a výsledek sčítání se 16bitovým operandem.

Související lekce

  • C++ · Lekce 17 · Pokročilá · Verze: 3

Zdroje