Apprenez à programmer en C++

Comprenez ce qu'est une variable

Suivez ces règles pour nommer une variable

Les règles en C++ pour nommer correctement une variable :

• les noms de variables sont constitués de lettres, de chiffres et du tiret-bas _ uniquement ;

• le premier caractère doit être une lettre (majuscule ou minuscule) ;

• on ne peut pas utiliser d'accents ;

• on ne peut pas utiliser d'espaces dans le nom ;

• utiliser des noms de variables qui décrivent bien ce qu'elles contiennent. 

En plus de ces règles, il existe une convention partagée par beaucoup de programmeurs, pour harmoniser les noms de variables et améliorer la lisibilité :

• les noms de variables commencent par une minuscule ;

• si le nom se décompose en plusieurs mots, ceux-ci sont collés les uns aux autres ;

• chaque nouveau mot (excepté le premier) commence par une majuscule.

Attribuez un type à chaque variable

Voici la liste des types de variables que l'on peut utiliser en C++ :

Déclarez une variable

Pour déclarer une variable, il faut écrire un code qui indique, dans l'ordre :

1. Son type.

2. Son nom.

3. Et la valeur qu'elle contient :

TYPE NOM(VALEUR);

Reprenons le morceau de code minimal, et ajoutons une variable pour stocker l'âge de l'utilisateur.

#include <iostream>
using namespace std;

int main()
{
    int ageUtilisateur(16);
    return 0;
}

L'ordinateur voit qu'on veut emprunter un tiroir dans sa mémoire avec les propriétés suivantes :

• il peut contenir des nombres entiers ;

• il a une étiquette indiquant qu'il s'appelle ageUtilisateur  ;

• il contient la valeur 16.

En déclarant cette variable, voici ce qu'il se passe schématiquement :

Le petit carré où on voit le numéro 16 représente la zone de mémoire que l'ordinateur nous a prêtée. C'est l'équivalent de notre tiroir. Son étiquette affiche ageUtilisateur  , et il contient le nombre 16.

Déclarons d'autres variables :

#include <iostream>
using namespace std;

int main()
{
    int ageUtilisateur(16);
    int nombreAmis(432);      //Le nombre d'amis de l'utilisateur

    double pi(3.14159);

    bool estMonAmi(true);    //Cet utilisateur est-il mon ami ?

    char lettre('a');

    return 0;
}

Il y a deux-trois choses importantes à remarquer ici :

1. Les variables de type bool ne peuvent avoir pour valeur que true ou false  , c'est donc une de ces deux valeurs qu'il faut mettre entre les parenthèses.

2. Pour le type char  , il faut mettre la lettre souhaitée entre apostrophes :char lettre('a');  .

3. Les commentaires permettent d'expliquer à quoi va servir la variable.

Bref, maintenant, je peux compléter mon schéma avec nos nouvelles variables :

Dans ce programme, nous n'avons pas encore déclaré de variables de type string. Et en fait, la procédure est un peu particulière. En plus de la déclaration classique, il faut :

• ajouter une ligne au début de votre programme, qui demande au compilateur d'inclure les outils nécessaires à la gestion des strings, #include <string>  :

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

int main()
{
    string nomUtilisateur("Albert Einstein");
    return 0;
}

