Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Sufiksy literałów całkowitych bez znaku i literałów szesnastkowych w C++

Odróżnij podstawę zapisu od typu literału i typu działania. Sam sufiks `u` nie gwarantuje 32 bitów ani nie wymusza arytmetyki 8-bitowej.

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

Składnia

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.

Prefiks 0x lub 0X oznacza zapis szesnastkowy, a nie typ bez znaku. Kompilator wybiera pierwszy typ z listy dla danej podstawy i sufiksu, który mieści wartość. Bez sufiksu lista dziesiętna to int, long, long long; szesnastkowa to int, unsigned int, long, unsigned long, long long, unsigned long long. Dlatego 0xFF ma typ int.

Jeśli wartość nie mieści się w żadnym typie z listy, a literał nie ma sufiksu rozmiaru (z lub Z, także w połączeniu z u lub U), kompilator może użyć rozszerzonego typu całkowitego, który mieści tę wartość. Jeśli lista zawiera wyłącznie typy ze znakiem albo wyłącznie typy bez znaku, typ rozszerzony musi należeć do tej samej grupy. Jeśli lista zawiera oba rodzaje typów, dopuszczalny jest typ rozszerzony ze znakiem lub bez znaku. Jeśli żaden dozwolony typ nie mieści wartości, program jest niepoprawny.

Dla u lub U kolejność to unsigned int, unsigned long, unsigned long long. 0xFFu i 255u mają tę samą wartość i typ unsigned int, którego szerokość nie musi wynosić 32 bitów. Przy UL lista zaczyna się od unsigned long i przechodzi do unsigned long long, jeśli wartość się nie mieści. Przy ULL zaczyna się od unsigned long long. Składnik u może stać przed lub po drugim składniku; ll i LL są poprawne, ale lL i Ll nie.

Od C++23 uz oznacza std::size_t, jeśli wartość się mieści. Samo z najpierw wskazuje odpowiadający mu typ ze znakiem; tylko przy zapisie niedziesiętnym kolejnym kandydatem jest std::size_t. Obsługa sufiksu rozmiaru zależy od kompilatora. Żaden z tych sufiksów nie gwarantuje dokładnej szerokości; jeśli potrzeba dokładnie 32 bitów, użyj std::uint32_t z <cstdint>, o ile jest dostępny.

Typ literału nie jest jeszcze typem całego działania. Przy wbudowanym + operandy całkowite o randze niższej niż int promują się do int, jeśli mieści on cały zakres ich typu, w przeciwnym razie do unsigned int. std::uint8_t promuje się do int; dla std::uint16_t wynik dodawania z 1 może mieć typ int lub unsigned int. Zwykłe konwersje arytmetyczne wyznaczają wspólny typ: byte + 1 daje int, a byte + 1u daje unsigned int.

Dodawanie najpierw daje 256. Dopiero konwersja do std::uint8_t daje 0 modulo 256; nie jest to przepełnienie w działaniu 8-bitowym. Gdy std::uint8_t jest aliasem unsigned char, std::cout << stored wybiera przeciążenie znakowe. static_cast<unsigned int>(stored) wybiera wypisywanie liczby.

Przykłady

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

Wynik

256 0 40001

Przykład wymaga trybu C++23 z obsługą `uz` oraz typów `std::uint8_t` i `std::uint16_t`. Oczekiwany wiersz `256 0 40001` pokazuje sumę, wartość po konwersji i wynik dodawania z operandem 16-bitowym.

Powiązane lekcje

  • C++ · Lekcja 17 · Zaawansowany · Wersja: 3

Źródła