Integer literal

Permet d'utiliser directement des valeurs de type entier dans les expressions.

Syntaxe

Un littéral entier a la forme

où

• decimal-literal est un chiffre décimal non nul ( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ), suivi de zéro ou plusieurs chiffres décimaux ( 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 )
• octal-literal est le chiffre zéro ( 0 ) suivi de zéro ou plusieurs chiffres octaux ( 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 )
• hex-literal est la séquence de caractères 0x ou la séquence de caractères 0X suivie d'un ou plusieurs chiffres hexadécimaux ( 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , a , A , b , B , c , C , d , D , e , E , f , F )
• binary-literal est la séquence de caractères 0b ou la séquence de caractères 0B suivie d'un ou plusieurs chiffres binaires ( 0 , 1 )
• integer-suffix , s'il est fourni, peut contenir un ou plusieurs des éléments suivants (si les deux sont fournis, ils peuvent apparaître dans n'importe quel ordre) :

• suffixe non signé (le caractère u ou le caractère U )
• l'un des

• suffixe long (le caractère l ou le caractère L )

Un littéral entier (comme tout littéral) est une expression primaire .

Explication

Le premier chiffre d'un littéral entier est le plus significatif.

Exemple. Les variables suivantes sont initialisées avec la même valeur :

int d = 42;
int o = 052;
int x = 0x2a;
int X = 0X2A;
int b = 0b101010; // C++14

Exemple. Les variables suivantes sont également initialisées avec la même valeur :

unsigned long long l1 = 18446744073709550592ull;       // C++11
unsigned long long l2 = 18'446'744'073'709'550'592llu; // C++14
unsigned long long l3 = 1844'6744'0737'0955'0592uLL;   // C++14
unsigned long long l4 = 184467'440737'0'95505'92LLU;   // C++14

Le type du littéral

Le type du littéral entier est le premier type dans lequel la valeur peut tenir, dans la liste des types qui dépend de la base numérique et du integer-suffix utilisé :

Si la valeur du littéral entier qui n'a pas de suffixe de taille (depuis C++23) est trop grande pour tenir dans l'un des types autorisés par la combinaison suffixe/base et que le compilateur prend en charge un type entier étendu (tel que __int128 ) qui peut représenter la valeur du littéral, le littéral peut se voir attribuer ce type entier étendu — sinon le programme est mal formé.

Notes

Les lettres dans les littéraux entiers ne sont pas sensibles à la casse : 0xDeAdBeEfU et 0XdeadBEEFu représentent le même nombre (une exception est le long-long-suffix , qui est soit ll ou LL , jamais lL ou Ll ) (depuis C++11) .

Il n'existe pas de littéraux entiers négatifs. Des expressions telles que - 1 appliquent l' opérateur unaire moins à la valeur représentée par le littéral, ce qui peut impliquer des conversions de type implicites.

En C avant C99 (mais pas en C++), les valeurs décimales non suffixées qui ne rentrent pas dans un long int peuvent avoir le type unsigned long int .

En raison du maximal munch , les littéraux entiers hexadécimaux se terminant par e et E , lorsqu'ils sont suivis des opérateurs + ou - , doivent être séparés de l'opérateur par un espace ou des parenthèses dans le code source :

auto x = 0xE+2.0;   // erreur
auto y = 0xa+2.0;   // OK
auto z = 0xE +2.0;  // OK
auto q = (0xE)+2.0; // OK

Sinon, un seul jeton de prétraitement numérique invalide est formé, ce qui entraîne l'échec de l'analyse ultérieure.

Exemple

#include <cstddef>
#include <iostream>
#include <type_traits>
int main()
{
    std::cout << 123 << '\n'
              << 0123 << '\n'
              << 0x123 << '\n'
              << 0b10 << '\n'
              << 12345678901234567890ull << '\n'
              << 12345678901234567890u << '\n'; // le type est unsigned long long
                                                // même sans suffixe long long
//  std::cout << -9223372036854775808 << '\n'; // erreur : la valeur
               // 9223372036854775808 ne peut pas tenir dans signed long long, qui est le
               // plus grand type autorisé pour un littéral entier décimal non suffixé
    std::cout << -9223372036854775808u << '\n'; // le moins unaire appliqué à une valeur
               // non signée la soustrait de 2^64, ce qui donne 9223372036854775808
    std::cout << -9223372036854775807 - 1 << '\n'; // méthode correcte pour calculer
                                                   // la valeur -9223372036854775808
#if __cpp_size_t_suffix >= 202011L // C++23
    static_assert(std::is_same_v<decltype(0UZ), std::size_t>);
    static_assert(std::is_same_v<decltype(0Z), std::make_signed_t<std::size_t>>);
#endif
}

123
83
291
2
12345678901234567890
12345678901234567890
9223372036854775808
-9223372036854775808

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Références

Voir aussi