• placer des guillemets autour de la valeur ; un peu comme pour les char mais, cette fois, ce sont des guillemets doubles ( "  ) et pas juste des apostrophes ( '  ).

Avant de passer à la suite, je voudrais vous parler d'une façon de déclarer une variable, sans valeur. Cela peut arriver dans de rares cas, lorsque l'on ne sait pas ce que contient cette variable.

D'ordinaire, lors de la déclaration d'une variable, votre programme effectue automatiquement deux opérations successives :

1. Il demande à l'ordinateur de lui fournir une zone de stockage dans la mémoire. On parle alors d'allocation de la variable.

2. Il remplit cette case avec la valeur fournie. On parle alors d'initialisation de la variable.

Sous forme de code C++ complet, voilà ce que cela donne :

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

int main()
{
    string nomJoueur;  
    int nombreJoueurs;
    bool aGagne;         //Le joueur a-t-il gagné ?

    return 0;
}

Voici donc schématiquement ce qu'il se passe :

On a bien trois cases dans la mémoire (et les trois étiquettes correspondantes), mais on ne sait pas ce qu'elles contiennent.

Il est temps d'apprendre à effectuer quelques opérations avec nos variables, parce que pour l'instant, notre écran est resté désespérément vide !

Affichez la valeur d'une variable

Au chapitre précédent, vous avez appris à afficher du texte à l'écran avec cout et les chevrons ( <<  ). Pour afficher le contenu d'une variable, c'est la même chose. À la place du texte à afficher, on met simplement le nom de la variable.

Prenons un exemple complet pour essayer :

#include <iostream>
using namespace std;

int main()
{
    int ageUtilisateur(16);
    cout << "Votre age est : ";
    cout << ageUtilisateur;
    return 0;
}

Une fois compilé, ce code affiche à l'écran :

Votre age est : 16

On peut faire encore plus simple et tout mettre sur une seule ligne :

#include <iostream>
using namespace std;

int main()
{
    int ageUtilisateur(16);
    cout << "Votre age est : " << ageUtilisateur << endl;
    return 0;
}

On peut aussi afficher le contenu de plusieurs variables à la fois :

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

int main()
{
    int qiUtilisateur(150);
    string nomUtilisateur("Albert Einstein");
    
    cout << "Vous vous appelez " << nomUtilisateur << " et votre QI vaut " << qiUtilisateur << endl;
    return 0;
}

Ce qui affiche :

Vous vous appelez Albert Einstein et votre QI vaut 150

Dans cette vidéo, on récapitule tout pour voir comment créer et utiliser une variable :

Utilisez les références

Au tout début de ce chapitre, je vous disais qu'une variable pouvait être considérée comme une case mémoire avec une étiquette portant son nom. Dans la vraie vie, on peut très bien mettre plusieurs étiquettes sur un objet donné.

En fait, c'est la même chose en C++ : on peut coller une deuxième étiquette à une case mémoire (et même plus, si on veut). On obtient alors un deuxième moyen d'accéder à la même case mémoire.

Schématiquement, on peut se représenter une référence comme ceci :

On a une seule case mémoire, mais deux étiquettes qui lui sont accrochées.

Au niveau du code, on utilise une esperluette ( &  ) pour déclarer une référence sur une variable :

int ageUtilisateur(16);  //Déclaration d'une variable.

int& maVariable(ageUtilisateur); //Déclaration d'une référence nommée maVariable qui est accrochée à la variable ageUtilisateur

À la ligne 1, on déclare une case mémoire nommée ageUtilisateur  , dans laquelle on met le nombre 16. Et à la ligne 3, on accroche une deuxième étiquette à cette case mémoire. On a donc dorénavant deux moyens d'accéder au même espace dans la mémoire de notre ordinateur. On dit que maVariable fait référence à ageUtilisateur  .

Essayons pour voir. On peut afficher l'âge de l'utilisateur comme d'habitude via une référence :

#include <iostream>
using namespace std;

int main()
{
    int ageUtilisateur(18); //Une variable pour contenir l'âge de l'utilisateur
    
    int& maReference(ageUtilisateur); //Et une référence sur la variable 'ageUtilisateur'

    //On peut utiliser à partir d'ici
    //'ageUtilisateur' ou 'maReference' indistinctement
    //Puisque ce sont deux étiquettes de la même case en mémoire

    cout << "Vous avez " << ageUtilisateur << "  ans. (via variable)" << endl;
    //On affiche, de la manière habituelle

    cout << "Vous avez " << maReference << " ans. (via reference)" << endl;
    //Et on affiche en utilisant la référence
    
    return 0;
}

Ce qui donne :

Vous avez 18 ans. (via variable)
Vous avez 18 ans. (via reference)

Bonne question. Imaginez que l'on ait besoin de cette variable dans deux parties très différentes du programme, des parties créées par différents programmeurs. Dans une des parties, un des programmeurs va s'occuper de la déclaration de la variable, alors que l'autre programmeur va juste l'afficher. Ce deuxième programmeur aura juste besoin d'un accès à la variable, et un alias sera donc suffisant.

Allez ! Une petite vidéo qui vous illustre le concept des références :

Pour l'instant, cela vous paraît très abstrait et inutile ? Il faut juste savoir que c'est un des éléments importants du C++, qui apparaîtra à de très nombreuses reprises dans ce cours. Il est donc essentiel de se familiariser avec la notion avant de devoir l'utiliser dans des cas plus compliqués.

En résumé

• Une variable est une information stockée en mémoire.

• Les noms de variables peuvent contenir des lettres, des chiffres et des tirets bas  _  uniquement ; le premier caractère doit être une lettre ; on ne peut pas utiliser d'accents ou d'espaces.

• C++ est sensible à la casse ; agemathieu est donc différent de  ageMathieu  .

• Il existe différents types de variables en fonction de la nature de l'information à stocker : int  , char  , bool  …

• Une variable doit être déclarée avant utilisation. Exemple : int ageUtilisateur(16);  .

• La valeur d'une variable peut être affichée à tout moment avec cout  .

• Les références sont des étiquettes qui permettent d'appeler une variable par un autre nom. Exemple :  int& maReference(ageUtilisateur);  .

Vous avez découvert le monde des variables et comme vous avez pu le voir dans ce chapitre, c’est très utile pour stocker en mémoire des informations. Dans le chapitre suivant, vous allez voir comment les manipuler. C’est maintenant que ça devient intéressant !