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 literals.

Les constantes peuvent être de l'un des types 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 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 base: 0x ou 0X pour hexadécimal, 0 pour octal et rien pour 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 majuscules ou en minuscules 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, une virgule décimale, une partie fractionnaire et une partie exposant. Vous pouvez représenter des littéraux à virgule flottante sous forme décimale ou 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 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ères

Les caractères littéraux sont placés entre guillemets simples. Si le littéral commence par L (majuscule uniquement), il s'agit d'un littéral de caractère large (par exemple, L'x ') et doit être stocké danswchar_ttype de variable. Sinon, il s'agit d'un littéral de caractère étroit (par exemple, 'x') et peut être stocké dans une simple variable dechar type.

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

Il y a certains caractères en C ++ quand ils sont précédés d'une barre oblique inverse, ils auront une signification spéciale 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	Sens
\\	\ personnage
\ '	' personnage
\ "	" personnage
\?	? personnage
\une	Alerte ou cloche
\ b	Retour arrière
\F	Saut 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 -

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

Vous pouvez diviser une longue ligne en plusieurs lignes à l'aide de chaînes littérales et les séparer en utilisant des 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éfinition des constantes

Il existe deux méthodes simples en C ++ pour définir des constantes -

En utilisant #define préprocesseur.
En utilisant 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 -

#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 -

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 -

#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 -

Notez que c'est une bonne pratique de programmation de définir des constantes dans CAPITALS.