Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C++

Prípony celočíselných literálov bez znamienka a šestnástkových literálov v C++

Rozlišuj základ zápisu, typ literálu a typ výpočtu. Samotná prípona `u` nezaručuje šírku 32 bitov ani nevynucuje 8-bitovú aritmetiku.

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

Predpona 0x alebo 0X označuje základ 16, nie typ bez znamienka. Prekladač vyberie prvý typ zo zoznamu pre daný základ a príponu, ktorý dokáže reprezentovať hodnotu. Bez prípony je zoznam pre desiatkové literály int, long, long long; pre šestnástkové int, unsigned int, long, unsigned long, long long, unsigned long long. Preto má 0xFF typ int.

Ak žiadny typ zo zoznamu nedokáže reprezentovať hodnotu a literál nemá príponu pre typ veľkosti (z alebo Z, s u či U alebo bez nich), prekladač môže použiť rozšírený celočíselný typ, ktorý hodnotu dokáže reprezentovať. Ak zoznam obsahuje len typy so znamienkom alebo len typy bez znamienka, rozšírený typ musí patriť do rovnakej skupiny. Ak zoznam obsahuje obe skupiny, rozšírený typ môže byť so znamienkom alebo bez znamienka. Ak hodnotu nedokáže reprezentovať žiadny povolený typ, program nie je správne utvorený.

Pri u alebo U je poradie unsigned int, unsigned long, unsigned long long. 0xFFu a 255u majú rovnakú hodnotu aj typ unsigned int, ktorý nemusí mať 32 bitov. UL začína typom unsigned long a podľa potreby prejde na unsigned long long. ULL začína typom unsigned long long. Časť u môže byť pred druhou časťou alebo za ňou; ll a LL sú platné, lL a Ll nie.

Od C++23 dáva uz typ std::size_t, ak sa doň hodnota zmestí. Samotné z najprv skúša zodpovedajúci typ so znamienkom; std::size_t je ďalším kandidátom len pri nedesiatkovom literáli. Podpora prípony pre typ veľkosti závisí od prekladača. Žiadna z týchto prípon nezaručuje presnú šírku; ak potrebuješ presne 32 bitov, použi std::uint32_t z <cstdint>, ak je dostupný.

Typ literálu nemusí byť typom výpočtu. Pri vstavanom + sa celočíselné operandy s nižšou konverznou hodnosťou než int povýšia na int, ak pokryje celý ich rozsah, inak na unsigned int. std::uint8_t sa povýši na int; pripočítanie 1 k std::uint16_t môže dať int alebo unsigned int. Zvyčajné aritmetické konverzie určia spoločný typ: byte + 1 dáva int, kým byte + 1u dáva unsigned int.

Sčítanie najprv dá 256. Až konverzia na std::uint8_t dá 0 modulo 256; nejde o pretečenie pri 8-bitovom výpočte. Ak je std::uint8_t alias typu unsigned char, std::cout << stored vyberie preťaženie pre znak. static_cast<unsigned int>(stored) zvolí číselný výstup.

Prí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ýsledok

256 0 40001

Príklad vyžaduje režim C++23 s podporou `uz` a typy `std::uint8_t` a `std::uint16_t`. Očakávaný riadok `256 0 40001` ukazuje súčet, skonvertovanú hodnotu a výsledok sčítania so 16-bitovým operandom.

Súvisiace lekcie

  • C++ · Lekcia 17 · Pokročilá · Verzia: 3

Zdroje