Littéraux numériques, booléens et de pointeur

Un littéral est un élément de programme qui représente directement une valeur. Cet article traite des littéraux de type entier, à virgule flottante, booléen et pointeur. Pour plus d’informations sur les littéraux de chaîne et de caractères, consultez Littéraux de chaîne et de caractères (C++). Vous pouvez également définir vos propres littéraux en fonction de l’une de ces catégories. Pour plus d’informations, consultez littéraux définis par l’utilisateur (C++).

Vous pouvez utiliser des littéraux dans de nombreux contextes, mais le plus souvent pour initialiser des variables nommées et passer des arguments à des fonctions :

const int answer = 42;      // integer literal
double d = sin(108.87);     // floating point literal passed to sin function
bool b = true;              // boolean literal
MyClass* mc = nullptr;      // pointer literal

Parfois, il est important indiquer au compilateur comment interpréter un littéral ou le type spécifique à lui affecter. Pour ce faire, ajoutez des préfixes ou des suffixes au littéral. Par exemple, le préfixe 0x indique au compilateur d’interpréter le nombre qui le suit comme valeur hexadécimale, par exemple 0x35. Le ULL suffixe indique au compilateur de traiter la valeur comme un unsigned long long type, comme dans 5894345ULL. Consultez les sections suivantes pour obtenir la liste complète des préfixes et suffixes pour chaque type de littéral.

Littéraux d'entier

Les littéraux d'entier commencent par un chiffre et n'ont aucune partie fractionnaire ni exposant. Vous pouvez spécifier des littéraux entiers au format décimal, binaire, octal ou hexadécimal. Vous pouvez éventuellement spécifier un littéral entier comme non signé et un type long ou long, à l’aide d’un suffixe.

Lorsqu’aucun préfixe ou suffixe n’est présent, le compilateur donne un type int de valeur littérale intégrale (32 bits), si la valeur convient, sinon elle lui donne le type long long (64 bits).

Pour spécifier un littéral intégral décimal, commencez la spécification par un chiffre différent de zéro. Par exemple :

int i = 157;        // Decimal literal
int j = 0198;       // Not a decimal number; erroneous octal literal
int k = 0365;       // Leading zero specifies octal literal, not decimal
int m = 36'000'000  // digit separators make large values more readable

Pour spécifier un littéral intégral octal, commencez la spécification par 0, suivi d'une séquence de chiffres dans la plage 0 à 7. Les chiffres 8 et 9 sont des erreurs lors de la spécification d'un littéral octal. Par exemple :

int i = 0377;   // Octal literal
int j = 0397;   // Error: 9 is not an octal digit

Pour spécifier un littéral intégral hexadécimal, commencez la spécification avec 0x ou (le cas du « x » n’a pas d’importance), suivie d’une séquence de chiffres dans la plage 09 et a (ou ) à (ou A) à f (ou F0X ). Les chiffres hexadécimaux a (ou A) à f (ou F) représentent des valeurs dans la plage 10 à 15. Par exemple :

int i = 0x3fff;   // Hexadecimal literal
int j = 0X3FFF;   // Equal to i

Pour spécifier un type non signé, utilisez le suffixe ou U le u suffixe. Pour spécifier un type long, utilisez le suffixe ou L le l suffixe. Pour spécifier un type intégral 64 bits, utilisez le suffixe LL ou ll. Le suffixe i64 est toujours pris en charge, mais nous ne le recommandons pas. Il est spécifique à Microsoft et n’est pas portable. Par exemple :

unsigned val_1 = 328u;                  // Unsigned value
long val_2 = 0x7FFFFFL;                 // Long value specified
                                        //  as hex literal
unsigned long val_3 = 0776745ul;        // Unsigned long value
auto val_4 = 108LL;                           // signed long long
auto val_4 = 0x8000000000000000ULL << 16;     // unsigned long long

Séparateurs de chiffres : vous pouvez utiliser le caractère à guillemet unique (apostrophe) pour séparer les valeurs de place dans des nombres plus volumineux pour faciliter la lecture des humains. Les séparateurs n'ont pas d'effet sur la compilation.

long long i = 24'847'458'121;

Littéraux à virgule flottante

Les littéraux à virgule flottante spécifient des valeurs qui doivent avoir une partie fractionnaire. Ces valeurs contiennent des décimales (.) et peuvent contenir des exposants.

Les littéraux à virgule flottante ont un significand (parfois appelé mantissa), qui spécifie la valeur du nombre. Ils ont un exposant, qui spécifie l’ampleur du nombre. Et ils ont un suffixe facultatif qui spécifie le type du littéral. Le significand est spécifié sous la forme d’une séquence de chiffres suivi d’une période, suivi d’une séquence facultative de chiffres représentant la partie fractionnaire du nombre. Par exemple :

18.46
38.

L'exposant, s'il est présent, spécifie la grandeur du nombre comme puissance de 10, comme indiqué dans l'exemple suivant :

18.46e0      // 18.46
18.46e1      // 184.6

L’exposant peut être spécifié à l’aide e ou E, qui ont la même signification, suivi d’un signe facultatif (+ ou -) et d’une séquence de chiffres. Si un exposant est présent, la virgule décimale de fin est inutile dans les nombres entiers tels que 18E0.

Littéraux à virgule flottante par défaut pour taper double. En utilisant les suffixes f ou l ou FL (le suffixe n’est pas sensible à la casse), le littéral peut être spécifié en tant que float ou long double.

double Bien qu’ils long double aient la même représentation, ils ne sont pas du même type. Par exemple, vous pouvez avoir des fonctions surchargées telles que

void func( double );

et

void func( long double );

littéraux booléens

Les littéraux booléens sont true et false.

Littéral de pointeur (C++11)

C++ introduit le nullptr littéral pour spécifier un pointeur initialisé zéro. Dans le code portable, nullptr doit être utilisé au lieu de zéro de type intégral ou de macros telles que NULL.

Littéraux binaires (C++14)

Un littéral binaire peut être spécifié à l'aide du préfixe 0B ou 0b, suivi d'une séquence de 1 et de 0 :

auto x = 0B001101 ; // int
auto y = 0b000001 ; // int

Évitez d'utiliser des littéraux en tant que « constantes magiques »

Vous pouvez utiliser des littéraux directement dans les expressions et instructions bien qu'il ne s'agisse pas toujours d'une bonne pratique de programmation :

if (num < 100)
    return "Success";

Dans l’exemple précédent, une meilleure pratique consiste à utiliser une constante nommée qui transmet une signification claire, par exemple « MAXIMUM_ERROR_THRESHOLD ». Et si la valeur de retour « Success » est vue par les utilisateurs finaux, il peut être préférable d’utiliser une constante de chaîne nommée. Vous pouvez conserver des constantes de chaîne dans un emplacement unique dans un fichier qui peut être localisé dans d’autres langues. L’utilisation de constantes nommées vous aide à comprendre l’intention du code.

Voir aussi

Conventions lexicales
Littéraux de chaîne C++
Littéraux définis par l’utilisateur C++