En langage C, une déclaration de variable de type élémentaire peut se coder en respectant la forme syntaxique simplifiée suivante (cf. chap. C2‑III ) :

descripteur de type  identificateur  [ = expression d'initialisation ] ;

Dans cette forme syntaxique (beaucoup plus simple que celle de la norme), on trouve :

• 3 termes génériques du métalangage, à savoir descripteur de type, identificateur et expression d'initialisation, qui sont à remplacer par des éléments de code spécifiques au gré des besoins du programme (cf. les exemples ci‑après) ;
• 2 éléments de code du langage, à savoir les symboles = (l'opérateur d'affectation) et ; (le séparateur d'instruction) ;
• Quant aux crochets gris [ ], ils ne sont pas des éléments du langage mais des symboles du métalangage pour délimiter une partie optionnelle dans la forme syntaxique.

Une telle forme syntaxique convient parfaitement pour régir des déclarations simples de variables de types élémentaires comme celles dont on a besoin dans les premiers programmes que tout débutant est amené à coder, par exemple :

• int x = 42;
• const unsigned BLINK_HALF_PERIOD = 500;

En langage C, le programme académique ci‑dessous est sémantiquement incorrect, comme on peut le constater si on tente de le compiler et exécuter avec OnlineGDB.

int main(void)
{
  x = 42;

  printf("%d\n", x);
  return 0;
}

En effet, bien que la ligne nº 3 soit syntaxiquement correcte (c'est une simple affectation de la valeur 42 à la variable x), elle déclenche une erreur de compilation car x n'a pas été préalablement déclarée :

main.c: In function ‘main’:
main.c:3:5: error: ‘x’ undeclared (first use in this function)
    3 |     x = 42;
      |     ^

Pour rendre ce programme sémantiquement correct, il suffit :

• de transformer l'instruction de la ligne nº 3 en une déclaration, typiquement comme ci‑dessous :

  int x = 42;

• ou de déclarer préalablement x comme une variable, par exemple :

  int x;
  x = 42;

Dans les deux cas, le programme devient compilable et s'exécute normalement en affichant la valeur 42.

De façon générale, sont des effets de bord :

• l'affectation d'une valeur à une variable du programme – par exemple, x = 42 ;
• la lecture ou écriture de caractères sur le terminal d'exécution – le programme modifiant le buffer du flux de entrée/sortie standard via une fonction dédiée ;
• la mise en service d'un périphérique géré par le système d'exploitation et commandé par le programme (haut‑parleur, caméra, etc.) – le programme modifiant une variable du système.

Au contraire, la simple modification d'un registre au cours d'un calcul – par exemple, x + 2 – n'est pas un effet de bord (sauf bien entendu dans le cas particulier d'une donnée stockée expressément dans un registre – cf. chap. C4‑II ).

Toute expression codée qui contient une opération de division d'entiers par zéro – par exemple, l'expression 1/0 engendre un comportement non défini du programme (cf. le brouillon de la norme C23 , section 6.5.6, p. 86, ligne 6 : « if the value of the second operand is zero, the behavior is undefined »).

Dans la pratique, en règle générale, le compilateur – typiquement GCC – émet seulement un avertissement mais l'exécution peut engendrer des comportements différents :

• Sur une machine à architecture x86-64, le système d'exploitation déclenche l'interruption de l'exécution du programme et ce dernier retourne une valeur non nulle (code d'erreur) – cf. chap. C2‑I . On peut l'expérimenter sur le site Compiler Explorer godbolt.org (cf. chap. C1‑II ), comme le montre la capture d'écran ci‑dessous.

• sur une machine à architecture ARM64, la division prend la valeur invalide 0 tandis que le programme poursuit son exécution et retourne la valeur 0. On peut aussi l'expérimenter sur le site Compiler Explorer, comme le montre la capture d'écran ci‑dessous.

Remarque. Au regard de la définition de la notion de comportement, on pourrait s'étonner qu'elle s'applique à l'évaluation d'une expression comme 1/0 qui, a priori, n'est même pas à effet de bord. En fait, c'est son utilisation ici comme argument de la fonction printf qui engendre un comportement indéfini (l'affichage d'une valeur impossible qui se traduit parfois par l'interruption du programme – un comportement indiscutable observable dans l'environnement d'exécution).

Dans l'extrait de programme ci‑dessous pour carte Arduino ont été ajoutés divers commentaires pour illuster quelques possibilités d'emploi de façon académique. Certes, ils sont un peu trop nombreux pour un programme aussi simple, mais ils ont été placés pour gêner le moins possible la lecture du code.

/* * * * * * *  PROGRAM: basic LED blink * * * * * * *
 * Hardware:
 *  - board: any Arduino board
 *  - green LED associated with 220 ohm resistor
 * Version : 1.0 (01/04/2018)
 */

