Les variables en C : déclarer, initialiser et affecter

Une variable est un morceau de mémoire nommé qui contient une valeur que votre programme peut lire et changer. En C, vous dites toujours d'avance quel genre de valeur elle contient, et ce choix est définitif pour toute la vie de la variable.

Déclarer une variable

La forme est type, nom, point-virgule :

int age;
double price;
char grade;

Chaque ligne réserve assez de mémoire pour ce type de données et y attache un nom. Rien n'a encore été stocké - l'espace existe, mais son contenu est ce qu'y a laissé ce qui s'est exécuté avant.

Vous pouvez donner une valeur au même moment, ce qui s'appelle l'initialisation :

#include <stdio.h>

int main(void) {
    int age = 30;
    double price = 19.99;
    char grade = 'A';

    printf("Age : %d\n", age);
    printf("Prix : %.2f\n", price);
    printf("Note : %c\n", grade);
    return 0;
}

Notez les spécificateurs de format : %d pour int, %f pour double, %c pour char. printf n'inspecte pas les valeurs qu'on lui donne - il fait confiance à votre chaîne de format, donc une discordance affiche n'importe quoi plutôt qu'une erreur.

L'affectation après la déclaration

Une fois qu'une variable existe, vous la changez avec = :

#include <stdio.h>

int main(void) {
    int score;      /* declaree, valeur inconnue */

    score = 0;      /* affectation */
    printf("Debut  : %d\n", score);

    score = 85;     /* affectation de nouveau - l'ancienne valeur a disparu */
    printf("Milieu : %d\n", score);

    score = score + 10;   /* lire l'ancienne valeur, stocker la nouvelle */
    printf("Fin    : %d\n", score);
    return 0;
}

= en C est une affectation, pas une égalité. score = score + 10 se lit « prends ce qui est dans score, ajoute 10, remets le résultat dans score ». L'opérateur de comparaison est ==, et les confondre est un bug si courant qu'il a sa propre section sur la page booléens.

Le raccourci score += 10 fait la même chose en moins de caractères ; les opérateurs d'affectation composée couvrent toute l'arithmétique.

Le piège de la variable non initialisée

C'est le bug de débutant le plus courant en C, et il ne produit aucune erreur :

#include <stdio.h>

int main(void) {
    int total;      /* n'a jamais recu de valeur */

    for (int i = 1; i <= 5; i++) {
        total += i; /* lecture de total avant qu'il ait une valeur */
    }

    printf("Total : %d\n", total);
    return 0;
}

Lancez-le. Vous pouvez voir 15, la bonne réponse. Vous pouvez voir un nombre aléatoire énorme. Vous pouvez voir autre chose à une seconde exécution ou sur une autre machine. Tout cela est un comportement « correct », car lire une variable locale non initialisée est un comportement indéfini - la norme C n'impose aucune exigence sur ce qui se passe.

Contrairement à beaucoup de langages, le C ne met pas vos locales à zéro. Une variable locale est une tranche de la pile, et la pile est pleine de restes d'appels de fonctions antérieurs. Parfois, ces restes se trouvent être des zéros, ce qui rend ce bug si dangereux : il fonctionne souvent en test et échoue en production.

La correction tient en un caractère :

#include <stdio.h>

int main(void) {
    int total = 0;      /* initialisee */

    for (int i = 1; i <= 5; i++) {
        total += i;
    }

    printf("Total : %d\n", total);
    return 0;
}

Faites-en une habitude : initialisez chaque variable au point de déclaration. Si vous n'avez réellement pas encore de valeur sensée, 0 ou NULL vaut mieux que du garbage. Et compilez avec -Wall, qui attrape la plupart des cas :

warning: 'total' is used uninitialized in this function

Les variables globales et static font exception - elles sont initialisées à zéro automatiquement. S'y fier est acceptable, mais écrire = 0 quand même documente votre intention.

Déclarer plusieurs variables à la fois

Des variables du même type peuvent partager une déclaration, avec ou sans initialiseurs :

#include <stdio.h>

