Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / C++

Pripone nepredznačenih in šestnajstiških celoštevilskih literalov v C++

Loči osnovo zapisa, tip literala in tip izračuna. Sama pripona `u` ne zagotavlja širine 32 bitov in ne vsili 8-bitne aritmetike.

Različica: ISO C++23; implementation support may vary

Sintaksa

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 ali 0X označuje osnovo 16, ne nepredznačenega tipa. Prevajalnik izbere prvi tip na seznamu za dano osnovo in pripono, ki lahko predstavi vrednost. Brez pripone je desetiški seznam int, long, long long, šestnajstiški pa int, unsigned int, long, unsigned long, long long, unsigned long long. Zato ima 0xFF tip int.

Če noben tip na seznamu ne more predstaviti vrednosti in literal nima velikostne pripone (z ali Z, z dodatkom u ali U ali brez njega), lahko prevajalnik uporabi razširjen celoštevilski tip, ki vrednost lahko predstavi. Če so na seznamu samo predznačeni ali samo nepredznačeni tipi, mora razširjeni tip spadati v isto skupino. Če seznam vsebuje obe skupini, je razširjeni tip lahko predznačen ali nepredznačen. Če noben dovoljen tip ne more predstaviti vrednosti, program ni pravilno oblikovan.

Pri u ali U je vrstni red unsigned int, unsigned long, unsigned long long. 0xFFu in 255u imata isto vrednost in isti tip, unsigned int, ki ni nujno 32-biten. UL začne z unsigned long in po potrebi preide na unsigned long long. ULL začne z unsigned long long. Del u je lahko pred drugim delom ali za njim; ll in LL sta veljavna, lL in Ll pa ne.

Od C++23 uz da tip std::size_t, če ta lahko predstavi vrednost. Samostojni z najprej preizkusi ustrezni predznačeni tip; std::size_t je naslednji kandidat samo pri nedesetiškem literalu. Podpora za velikostno pripono je odvisna od prevajalnika. Nobena od teh pripon ne zagotavlja natančne širine; za natanko 32 bitov uporabi std::uint32_t iz <cstdint>, če je na voljo.

Tip literala ni nujno tip izračuna. Pri vgrajenem operatorju + se celoštevilski operandi z nižjim pretvorbenim rangom od int povišajo v int, če ta pokriva njihov celotni razpon, sicer v unsigned int. std::uint8_t se poviša v int; prištetje 1 k std::uint16_t lahko da int ali unsigned int. Običajne aritmetične pretvorbe določijo skupni tip: byte + 1 da int, byte + 1u pa unsigned int.

Seštevanje najprej da 256. Šele pretvorba v std::uint8_t da 0 po modulu 256; ne gre za prekoračitev pri 8-bitnem računanju. Če je std::uint8_t vzdevek za unsigned char, std::cout << stored izbere preobremenitev za izpis znaka. static_cast<unsigned int>(stored) izbere številski izpis.

Primeri

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

Rezultat

256 0 40001

Primer zahteva način C++23 s podporo za `uz` ter tipa `std::uint8_t` in `std::uint16_t`. Pričakovana vrstica `256 0 40001` prikaže vsoto, pretvorjeno vrednost in rezultat seštevanja s 16-bitnim operandom.

Povezane lekcije

  • C++ · Lekcija 17 · Napredna · Različica: 3

Viri