const int LED_PIN = 2; // avoid pin 0 and 1 (serial port)

// const int BUTTON_PIN = 3; // comment if not needed

void setup() {
  pinMode(LED_PIN, OUTPUT);
}
// =====================================================

On peut remarquer que dans la présente page web, les commentaires sont automatiquement mis en italique gris par le script de coloration syntaxique Code Prettify (cf. chap. C2‑X ). C'est un style d'atténuation qui poursuit le même but de gêner le moins possible la lecture du code proprement dit, et c'est la pratique adoptée par tous les éditeurs de code.

Considérons le programme académique ci‑dessous qui teste une formule de génération de nombres aléatoires compris entre 1 et 6, par exemple pour modéliser le comportement d'un dé à six faces :

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX_VALUE 6

int nbRoll = 50;

int main(void)
{
  srand(time(NULL));
  for (int roll = 1; roll <= nbRoll; roll++) {
    int dice = (rand() % MAX_VALUE) + 1;
    printf("%d ", dice);
  }
  printf("\n");
  return 0;
}

On y trouve dans l'ordre :

• quatre directives (aux lignes n° 1, 2, 3 et 5) – toutes commencent bien par le symbole # ;
• une instruction de déclaration d'une variable globale (à la ligne n° 7) ;
• la définition de la fonction nommée main dont le bloc ainsi nommé comporte lui‑même quatre instructions :
• une instruction simple à la ligne n° 11 ;
• une instruction structurée (boucle for) dont le bloc anonyme comporte :
• une instruction de déclaration locale à la ligne n° 13 ;
• une instruction simple à la ligne n° 14 ;
• puis encore deux instructions simples aux lignes n° 16 & 17.

On a déjà vu dans les programmes donnés en exemples précédemment de nombreux exemples des deux cas les plus emblématiques d'instructions simples comme :

• userAge = 20;  où l'expression est une affectation, 
• printf("%d ", dice);  où l'expression est un appel de fonction.

L'extrait de code académique ci‑dessous ne comporte qu'une seule instruction structurée, dite de bifurcation :

  if (userAge >= LEGAL_AGE) {
    entrance = true;
  }
  else {
    entrance = false;
  }

Cette instruction est composée de deux instructions simples, dont une seule sera exécutéeselon le résultat du test spécifié par l'expression entre parenthèses après le mot‑clef if.

1. L'expression codée en langage C :
   abs(newVoltage - previousVoltage)
   correspond à l'expression mathématique |newVoltage − previousVoltage|

Elle est composée (cf. sa représentation graphique ci‑contre) :
• de l'appel de la fonction abs (valeur absolue) appliquée à la sous‑expression newVoltage - previousVoltage ;
• cette sous‑expression étant elle‑même composée via l'opérateur - (soustraction) appliqué aux deux atomes newVoltage et previousVoltage.
2. L'expression codée en langage C :
   newVoltage = previousVoltage / 2.0
   est une fondamentalement une affectation dont l'opérateur est codé = (cf. chap. C2‑IV ).

Elle est composée (cf. sa représentation graphique ci‑contre) :
• de l'atome newVoltage et de la sous‑expression previousVoltage / 2.0 ;
• cette sous‑expression étant elle‑même composée via l'opérateur / (division) appliqué aux deux atomes previousVoltage et 2.0, cette dernière étant une constante littérale numérique de type décimal.

• Identificateurs valides :
  i   D5   d5   newVoltage   NEW_VOLTAGE   _exceptions  …
• Identificateurs non valides :
• 5D  (chiffre initial interdit),
• énergieCumulée  (lettres accentuées interdites),
• new Voltage  (espace interdit),
• new-Voltage  (trait d'union interdit).

Dans la déclaration académique suivante :

int userAge;

• l'identificateur userAge est un atome ;
si l'on codait par mégarde int user Age; avec un espace au milieu, le compilateur détecterait deux nouveaux identificateurs distincts user et Age ;
• en revanche, au moins un espace de séparation entre int et userAge est indispensable comme séparateur ;
si l'on codait par mégarde intuserAge; le compilateur ne détecterait qu'un seul identificateur et pas le mot‑clef int.

La déclaration de l'exemple académique précédent pourrait aussi se coder de façon « fantaisiste » :

int
userAge
    ;

Mais bien entendu, il n'est pas question d'abuser ainsi de la liberté du format ! Pour faciliter la lecture, on doit trouver un bon compromis entre aération et compacité. Ici, les espaces ne sont pas ajoutés avec pertinence – au contraire, ils nuisent à la bonne lisibilité du code (cf. chap. C2‑X ).