Constantes/littéraux C++

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 n'importe quel type de données de base et peuvent être divisées en nombres entiers, nombres à virgule flottante, caractères, chaînes et valeurs booléennes.

Encore une fois, les constantes sont traitées comme des variables normales, 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 base :0x ou 0X pour l'hexadécimal, 0 pour l'octal et rien pour le décimal.

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

Voici quelques exemples de littéraux entiers −

212         // Legal
215u        // Legal
0xFeeL      // Legal
078         // Illegal: 8 is not an octal digit
032UU       // Illegal: cannot repeat a suffix

Voici d'autres exemples de différents types de littéraux entiers −

85         // decimal
0213       // octal
0x4b       // hexadecimal
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 sous forme décimale ou sous forme exponentielle.

Lors de la représentation sous forme décimale, vous devez inclure la virgule décimale, l'exposant ou les deux et lors de la représentation 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       // Legal
314159E-5L    // Legal
510E          // Illegal: incomplete exponent
210f          // Illegal: no decimal or exponent
.e55          // Illegal: missing integer or fraction

Littéraux booléens

Il existe deux littéraux booléens et ils font partie des mots clés C++ standard −

• Une valeur de true représentant vrai.

• Une valeur de faux représentant faux.

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

Littéraux de caractères

Les littéraux de caractères sont entourés de guillemets simples. Si le littéral commence par L (majuscule uniquement), il s'agit d'un littéral à caractères larges (par exemple, L'x') et doit être stocké dans wchar_t type de variables. Sinon, il s'agit d'un littéral de caractère étroit (par exemple, 'x') et peut être stocké dans une simple variable de char saisir.

Un caractère littéral peut être un caractère ordinaire (par exemple, 'x'), une séquence d'échappement (par exemple, '\t') ou un caractère universel (par exemple, '\u02C0').

Il existe certains caractères en C++ lorsqu'ils sont précédés d'une barre oblique inverse, ils auront une signification particulière et ils sont utilisés pour représenter comme une nouvelle ligne (\n) ou une tabulation (\t). Ici, vous avez une liste de certains de ces codes de séquence d'échappement −

Séquence d'échappement	Signification
\\	\ caractère
\'	' caractère
\"	" caractère
\ ?	? personnage
\a	Alerte ou cloche
\b	Retour arrière
\f	Flux de formulaire
\n	Nouvelle ligne
\r	Retour chariot
\t	Onglet horizontal
\v	Onglet vertical
\ooo	Numéro octal de un à trois chiffres
\xhh . . .	Nombre hexadécimal d'un ou plusieurs chiffres

Voici l'exemple pour montrer quelques caractères de séquence d'échappement −

Démo en direct

#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 placés entre guillemets doubles. Une chaîne contient des caractères similaires aux caractères littéraux :caractères simples, séquences d'échappement et caractères universels.

Vous pouvez diviser une longue ligne en plusieurs lignes à l'aide de littéraux de chaîne et les séparer à l'aide d'espaces.

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éfinir les constantes

Il existe deux manières simples en C++ de définir des constantes −

• Utiliser #define préprocesseur.

• Utilisation de const mot-clé.

Le préprocesseur #define

Voici le formulaire pour utiliser le préprocesseur #define pour définir une constante −

#define identifier value

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

Démo en direct

#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 const préfixe pour déclarer des constantes avec un type spécifique comme suit −

const type variable = value;

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

Démo en direct

#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 que c'est une bonne pratique de programmation de définir des constantes en MAJUSCULES.