Utilisation de variables très locales en C
1Comme tout le monde le sait, et bien que les versions récentes des compilateurs et de la norme C soient plus souples à ce sujet, il faut absolument déclarer ses variables en début de blocs, avant toute instruction. Or, il arrive souvent que l’on ai besoin d’une variable localement au milieu de sa fonction ou de son bloc if. Comme souvent les règles de bonne conduite stipulant que la longueur d’une fonction doit être raisonnable ne sont pas respectées, on se retrouve avec des fonctions de plusieurs centaines de lignes, avec une pléthore de variables utilisées uniquement dans 10 lignes. Outre la surabondance de variables causant une lecture difficile du code et une difficulté supplémentaire pour le maintenir, on se retrouve aussi avec des variables utilisées plusieurs fois dans le code pour différentes choses indépendantes, créant des risques de confusion, d’effets de bord non prévus et donc des risques de dysfonctionnement, de comportements non prévus ou alors un plantage intégral de l’application.
Donc, un petit rappel de la sémantique du C89 et suivant s’impose. Il existe plusieurs types d’instructions dont :
- Les « instructions expressions » dont la syntaxe est :
expression ;
- Les « instructions composées » dont la syntaxe est :
{ liste-de-declarations(optionnel) liste-d'instructions }
L’utilité des instructions composées est flagrante avec les instructions de contrôle de flux (if, if…else, for, while, do…while). En effet, en prenant comme exemple l’instruction if…else, dont la syntaxe est if (expression) instruction1 else instruction2, on voit que ces instructions n’exécutent que l’instruction suivante. On se sert donc des instructions composées pour exécuter plusieurs instructions.
On voit donc qu’il est alors possible d’utiliser une instruction composée n’importe où dans le code, notamment lorsque l’on a besoin d’une variable très localement. Voici un exemple :
void AfficherDonnerUtilisateur(Utilisateur *u)
{
printf("Nom : %s\n", u->nom);
printf("Prénom : %s\n", u->prenom);
{
int i = 0;
int somme = 0;
for (i = 0; i < u->nbDonnees1; ++i)
{
somme += u->Donnees1[i];
}
printf("Moyenne donnée 1 : %.2f", (somme / u->nbDonnees1));
}
{
int i = 0;
float somme = 0;
for (i = 0; i < u->nbDonnees2; ++i)
{
somme += u->Donnees2[i];
}
printf("Somme donnée 2 : %.4f", somme);
}
}
Fini dès lors les longues listes de déclaration de variables en début de fonction !






Pour ceux qui ont lu cet article, c’est typiquement le genre de code que vous voulez eviter. Il n’y pas besoin de declarers des variables au milieu d’une function et un bon codeur n’aura jamais une longue liste de variables.
Le principe de base de programmation est de rester « DRY » (Don’t Repeat Yourself). Le code ci-dessus se repete pour rien.
« Outre la surabondance de variables causant une lecture difficile du code et une difficulté supplémentaire pour le maintenir ».
Le code ci-dessus est encore moins lisible qu’une longue liste de variables et bien plus dangeureux. Si d’autres developpeurs travaillent sur ce projet ils n’auraient pu imaginer qu’un « petit malin » s’est amuse a declarer des variables en plein milieu de la fonction.
« créant des risques de confusion, d’effets de bord non prévus et donc des risques de dysfonctionnement, de comportements non prévus ou alors un plantage intégral de l’application. »
Ce qui correspond exactement au code presente ci-dessus.
Si vous voulez voir a quoi un bon code C ressemble, jetez un coup d’oeil sur la source de Quake3. (https://github.com/id-Software/Quake-III-Arena). Vous pourrez voir qu’il doit y’avoir maximum 6 declaration de variables dans une fonction.