C - Constantes et littéraux

Les constantes font référence à des valeurs fixes que le programme ne peut pas modifier pendant son exécution. Ces valeurs fixes sont également appelées littéraux .

Les constantes peuvent être de n'importe quel type de données de base comme une constante entière, une constante flottante, une constante caractère ou une chaîne littérale . Il existe également des constantes d'énumération.

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.

Lorsque vous représentez la forme décimale, vous devez inclure la virgule décimale, l'exposant ou les deux ; et tout en représentant la 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 */

Constantes de caractère

Les caractères littéraux sont entourés de guillemets simples, par exemple, 'x' peut être stocké dans une simple variable de char saisir.

Un littéral de caractère 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').

Certains caractères en C ont une signification particulière lorsqu'ils sont précédés d'une barre oblique inverse, par exemple, une nouvelle ligne (\n) ou une tabulation (\t).

• Ici, vous avez une liste 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 <stdio.h>

int main() {
   printf("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 ou les constantes sont entourés de 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 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é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

Vous trouverez ci-dessous 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 <stdio.h>

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

int main() {
   int area;  
  
   area = LENGTH * WIDTH;
   printf("value of area : %d", area);
   printf("%c", NEWLINE);

   return 0;
}

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

value of area : 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 <stdio.h>

int main() {
   const int  LENGTH = 10;
   const int  WIDTH = 5;
   const char NEWLINE = '\n';
   int area;  
   
   area = LENGTH * WIDTH;
   printf("value of area : %d", area);
   printf("%c", NEWLINE);

   return 0;
}

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

value of area : 50

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