int main(void) {
    int x = 1, y = 2, z = 3;
    double width = 4.5, height;   /* height n'est pas initialisee */

    height = 2.0;
    printf("%d %d %d\n", x, y, z);
    printf("aire : %.2f\n", width * height);
    return 0;
}

C'est légal et courant pour des valeurs étroitement liées comme x, y, z. C'est aussi là que vit une mauvaise lecture classique :

int a = 0, b = 0, c = 0;   /* les trois valent 0 */
int d, e, f = 0;           /* seul f vaut 0 - d et e contiennent du garbage */

L'initialiseur s'attache à un nom, pas à la ligne. Quand les valeurs diffèrent par leur sens, donnez à chacune sa propre ligne - cela se lit mieux et se compare mieux en diff.

Déclarer des pointeurs sur une ligne présente le même piège en plus tranchant :

int *p, q;   /* p est un pointeur sur int ; q est un int simple */

Le * s'attache au nom, pas au type. Déclarez les pointeurs un par ligne.

Règles et conventions de nommage

Les règles du compilateur :

• Lettres, chiffres et tirets bas uniquement.
• Ne peut pas commencer par un chiffre : total2 convient, 2total non.
• Ne peut pas être un mot-clé du C : pas de variable nommée int, return, for, double.
• Sensible à la casse : count, Count et COUNT sont trois variables distinctes.
• Les noms commençant par un tiret bas, ou contenant un double tiret bas, sont réservés à l'implémentation. N'en créez pas.

int itemCount;       /* legal */
int item_count;      /* legal - le style C habituel */
int _count;          /* legal mais reserve - a eviter */
int item-count;      /* erreur : '-' est l'operateur moins */
int 3rd_place;       /* erreur : commence par un chiffre */
int float;           /* erreur : mot-cle */

Les conventions que suit la plupart du code C : snake_case pour les variables et les fonctions, MAJUSCULES pour les constantes macro, et des noms qui disent ce que la valeur signifie plutôt que son type. elapsed_ms vaut mieux que t ; customer_count vaut mieux que n2.

Les noms courts restent très bien là où la portée est minuscule - i comme compteur de boucle est universellement compris, et personne ne veut for (int loop_iteration_index = 0; ...).

Où vit une variable

L'endroit où vous déclarez une variable détermine qui peut la voir et combien de temps elle dure. C'est la portée, et la version courte est :

#include <stdio.h>

int shared = 100;       /* globale : visible de toutes les fonctions de ce fichier */

void show(void) {
    printf("show voit shared = %d\n", shared);
}

int main(void) {
    int local = 5;      /* locale a main */

    {
        int inner = 7;  /* locale a ce bloc seulement */
        printf("inner = %d, local = %d\n", inner, local);
    }
    /* inner n'existe plus ici */

    show();
    printf("main voit local = %d\n", local);
    return 0;
}

Une variable est visible de sa déclaration jusqu'à l'accolade fermante du bloc qui la contient. Les globales vivent pendant tout le programme et sont visibles partout, ce qui paraît pratique et explique pourquoi elles posent problème : toute fonction peut en changer une, donc retrouver qui l'a fait devient une recherche dans tout le fichier. Préférez les locales et passez les valeurs aux fonctions en paramètres.

Déclarer n'importe où (C99 et après)

Dans le C89 d'origine, toute déclaration devait précéder toute instruction dans un bloc :

int main(void) {
    int i, sum = 0;      /* toutes les declarations d'abord */
    printf("Demarrage\n");
    for (i = 0; i < 10; i++) { sum += i; }
    return 0;
}

Depuis C99, vous pouvez déclarer là où vous avez besoin de la valeur pour la première fois, y compris dans l'en-tête du for :

#include <stdio.h>

int main(void) {
    printf("Demarrage\n");

    int sum = 0;                          /* declaree la ou elle sert */
    for (int i = 0; i < 10; i++) {        /* i est limite a la boucle */
        sum += i;
    }

    printf("Somme : %d\n", sum);
    return 0;
}

C'est un meilleur style : la déclaration est à côté de son premier usage, et i ne peut pas fuir dans le reste de la fonction. Compilez avec -std=c17 (ou tout réglage C99 et plus) et cela fonctionne partout.