Variables en C++ : déclaration, initialisation et portée expliquées

Ce qu'est une variable

Une variable est une zone de mémoire nommée qui contient une valeur. En C++, chaque variable possède un type fixe - choisi lors de sa déclaration - et ce type ne change jamais. C'est ce qui rend C++ à typage statique : le compilateur connaît le type de chaque variable avant l'exécution du programme et refuse de compiler du code qui stocke une valeur du mauvais type.

Une déclaration comporte trois parties : le type, le nom et (presque toujours) une valeur initiale.

#include <iostream>
#include <string>
using namespace std;

int main() {
    int age = 30;
    string name = "Ada";
    bool isActive = true;

    cout << name << " is " << age << ", active: " << isActive << "\n";
    return 0;
}

Lisez int age = 30; comme « crée un int appelé age et mets-y 30 ». Le point-virgule termine l'instruction, exactement comme la page sur les commentaires l'a montré pour chaque instruction. Remarquez que isActive s'est affiché 1 : un bool apparaît par défaut sous la forme 1/0, ce sur quoi s'appuie la page sur les types de données.

Initialisation vs. affectation

Ces deux notions se ressemblent mais sont des opérations différentes, et cette différence est l'une des idées les plus importantes de cette page.

L'initialisation donne à une variable sa première valeur dans le cadre de la déclaration. L'affectation modifie la valeur d'une variable qui existe déjà.

#include <iostream>
using namespace std;

int main() {
    int score = 95;   // initialisation - première valeur, donnée à la déclaration
    score = 100;      // affectation - modification d'une variable existante
    score = score + 5;

    cout << score << "\n";
    return 0;
}

Vous pouvez déclarer sans initialiser puis affecter plus tard, mais soyez prudent :

#include <iostream>
using namespace std;

int main() {
    int score;     // déclarée, mais contient des données poubelles pour l'instant
    score = 95;    // elle a maintenant une vraie valeur
    cout << score << "\n";
    return 0;
}

Cela fonctionne parce que nous avons affecté score avant de le lire. La version dangereuse consiste à le lire d'abord - abordée juste après.

Le piège de la variable non initialisée

C'est le piège classique de C++ qui n'existe pas dans beaucoup d'autres langages. Lire une variable locale qui a été déclarée mais à laquelle on n'a jamais donné de valeur est un comportement indéfini : la variable contient les octets qui se trouvaient par hasard à cet emplacement mémoire.

int score;             // non initialisée
std::cout << score;    // comportement indéfini - affiche des données poubelles, ou « fonctionne », ou plante

Le compilateur construira cela sans broncher. Il peut afficher 0, il peut afficher 32766, et il peut se comporter différemment à chaque exécution ou sur chaque machine - ce qui rend ces bogues atroces à traquer. Deux parades :

• Initialisez toujours à la déclaration. int score = 0; ne coûte rien et supprime tout le problème.
• Activez les avertissements. Compiler avec -Wall -Wextra amène le compilateur à signaler de nombreuses lectures non initialisées avant qu'elles ne vous mordent.

Préférez la première option pour chaque variable locale : donnez-lui une valeur de départ raisonnable au moment même où vous la créez.

Styles d'initialisation : =, () et {}

C++ propose plusieurs façons d'écrire une valeur initiale. Elles font pour la plupart la même chose, mais l'initialisation par accolades possède une sécurité supplémentaire qui mérite d'être connue.

#include <iostream>
using namespace std;

int main() {
    int a = 5;     // initialisation par copie
    int b(5);      // initialisation directe
    int c{5};      // initialisation par accolades (uniforme) - C++11 et ultérieur

    cout << a << " " << b << " " << c << "\n";
    return 0;
}

La raison de recourir à {} est qu'elle rejette les conversions avec rétrécissement (narrowing) : les affectations qui perdraient silencieusement des données. Avec =, une valeur fractionnaire est tronquée sans bruit ; avec {}, le compilateur vous arrête :

int x = 3.9;    // compile - x devient silencieusement 3 (le .9 est jeté)
int y{3.9};     // erreur de compilation - le rétrécissement de double vers int n'est pas autorisé

Détecter cela à la compilation est exactement ce que vous voulez. Une habitude moderne courante consiste à utiliser {} par défaut pour cette vérification supplémentaire, et à se rabattre sur = uniquement lorsque l'initialisation par copie se lit plus naturellement.

Règles et conventions de nommage

C++ impose quelques règles strictes, puis chacun ajoute des conventions par-dessus. Les règles : un nom peut contenir des lettres, des chiffres et _ ; il ne peut pas commencer par un chiffre ; il ne peut pas être un mot-clé réservé (comme int ou return) ; et il est sensible à la casse (age et Age sont deux variables différentes). Évitez les noms qui commencent par un underscore suivi d'une majuscule, ou qui contiennent deux underscores à la suite : ils sont réservés à l'implémentation.

Les conventions que suit la plupart du code C++ :

• Les variables utilisent snake_case ou camelCase - choisissez-en une et restez cohérent : item_count ou itemCount.
• Les noms doivent décrire la valeur : count, pas c ; user_email, pas x.

#include <iostream>
using namespace std;

int main() {
    int item_count = 3;
    double price_per_item = 4.50;
    double total_price = item_count * price_per_item;

    cout << "Total: " << total_price << "\n";
    return 0;
}

Des noms clairs ne sont pas de la décoration : c'est ainsi que votre futur vous relira le code. total_price = item_count * price_per_item se comprend tout seul d'une manière que t = c * p n'atteindra jamais.

Portée des variables

Une variable n'existe qu'à l'intérieur du bloc - les { ... } - où elle est déclarée, et elle est détruite à l'accolade fermante. C'est sa portée (scope). Une variable déclarée dans une boucle ou un bloc if est invisible en dehors :

#include <iostream>
using namespace std;

int main() {
    int total = 0;

    for (int i = 1; i <= 3; i++) {
        int square = i * i;   // 'square' ne vit qu'à l'intérieur du corps de cette boucle
        total += square;
    }

    cout << "Total: " << total << "\n";
    // cout << square;   // erreur - 'square' est hors de portée ici
    return 0;
}

i et square appartiennent tous deux à la boucle et disparaissent à sa fin ; total est déclaré dans le bloc extérieur, donc il survit. Un bloc interne peut aussi masquer (shadow) un nom d'un bloc externe : une nouvelle variable du même nom cache temporairement l'externe jusqu'à la fermeture du bloc interne, ce qui est une source fréquente de confusion ; évitez donc de réutiliser des noms entre portées imbriquées.

L'enseignement pratique : déclarez chaque variable dans le plus petit bloc qui en a besoin, et initialisez-la là. Une portée étroite signifie moins de noms qui se disputent votre attention et moins de risques de lire une valeur loin de l'endroit où elle a été définie.

Ensuite : Les types de données

Chaque variable de cette page a commencé par un type - int, double, string, bool. La page suivante détaille les types de données de C++ : les types fondamentaux et leurs tailles, les entiers signés et non signés, float vs. double, char, et comment choisir le bon type pour la tâche.