Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Suffixes des littéraux entiers non signés et hexadécimaux en C++

Distinguez la base du littéral, son type et le type du calcul. Le suffixe `u` seul ne garantit pas 32 bits et n’impose pas un calcul sur 8 bits.

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

Syntaxe

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.

Le préfixe 0x ou 0X indique la base 16, pas un type non signé. Le compilateur choisit, dans la liste correspondant à la base et au suffixe, le premier type capable de représenter la valeur. Sans suffixe, la liste décimale est int, long, long long ; la liste hexadécimale est int, unsigned int, long, unsigned long, long long, unsigned long long. Ainsi, 0xFF est de type int.

Si aucun type de la liste ne peut représenter la valeur et que le littéral n’a pas de suffixe de taille (z ou Z, avec ou sans u ou U), le compilateur peut utiliser un type entier étendu capable de la représenter. Si la liste ne contient que des types signés ou que des types non signés, le type étendu doit appartenir à la même catégorie. Si elle contient les deux catégories, le type étendu peut être signé ou non signé. Si aucun type autorisé ne peut représenter la valeur, le programme est mal formé.

Avec u ou U, l’ordre est unsigned int, unsigned long, unsigned long long. 0xFFu et 255u ont la même valeur et le même type, unsigned int, dont la largeur n’est pas forcément de 32 bits. UL commence par unsigned long, puis essaie unsigned long long si nécessaire. ULL commence par unsigned long long. L’élément u peut précéder ou suivre l’autre ; ll et LL sont valides, contrairement à lL et Ll.

Depuis C++23, uz donne std::size_t si la valeur est représentable. z seul essaie d’abord le type signé correspondant ; std::size_t n’est le candidat suivant que pour un littéral non décimal. La prise en charge du suffixe de taille dépend du compilateur. Aucun de ces suffixes ne garantit une largeur exacte ; pour exactement 32 bits, utilisez std::uint32_t de <cstdint> s’il est disponible.

Le type du littéral n’est pas nécessairement celui du calcul. Avec le + intégré, les opérandes entiers de rang inférieur à int sont promus en int si ce type couvre toute leur plage, sinon en unsigned int. std::uint8_t est promu en int ; ajouter 1 à un std::uint16_t peut donner int ou unsigned int. Les conversions arithmétiques usuelles déterminent le type commun : byte + 1 donne int, tandis que byte + 1u donne unsigned int.

L’addition produit d’abord 256. Seule la conversion en std::uint8_t donne 0 modulo 256 ; il ne s’agit pas d’un dépassement lors d’un calcul sur 8 bits. Lorsque std::uint8_t est un alias de unsigned char, std::cout << stored sélectionne la surcharge pour les caractères. static_cast<unsigned int>(stored) sélectionne l’affichage numérique.

Exemples

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

Résultat

256 0 40001

L’exemple exige le mode C++23 avec la prise en charge de `uz`, ainsi que `std::uint8_t` et `std::uint16_t`. La ligne attendue `256 0 40001` présente la somme, la valeur convertie et le résultat de l’addition avec un opérande sur 16 bits.

Leçons associées

  • C++ · Leçon 17 · Avancé · Version : 3

Sources