Constantes et littéraux en C++ : Types, syntaxe et bonnes pratiques

Les constantes font référence à des valeurs fixes que le programme ne peut pas modifier et elles sont appelées littéraux.

Les constantes peuvent être de l'un des types de données de base et peuvent être divisées en Numéraux entiers, Numéraux à virgule flottante, Caractères, Chaînes et Valeurs booléennes.

Encore une fois, les constantes sont traitées comme des variables régulières, sauf que leurs valeurs ne peuvent pas être modifiées après leur définition.

Littéraux entiers

Un littéral entier peut être une constante décimale, octale ou hexadécimale. Un préfixe spécifie la base ou la radice : 0x ou 0X pour l'hexadécimal, 0 pour l'octal, et rien pour le décimal.

Un littéral entier peut aussi avoir un suffixe qui est une combinaison de U et L, pour unsigned et long, respectivement. Le suffixe peut être en majuscules ou minuscules et dans n'importe quel ordre.

Voici quelques exemples de littéraux entiers :

212       // Légal
215u      // Légal
0xFeeL    // Légal
078       // Illégal : 8 n'est pas un chiffre octal
032UU     // Illégal : ne peut pas répéter un suffixe

Voici d'autres exemples de divers types de littéraux entiers :

85        // décimal
0213      // octal
0x4b      // hexadécimal
30        // int
30u       // unsigned int
30l       // long
30ul      // unsigned long

Littéraux à virgule flottante

Un littéral à virgule flottante a une partie entière, un point décimal, une partie fractionnaire et une partie exposant. Vous pouvez représenter les littéraux à virgule flottante soit sous forme décimale, soit sous forme exponentielle.

En représentant sous forme décimale, vous devez inclure le point décimal, l'exposant, ou les deux ; et en représentant sous forme exponentielle, vous devez inclure la partie entière, la partie fractionnaire, ou les deux. L'exposant signé est introduit par e ou E.

Voici quelques exemples de littéraux à virgule flottante :

3.14159       // Légal
314159E-5L    // Légal
510E          // Illégal : exposant incomplet
210f          // Illégal : pas de point décimal ni d'exposant
.e55          // Illégal : partie entière ou fractionnaire manquante

Littéraux booléens

Il y a deux littéraux booléens et ils font partie des mots-clés standard C++ :

• Une valeur true représentant vrai.

• Une valeur false représentant faux.

Vous ne devez pas considérer la valeur de true égale à 1 et la valeur de false égale à 0.

Littéraux de caractère

Les littéraux de caractère sont enfermés dans des guillemets simples. Si le littéral commence par L (majuscule seulement), c'est un littéral de caractère large (ex: L'x') et doit être stocké dans une variable de type wchar_t. Sinon, c'est un littéral de caractère étroit (ex: 'x') et peut être stocké dans une variable simple de type char.

Un littéral de caractère peut être un caractère simple (ex: 'x'), une séquence d'échappement (ex: '\t'), ou un caractère universel (ex: '\u02C0').

Il y a certains caractères en C++ qui, lorsqu'ils sont précédés d'une barre oblique inverse, ont une signification spéciale et sont utilisés pour représenter comme nouvelle ligne (\n) ou tabulation (\t). Voici une liste de certains de ces codes de séquence d'échappement :

Séquence d'échappement	Signification
\\	caractère \
\'	caractère '
\"	caractère "
\?	caractère ?
\a	Alerte ou cloche
\b	Retour arrière
\f	Saut de page
\n	Nouvelle ligne
\r	Retour chariot
\t	Tabulation horizontale
\v	Tabulation verticale
\ooo	Nombre octal de un à trois chiffres
\xhh...	Nombre hexadécimal d'un ou plusieurs chiffres

Voici un exemple pour montrer quelques caractères de séquence d'échappement :

#include <iostream>
using namespace std;

int main() {
    cout << "Hello\tWorld\n\n";
    return 0;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

Hello World

Littéraux de chaîne

Les littéraux de chaîne sont enfermés dans des guillemets doubles. Une chaîne contient des caractères similaires aux littéraux de caractère : caractères simples, séquences d'échappement et caractères universels.

Vous pouvez diviser une longue ligne en plusieurs lignes en utilisant des littéraux de chaîne et les séparer en utilisant des espaces blancs.

Voici quelques exemples de littéraux de chaîne. Les trois formes sont des chaînes identiques.

"hello, dear"
"hello, \ dear"
"hello, " "d" "ear"

Définition des constantes

Il y a deux façons simples en C++ de définir des constantes :

• En utilisant le préprocesseur #define.

• En utilisant le mot-clé const.

Le préprocesseur #define

Voici la forme pour utiliser le préprocesseur #define pour définir une constante :

#define identificateur valeur

L'exemple suivant l'explique en détail :

#include <iostream>
using namespace std;

#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'

int main() {
    int area;
    area = LENGTH * WIDTH;
    cout << area;
    cout << NEWLINE;
    return 0;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

50

Le mot-clé const

Vous pouvez utiliser le préfixe const pour déclarer des constantes avec un type spécifique comme suit :

const type variable = valeur;

L'exemple suivant l'explique en détail :

#include <iostream>
using namespace std;

int main() {
    const int LENGTH = 10;
    const int WIDTH = 5;
    const char NEWLINE = '\n';
    int area;
    area = LENGTH * WIDTH;
    cout << area;
    cout << NEWLINE;
    return 0;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

50

Notez qu'il est une bonne pratique de programmation de définir les constantes en MAJUSCULES.