Par l'instruction académique ci‑dessous, on déclare une donnée variable :

int myFirstVariable = 13;

• de type int (entier standard) ;
• nommée myFirstVariable – c'est son identificateur ;
• de valeur initiale spécifiée par la constante littérale codée 13, elle aussi préalablement interprétée par le compilateur comme étant implicitement de type int (aucune conversion ne doit donc être mise en œuvre).

Sur un poste de travail récent à architecture 32 ou 64 bits, quel que soit le système d'exploitation, la valeur d'une donnée de type int est encodée en mémoire sur 4 octets, soit 4 × 8 = 32 bits. Ces 32 bits représentant la valeur entière 13 en binaire vaudraient :
00000000 00000000 00000000 00001101

float myFirstVariable = 13.0;

Le code ci‑dessous contient quatre déclarations (lignes nº 5, 6, 11 et 12). Toutes les variables déclarées sont initialisées.

#include <stdio.h>
#include <stdbool.h>

// global variables (static)
bool isUserRegistred = true;
unsigned int pointAccount = 10 + 50; // init + bonus

int main(void)
{
  // local variables (automatic)
  float inflationRate = 0.07; 
  int nextPointAccount = pointAccount * (1 + inflationRate);
  // ...
}

1. Commençons par une exemple purement académique avec le programme ci‑dessous s'exécutant sur un ordinateur, dont le fichier source est stocké dans un fichier source nommé testConst.c, dans lequel l'on a volontairement codé à la ligne nº 7 une affectation directe sur une constante déclarée globale A :

#include <stdio.h>

const int A = 3;

int main(void)
{
  A = 5;
  printf("A = %d\n", A);
  return 0;
}


Si on tente de le compiler sur dans un terminal de commandes en ligne, quel que soit le langage ou la version de la norme choisie, on obtient inévitablement une erreur de compilation tout à fait explicite :

  
gcc testConst.c -o testConst
  
testConst.c: In function ‘main’:
  testConst.c:7:5: error: assignment of read-only variable ‘A’
      7 |   A = 5;
        |     ^
  

▣ Maintenant, remplaçons la ligne nº 7 par une affectation indirecte via l'opérateur d'adresse &, en argument de la fonction scanf (autrement dit, on demande à l'utilisateur de saisir une valeur qui sera mémorisée à l'adresse de A). Alors, même sans aucune option particulière d'avertissement (cf. chap. C1‑II ), avec une version récente, le compilateur de gcc émet avertissement (idem avec g++) :
  
gcc testConst.c -o testConst
  
testConst.c: In function ‘main’:
  testConst.c:7:3: warning: writing into constant object (argument 2) [-Wformat=]
      7 |   scanf("%d", &A);
        |   ^~~~~
  
Si l'on décide quand même de ne pas tenir compte de cet avertissement alors, quelle que soit la chaîne de compilation gcc ou g++ employée auparavant, l'exécutable déclenche comme prévu une erreur de segmentation juste après la saisie de l'utilisateur :
  
./testConst
  
5
  Segmentation fault (core dumped)
  
▣ Enfin, modifions le programme précédent pour que la constante A soit locale dans la fonction main (cf. la ligne nº 5 ci‑dessous) :
#include <stdio.h>

int main(void)
{
  const int A = 3;
  scanf("%d", &A);
  printf("A = %d\n", A);
  return 0;
}
Comme précédemment, les commandes gcc ou g++ émettent l'une comme l'autre le même type d'avertissement :
  
gcc testConst.c -o testConst
  
testConst.c: In function ‘main’:
  testConst.c:6:3: warning: writing into constant object (argument 2) [-Wformat=]
      6 |   scanf("%d", &A);
        |   ^~~~~
  
En revanche, lors de l'exécution, aucune erreur ne se produit après la saisie de l'utilisateur et le programme se termine en retournant la valeur attendue 0. Toutefois, on observe un comportement différent selon le langage C ou C++ :
• Si l'exécutable est produit par gcc, on obtient :

    
./testConst
    
5
    A = 5
    
echo $?
    
0
    

Bien évidemment, ce n'est pas satisfaisant car la constante A a bel et bien été modifiée par la saisie de l'utilisateur !
• En revanche, si l'exécutable est produit par g++, on obtient :

    
./testConst
    
5
    A = 3
    
echo $?
    
0
    

