Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

Sufijos de literales enteros sin signo y hexadecimales en C++

Distingue la base del literal, su tipo y el tipo del cálculo. El sufijo `u` por sí solo no garantiza 32 bits ni impone una aritmética de 8 bits.

Versión: ISO C++23; implementation support may vary

Sintaxis

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.

El prefijo 0x o 0X indica base 16, no un tipo sin signo. El compilador elige el primer tipo de la lista para la base y el sufijo que pueda representar el valor. Sin sufijo, la lista decimal es int, long, long long; la hexadecimal es int, unsigned int, long, unsigned long, long long, unsigned long long. Por tanto, 0xFF es de tipo int.

Si ningún tipo de la lista puede representar el valor y el literal no lleva sufijo de tamaño (z o Z, con o sin u o U), el compilador puede usar un tipo entero extendido que lo represente. Si la lista solo contiene tipos con signo o solo tipos sin signo, el tipo extendido debe pertenecer a la misma categoría. Si contiene ambas categorías, el tipo extendido puede ser con signo o sin signo. Si ningún tipo permitido puede representar el valor, el programa está mal formado.

Con u o U, el orden es unsigned int, unsigned long, unsigned long long. 0xFFu y 255u tienen el mismo valor y el mismo tipo, unsigned int, que no tiene por qué ser de 32 bits. UL empieza por unsigned long y pasa a unsigned long long si es necesario. ULL empieza por unsigned long long. El componente u puede ir antes o después del otro; ll y LL son válidos, pero lL y Ll no.

Desde C++23, uz da std::size_t si el valor cabe. z por sí solo prueba primero el tipo con signo correspondiente; solo para un literal no decimal es std::size_t el siguiente candidato. La compatibilidad con el sufijo de tamaño depende del compilador. Ninguno de estos sufijos garantiza un ancho exacto; para exactamente 32 bits, usa std::uint32_t de <cstdint> si está disponible.

El tipo del literal no tiene por qué ser el del cálculo. Con el operador + incorporado, los operandos enteros de rango de conversión inferior al de int se promocionan a int si este abarca todo su intervalo de valores; de lo contrario, a unsigned int. std::uint8_t se promociona a int; sumar 1 a un std::uint16_t puede producir int o unsigned int. Las conversiones aritméticas habituales determinan el tipo común: byte + 1 da int, mientras que byte + 1u da unsigned int.

La suma produce primero 256. Solo al convertir a std::uint8_t se obtiene 0 módulo 256; no es un desbordamiento en una operación de 8 bits. Si std::uint8_t es un alias de unsigned char, std::cout << stored selecciona la sobrecarga para caracteres. static_cast<unsigned int>(stored) selecciona la salida numérica.

Ejemplos

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

Resultado

256 0 40001

El ejemplo requiere el modo C++23 con soporte para `uz` y los tipos `std::uint8_t` y `std::uint16_t`. La línea esperada `256 0 40001` muestra la suma, el valor convertido y el resultado de la suma con un operando de 16 bits.

Lecciones relacionadas

  • C++ · Lección 17 · Avanzado · Versión: 3

Fuentes