Placement des déclarations de variables en C

Question

J'ai longtemps pensé qu'en C, toutes les variables devaient être déclarées au début de la fonction. Je sais qu'en C99, les règles sont les mêmes qu'en C++, mais quelles sont les règles de placement des déclarations de variables en C89/ANSI C ?

Le code suivant se compile avec succès avec gcc -std=c89 y gcc -ansi :

#include <stdio.h>
int main() {
    int i;
    for (i = 0; i < 10; i++) {
        char c = (i % 95) + 32;
        printf("%i: %c\n", i, c);
        char *s;
        s = "some string";
        puts(s);
    }
    return 0;
}

Les déclarations de c y s provoque une erreur en mode C89/ANSI ?

Answer 1

Il compile avec succès parce que GCC permet la déclaration de s comme une extension GNU, même si elle ne fait pas partie de la norme C89 ou ANSI. Si vous voulez adhérer strictement à ces normes, vous devez passer le test de l'extension -pedantic drapeau.

La déclaration de c au début d'un { } fait partie de la norme C89 ; le bloc ne doit pas nécessairement être une fonction.

Answer 2

En C89, vous devez déclarer toutes vos variables au début d'un fichier de type bloc de contrôle .

Donc, votre char c est valide car elle se trouve en haut du bloc de portée de la boucle for. Mais, le bloc char *s devrait être une erreur.

Answer 3

Le regroupement des déclarations de variables en haut du bloc est un héritage probablement dû aux limitations des anciens compilateurs C primitifs. Tous les langages modernes recommandent et parfois même imposent la déclaration des variables locales au dernier moment : là où elles sont initialisées pour la première fois. En effet, cela élimine le risque d'utiliser une valeur aléatoire par erreur. Séparer la déclaration et l'initialisation vous évite également d'utiliser "const" (ou "final") quand vous le pourriez.

Malheureusement, le C++ continue d'accepter l'ancienne méthode de déclaration supérieure pour assurer la compatibilité avec le C (un problème de compatibilité avec le C parmi tant d'autres...) Mais le C++ essaie de s'en éloigner :

• La conception des références C++ ne permet même pas un tel regroupement en haut du bloc.
• Si vous séparez la déclaration et l'initialisation d'un fichier local C++ objet alors vous payez le coût d'un constructeur supplémentaire pour rien. Si le constructeur sans argument n'existe pas, vous n'êtes même pas autorisé à séparer les deux !

C99 commence à déplacer C dans cette même direction.

Si vous craignez de ne pas trouver l'endroit où sont déclarées les variables locales, cela signifie que vous avez un problème bien plus important : le bloc qui l'entoure est trop long et doit être divisé.

https://wiki.sei.cmu.edu/confluence/display/c/DCL19-C.+Minimiser+la+portée+des+variables+et+des+fonctions

Answer 4

Du point de vue de la maintenabilité, plutôt que de la syntaxe, il existe au moins trois pistes de réflexion :

1. Déclarez toutes les variables au début de la fonction afin qu'elles se trouvent au même endroit et que vous puissiez voir la liste complète d'un seul coup d'œil.

2. Déclarez toutes les variables aussi près que possible de l'endroit où elles sont utilisées pour la première fois, afin que vous sachiez por qué chacun est nécessaire.

3. Déclarez toutes les variables au début du bloc de portée le plus interne, afin qu'elles sortent de leur portée dès que possible et que le compilateur puisse optimiser la mémoire et vous prévenir si vous les utilisez accidentellement là où vous ne l'aviez pas prévu.

Je préfère généralement la première option, car je trouve que les autres m'obligent souvent à chercher les déclarations dans le code. Définir toutes les variables à l'avance permet également de les initialiser et de les observer plus facilement depuis un débogueur.

Il m'arrive parfois de déclarer des variables à l'intérieur d'un bloc plus petit, mais uniquement pour une bonne raison, dont j'ai très peu. Un exemple pourrait être après un fork() pour déclarer les variables nécessaires uniquement au processus enfant. Pour moi, cet indicateur visuel est un rappel utile de leur but.

Answer 5

Comme l'ont noté d'autres personnes, GCC est permissif à cet égard (et peut-être d'autres compilateurs, selon les arguments avec lesquels ils sont appelés) même en mode 'C89', à moins que vous n'utilisiez une vérification 'pédante'. Pour être honnête, il n'y a pas beaucoup de bonnes raisons de ne pas utiliser la vérification pédante ; un code moderne de qualité devrait toujours compiler sans avertissement (ou très peu lorsque vous savez que vous faites quelque chose de spécifique qui est suspect pour le compilateur comme une erreur possible), donc si vous ne pouvez pas faire compiler votre code avec une configuration pédante, il a probablement besoin d'attention.

La C89 exige que les variables soient déclarées avant toute autre instruction dans chaque champ d'application. Les normes ultérieures permettent une déclaration plus proche de l'utilisation (ce qui peut être à la fois plus intuitif et plus efficace), notamment la déclaration et l'initialisation simultanées d'une variable de contrôle de boucle dans les boucles 'for'.