Il apparaît donc que malgré la saisie de l'utilisateur, la constante A n'est pas modifiée !
En effet, la norme du langage C++ confère à toute constante un statut sémantique plus strict qu'en langage C. Typiquement, même sans invoquer aucune option d'optimisation particulière, dans le cas d'une constante de type élémentaire, le compilateur se charge de remplacer intelligemment les occurrence de son identificateur par sa valeur dans le code objet qu'il produit. Ainsi, même si l'emplacement mémoire de la constante est modifié, sa valeur d'utilisation dans le code ne l'est pas, comme on peut le constater dans le dernier scénario supra.

2. Voyons maintenant un exemple normal d'emploi de constantes déclarées dans un très classique programme de clignotement d'une led externe reliée au port numérique d'un carte Arduino.

const int LED_PIN = 5;

void setup()
{
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);
}
 
 
const unsigned BLINK_HALF_PERIOD = 500;  // milliseconds
 
void loop()
{
  digitalWrite(LED_PIN, HIGH);
  delay(BLINK_HALF_PERIOD);
  digitalWrite(LED_PIN, LOW);
  delay(BLINK_HALF_PERIOD);
}

Le fait de coder une constante nommée LED_PIN plutôt que la constante littérale 5 correspondant à sa valeur (cf. la ligne nº 1 ci‑dessus) présente deux avantages significatifs :
• D'une part, cela améliore grandement la lisibilité des expressions qui invoquent cette donnée. En effet, la ligne :

  digitalWrite(LED_PIN, HIGH)

ne pose aucun problème de compréhension (on allume une led), alors que si on avait codé :

  digitalWrite(5, HIGH)

alors il faut se souvenir du dispositif relié à la broche 5 du port numérique de la carte pour comprendre ce que fait le programme. Évidemment, tant qu'on a juste une led, cela ne semble poser a priori aucun problème, mais il suffit de se projeter dans la situation d'un système plus complexe pour imaginer la difficulté de lecture du code qui en résulterait.
• D'autre part, l'emploi d'une constante nommée améliore la robustesse du code à d'éventuelles modifications. Imaginons par exemple qu'on décide finalement de relier la led à la broche 2 du port numérique de la carte. Ici, il suffit juste de modifier la valeur d'initialisation de la constante dans la ligne de sa déclaration :

const int LED_PIN = 2;

A contrario, si on avait utilisé une constante littérale, il aurait fallu procéder au remplacement de toutes les occurrences de sa valeur dans le code qui correspondent bien à cette constante. Et attention car dans le programme, le chiffre 5 est utilisé pour autre chose :

const unsigned BLINK_HALF_PERIOD = 500;  // milliseconds

On comprend donc aisément que, même automatisée par une procédure de « rechercher/remplacer » présente un risque d'erreurs en cascade.

Reprenons un exemple académique du chapitre C2‑II  :

  if (userAge >= 18) {

Même si la constante littérale 18 n'apparaît qu'une seule fois dans le programme, il est quand même préférable de coder préalablement en début de fichier la déclaration :

const int LEGAL_AGE = 18;

pour pouvoir recoder mieux la ligne n° 10 supra comme ci‑dessous :

  if (userAge >= LEGAL_AGE) {

En effet, ce paramètre d'âge peut changer selon l'époque, le pays ou même le contexte. En le définissant comme une donnée déclarée, il sera plus commode par la suite de modifier sa valeur d'initialisation, typiquement via une variable d'environnement.

Dans le code académique ci‑dessous, trois variables a, b c de type int sont déclarées :

int a, b = 3, c = 10;

On peut remarquer que la variable a ne fait pas l'objet d'une initialisation, ce qui est autorisé par la syntaxe, même si ce n'est en général pas une bonne pratique (ici, c'est juste fait pour l'exemple).

On peut être amené à déclarer une variable sans lui affecter une valeur initiale, lorsque cette variable est destinée à recevoir des valeurs non prévisibles lors du codage du programme, typiquement si elle sera saisie par un utilisateur durant l'exécution :

#include <stdio.h>

int main(void)
{
  int patientAge;  // uninitialized variable
  printf("How old the patient is? ");
  scanf("%d", &patientAge);
  // ...
}	

Pourtant, il est préférable de coder la déclaration :

  int patientAge = -1; 

La valeur a priori « absurde » -1 permet de coder ensuite dans le programme des tests pour savoir si la saisie n'a pas encore eu lieu (ou si elle a éventuellement échoué).

Le code des deux déclarations de variables globales ci‑dessous est compilable en langage C++ :

float nominalVoltage  = 12.0;
float startingVoltage = nominalVoltage/2.0;

En langage C, la ligne n° 6 serait refusée lors de la compilation car l'expression d'initialisation nominalVoltage/2.0 n'est pas une expression constante : elle utilise l'identificateur de variable nominalVoltage.