Variables et constantes en C-C++

Variables et constantes en C

1. Déclaration et initialisation

/* Déclaration sans initialisation */
type nom_variable;

/* Déclaration avec initialisation */
type nom_variable = valeur;

/* Plusieurs variables du même type */
type var1, var2, var3;

/* Plusieurs variables avec initialisations mixtes */
type var1 = valeur1, var2, var3 = valeur3;

Exemple n°1 — Déclarations et initialisations

#include <stdio.h>

int main(void)
{
    int    age;              /* déclarée, non initialisée (valeur indéfinie) */
    int    annee = 2024;     /* déclarée et initialisée */
    float  b = 1.5, c;      /* b initialisée, c non initialisée */
    char   lettre = 'A';    /* caractère */
    double pi = 3.14159;    /* réel double précision */

    age = 20;               /* affectation après déclaration */

    printf("age    = %d\n",  age);
    printf("annee  = %d\n",  annee);
    printf("b      = %.1f\n", b);
    printf("lettre = %c\n",  lettre);
    printf("pi     = %f\n",  pi);

    return 0;
}

age    = 20
annee  = 2024
b      = 1.5
lettre = A
pi     = 3.141590

int x;
printf("%d\n", x);  /* comportement indéfini — valeur aléatoire */

int y = 0;
printf("%d\n", y);  /* sûr — affiche 0 */

C est un langage fortement typé

En C, le type d'une variable est fixé à la déclaration et ne peut pas être modifié. Toute tentative de redéclaration ou d'affectation d'un type incompatible provoque une erreur.

Exemple n°2 — Erreurs de typage

int a;
a = 5.6;    /* Attention : 5.6 est tronqué → a vaut 5 (pas d'erreur, mais perte de données) */
float a;    /* Erreur de compilation : redéclaration de "a" dans la même portée */

/* Correct : déclarer le bon type dès le départ */
float b = 5.6;   /* b vaut 5.6 */
int   c = 5;     /* c vaut 5   */

int x = 9.99;     /* x vaut 9  — pas d'erreur, mais perte de .99 */
int y = -2.7;     /* y vaut -2 — troncature vers zéro            */

/* Solution : utiliser le bon type ou un cast explicite */
float f = 9.99;
int   n = (int)f;  /* cast explicite — intention claire */

2. Constantes

Exemple n°3 — Déclaration de constantes

#include <stdio.h>
#define TAILLE_MAX 100         /* constante préprocesseur */

int main(void)
{
    const double PI = 3.14159;  /* constante typée */
    const int    NB_JOURS = 7;

    printf("PI        = %f\n", PI);
    printf("NB_JOURS  = %d\n", NB_JOURS);
    printf("TAILLE_MAX = %d\n", TAILLE_MAX);

    return 0;
}

Exemple n°4 — Tentative de modification d'une constante

const double PI = 3.14;
PI = 4.6;   /* Erreur de compilation : assignment of read-only variable 'PI' */

3. Variables statiques

static type nom_variable = valeur;

Exemple n°5 — Variable statique vs variable automatique

#include <stdio.h>

/* Version avec variable statique — cpt persiste entre les appels */
int tester_static(void)
{
    static int cpt = 0;  /* initialisée une seule fois */
    cpt++;
    return cpt;
}

/* Version avec variable automatique — cpt réinitialisée à chaque appel */
int tester_auto(void)
{
    int cpt = 0;         /* réinitialisée à chaque appel */
    cpt++;
    return cpt;
}

int main(void)
{
    printf("--- Variable statique ---\n");
    printf("Appel 1 : %d\n", tester_static());   /* 1 */
    printf("Appel 2 : %d\n", tester_static());   /* 2 */
    printf("Appel 3 : %d\n", tester_static());   /* 3 */

    printf("--- Variable automatique ---\n");
    printf("Appel 1 : %d\n", tester_auto());     /* 1 */
    printf("Appel 2 : %d\n", tester_auto());     /* 1 */
    printf("Appel 3 : %d\n", tester_auto());     /* 1 */

    return 0;
}

--- Variable statique ---
Appel 1 : 1
Appel 2 : 2
Appel 3 : 3
--- Variable automatique ---
Appel 1 : 1
Appel 2 : 1
Appel 3 : 1

Propriétés des variables statiques

int initializer(void) { return 5; }

int main(void)
{
    static int i = initializer();  /* Erreur : initializer element is not a compile-time constant */
    static int j = 5;              /* Correct : littéral constant */
    return 0;
}

/* fichier calcul.c */
static int compteur = 0;    /* visible uniquement dans calcul.c */
static void aide(void) { } /* fonction locale au fichier        */

int publique(void) { return ++compteur; }  /* visible de l'extérieur */

struct Point {
    int x;
    static int compteur;  /* Erreur : membre static interdit */
};

/* Correct : la structure entière est statique */
static struct Point origine = {0, 0};

Récapitulatif