Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Suffissi dei letterali interi senza segno ed esadecimali in C++

Distingui la base del letterale, il suo tipo e il tipo del calcolo. Il solo suffisso `u` non garantisce 32 bit e non impone l’aritmetica a 8 bit.

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

Sintassi

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.

Il prefisso 0x o 0X indica la base 16, non un tipo senza segno. Il compilatore sceglie il primo tipo dell’elenco relativo alla base e al suffisso che può rappresentare il valore. Senza suffisso, l’elenco decimale è int, long, long long; quello esadecimale è int, unsigned int, long, unsigned long, long long, unsigned long long. Quindi 0xFF è di tipo int.

Se nessun tipo dell’elenco può rappresentare il valore e il letterale non ha un suffisso di dimensione (z o Z, con o senza u o U), il compilatore può usare un tipo intero esteso che rappresenti il valore. Se l’elenco contiene solo tipi con segno o solo tipi senza segno, il tipo esteso deve appartenere alla stessa categoria. Se l’elenco contiene entrambe le categorie, il tipo esteso può essere con o senza segno. Se nessun tipo ammesso può rappresentare il valore, il programma è mal formato.

Con u o U l’ordine è unsigned int, unsigned long, unsigned long long. 0xFFu e 255u hanno lo stesso valore e lo stesso tipo, unsigned int, che non è necessariamente a 32 bit. UL parte da unsigned long e passa a unsigned long long se necessario. ULL parte da unsigned long long. Il componente u può precedere o seguire l’altro; ll e LL sono validi, ma lL e Ll no.

Da C++23, uz dà std::size_t se il valore è rappresentabile. z da solo prova prima il tipo con segno corrispondente; solo per un letterale non decimale il candidato successivo è std::size_t. Il supporto del suffisso di dimensione può variare a seconda del compilatore. Nessuno di questi suffissi garantisce una larghezza esatta; per avere esattamente 32 bit, usa std::uint32_t da <cstdint> se disponibile.

Il tipo del letterale non coincide necessariamente con quello del calcolo. Con il + predefinito, gli operandi interi di rango inferiore a int vengono promossi a int se può rappresentare tutto il loro intervallo, altrimenti a unsigned int. std::uint8_t viene promosso a int; sommare 1 a uno std::uint16_t può dare int o unsigned int. Le conversioni aritmetiche usuali determinano il tipo comune: byte + 1 dà int, mentre byte + 1u dà unsigned int.

La somma produce prima 256. Solo la conversione a std::uint8_t dà 0 modulo 256; non è un overflow durante un’operazione a 8 bit. Quando std::uint8_t è un alias di unsigned char, std::cout << stored seleziona l’overload per i caratteri. static_cast<unsigned int>(stored) seleziona la stampa numerica.

Esempi

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

Risultato

256 0 40001

L’esempio richiede la modalità C++23 con supporto per `uz` e i tipi `std::uint8_t` e `std::uint16_t`. La riga attesa `256 0 40001` mostra la somma, il valore convertito e il risultato dell’addizione con un operando a 16 bit.

Lezioni correlate

  • C++ · Lezione 17 · Avanzato · Versione: 3

Fonti