Jeux Libres
       
           

» Les Tutoriels » Apprenez à programmer en C++ ! » Utiliser la mémoire

Note : Vous vous apprêtez à lire un tutoriel de M@teo21 et Nanoc initialement publié à cette adresse sous la licence Creative Commons BY-NC-SA 2.0.

Utiliser la mémoire


Jusqu'à présent, vous avez découvert comment créer vos premiers programmes en mode console. Vous avez aussi appris à les compiler, ce qui n'a pas été une mince affaire. Pour l'instant les programmes que vous avez réalisés sont très simples. Ils affichent des messages à l'écran et c'est un peu tout. :(
Je suis d'accord avec vous, ce n'est pas assez pour faire quelque chose d'intéressant. Cela est principalement dû au fait que vos programmes ne savent pas interagir avec leurs utilisateurs. C'est ce que nous allons apprendre à faire dans le chapitre suivant, puisque je vais vous montrer comment demander des informations à l'utilisateur. Nous pourrons ainsi écrire notre premier programme interactif.

Mais avant ça, il va nous falloir travailler dur, puisque je vais vous présenter une notion fondamentale en informatique. Nous allons parler des variables.

L'idée de base qui se cache derrière la notion de variable c'est de mettre quelque chose dans la mémoire de l'ordinateur afin de le ré-utiliser plus tard. J'imagine que vous avez tous déjà eu une calculatrice entre les mains. Sur ces outils, il y a généralement des touches
M+
,
M-
,
MC
, etc. qui permettent de stocker un résultat intermédiaire d'un calcul dans la mémoire de la calculatrice et de reprendre ce nombre plus tard.
Nous allons apprendre à faire la même chose avec votre ordinateur, qui n'est après tout qu'une grosse machine à calculer. ;)

Une fois que nous aurons appris à déclarer des variables, nous pourrons les utiliser pour interagir avec les utilisateurs de nos programmes et leur demander par exemple, leur nom ou leur âge.





Chapitre précédent     Sommaire     Chapitre suivant


Qu'est-ce qu'une variable ?


Je vous ai donné l'exemple de la mémoire de la calculatrice avant parce que dans le monde de l'informatique le principe de base est le même. Il y a quelque part, dans votre ordinateur, des composants électroniques qui sont capables de contenir une valeur et de la conserver pendant un certain temps. La manière dont tout cela fonctionne exactement est très complexe. :(

Je vous rassure tout de suite, on n'a absolument pas besoin de comprendre comment ça marche pour pouvoir, nous aussi, mettre des valeurs dans la mémoire du PC. Toute la partie compliquée sera gérée par le compilateur et le système d'exploitation. Elle est pas belle la vie ?



La seule et unique chose que vous avez besoin de savoir, c'est qu'une variable est une partie de la mémoire que l'ordinateur nous prête pour y mettre des valeurs. Imaginez que l'ordinateur possède dans ses entrailles une grande armoire. Cette armoire possède des milliers (des milliards) de petits tiroirs, ce sont des endroits que nous allons pouvoir utiliser pour mettre nos variables.

Dans le cas d'une calculatrice toute simple, on ne peut généralement stocker qu'un seul nombre à la fois. Vous vous doutez bien que dans le cas d'un programme, il va falloir conserver plus d'une chose simultanément. Il faut donc un moyen de différencier les variables pour pouvoir par la suite y accéder. Chaque variable possède donc un nom. C'est en quelque sorte l'étiquette qui est collée sur le tiroir.

L'autre chose qui distingue la calculatrice de l'ordinateur, c'est que nous aimerions pouvoir stocker des tas de choses différentes, des nombres, des lettres, des phrases, des images, etc. C'est ce qu'on appelle le type d'une variable. Vous pouvez vous imaginez cela comme étant la forme du tiroir. On utilise en effet pas les mêmes tiroirs pour stocker des bouteilles ou des livres.

Les noms de variables



Commençons par la question du nom des variables. En C++, il y a quelques règles qui régissent les différents noms autorisés ou interdits.

  • 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.

Le mieux est encore de vous donner quelques exemples. Les noms ageZero, nom_du_zero ou encore NOMBRE_ZEROS sont tous des noms valides. AgeZéro, _nomzero ne le sont par contre pas.

A cela s'ajoute une règle supplémentaire qui est valable pour tout ce que l'on écrit en C++ et pas seulement pour les variables. Le langage fait la différence entre les majuscules et les minuscules. En termes techniques, on dit que C++ est sensible à la casse. Donc, nomZero, nomzero, NOMZERO et NomZeRo sont tous des noms de variables différents.

Pour des questions de lisibilité, il est important d'utiliser des noms de variables qui décrivent bien ce qu'elles contiennent. On préfèrera donc choisir ageUtilisateur comme nom plutôt que maVar ou variable1.
Pour le compilateur, cela ne joue aucun rôle. Mais pour vous et pour les gens qui travailleront avec vous sur le même programme, c'est très important.


Personnellement, j'utilise une "convention" partagée par beaucoup de programmeurs. Dans tous les gros projets regroupant des milliers de programmeurs on trouve des règles très strictes et parfois difficiles à suivre. Celles que je vous propose ici permettent de garder une bonne lisibilité et surtout vous permettront de bien comprendre tous les exemples dans la suite de ce cours.

  • 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.

Voyons ça avec des exemples. Prenons le cas d'une variable censée contenir l'âge de l'utilisateur du programme.

  • AgeUtilisateur: Non, car la première lettre est une majuscule.
  • age_utilisateur: Non, car les mots ne sont pas collés
  • ageutilisateur: Non, car le deuxième mot ne commence pas par une majuscule.
  • maVar: Non, car la nom ne décrit pas ce que contient la variable.
  • ageUtilisateur: Ok.

Je vous conseille fortement d'utiliser la même convention. Rendre son code lisible et facilement compréhensible par d'autres programmeurs est très important.

Les types de variables



Reprenons. Nous avons appris qu'une variable a un nom et un type. Nous savons comment nommer nos variables, voyons maintenant leurs différents types. L'ordinateur aime savoir ce qu'il a dans sa mémoire, il faut donc indiquer quel type d'élément va contenir la variable que nous aimerions utiliser. Est-ce un nombre, une mot, une lettre ? Il faut le spécifier.

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

Nom du typeCe qu'il peut contenir
boolPeut contenir deux valeurs : "vrai" (true) ou "faux" (false).
charUne lettre.
intUn nombre entier.
unsigned intUn nombre entier positif ou nul.
doubleUn nombre à virgule.
stringUne chaîne de caractères. C'est-à-dire une suite de lettres, un mot, une phrase.

Si vous tapez un de ces noms de type dans votre IDE, vous devriez voir le mot se colorer. L'IDE l'a reconnu, c'est bien la preuve que je ne vous raconte pas des salades. Le cas de string est différent; nous verrons plus loin pourquoi. Je peux vous assurer qu'on va beaucoup en reparler. :p

Il existe d'autres types de variables plus spécifiques. Par exemple des nombres entiers avec d'autres limites minimales et maximales. Ils sont plus rarement utilisés.


Quand on a besoin d'une variable, il faut donc se poser la question du genre de choses qu'elle va contenir. Si vous avez besoin d'une variable pour stocker le nombre de personnes qui utilisent votre programme, alors utilisez un int ou unsigned int, pour stocker le poids d'un gigot, on utilisera un double et pour conserver en mémoire le nom de votre meilleur ami, on choisira une chaîne de caractères string.

Mais, à quoi sert le type bool ? J'en ai jamais entendu parler.


C'est ce qu'on appelle un booléen. C'est-à-dire une variable qui ne peut prendre que deux valeurs, vrai (true en anglais) ou faux (false en anglais). On les utilise par exemple pour stocker des informations comme, La lumière est-elle allumée ?, L'utilisateur a-t-il le droit d'utiliser cette fonctionnalité ?, Le mot de passe est-il correct ?
Si vous avez besoin de conserver le résultat d'une question de ce genre, alors pensez à ce type de variable.


Déclarer une variable


Assez parlé, il est temps d'entrer dans le vif du sujet et de demander à l'ordinateur de nous prêter un de ses tiroirs. En terme technique, on parle de déclaration de variable.

Il nous faut indiquer à l'ordinateur, le type de la variable que l'on veut, son nom et enfin sa valeur. Pour se faire, c'est très simple. On indique les choses exactement dans cet ordre.

TYPE   NOM   (VALEUR);

On peut aussi utiliser la même syntaxe que dans le langage C:

TYPE   NOM = VALEUR;

Les deux versions sont strictement équivalentes. Je vous conseille cependant d'utiliser la première pour des raisons qui deviendront claires plus tard. La deuxième version ne sera pas utilisée dans la suite du cours, je vous l'ai mise pour que vous puissiez comprendre les nombreux exemples que l'on peut trouver sur le web et qui utilisent cette version de la déclaration d'une variable.

N'oubliez pas le point-virgule (;) à la fin de la ligne ! C'est le genre de choses que l'on oublie très facilement et le compilateur n'aime pas ça du tout.


Reprenons le morceau de code minimal et ajoutons-y une variable pour stocker l'âge de l'utilisateur.
1
2
3
4
5
6
7
8
#include <iostream>
using namespace std;
 
int main()
{
   int ageUtilisateur(16);
   return 0;
}

Que se passe-t-il à la ligne 6 de ce programme ?
L'ordinateur voit que l'on aimerait lui 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.

A partir de cette ligne, vous êtes donc l'heureux possesseur d'un tiroir dans la mémoire de l'ordinateur. :)


Comme nous allons avoir besoin de beaucoup de tiroirs dans la suite du cours, je vous propose d'utiliser des schémas un peu plus simples. On va beaucoup les utiliser par la suite, il est donc bien de s'y habituer tôt.


Je vais vous décrire un peu ce qu'on voit sur le schéma. Le gros rectangle bleu représente la mémoire de l'ordinateur. Pour l'instant, elle est presque vide. Le carré jaune est la zone de mémoire que l'ordinateur vous a prêtée. C'est l'équivalent de notre tiroir. Il contient, comme avant, le nombre 16 et on peut lire le nom ageUtilisateur sur l'étiquette qui y est accrochée.
Je ne suis pas bon en dessin, donc il faut un peu imaginer hein. ;)

Ne nous arrêtons pas en si bon chemin. Déclarons d'autres variables.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#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 choses importantes à remarquer ici, la première est que 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. L'autre chose dont il faut se souvenir, c'est que pour le type char, il faut mettre la lettre que l'on veut entre apostrophes. Il faut écrire char lettre('a'); et pas char lettre(a);. C'est une erreur que tout le monde fait, moi le premier. ;)

Il est toujours bien de mettre un commentaire pour expliquer à quoi va servir la variable.


Je peux donc compléter mon schéma en lui ajoutant nos nouvelles variables.


Vous pouvez évidemment compiler et tester le programme ci-dessus. Vous constaterez qu'il ne fait strictement rien. J'espère que vous n'êtes pas trop déçu. Il se passe en réalité énormément de choses mais comme je vous l'ai dit au début, ces opérations sont cachées et ne nous intéressent pas vraiment. En voici quand même un résumé chronologique.

  • Votre programme demande au système d'exploitation de lui fournir un peu de mémoire
  • L'OS a regardé s'il en avait encore à disposition et a indiqué au programme quel tiroir utiliser.
  • Le programme a écrit la valeur 16 dans la case mémoire.
  • Il a ensuite recommencé pour les quatre autres variables.
  • En arrivant à la dernière ligne, le programme a vidé ses tiroirs et les a rendus à l'ordinateur.

Et tout ça sans que rien ne se passe du tout à l'écran ! C'est normal, on n'a nulle part indiqué qu'on voulait afficher quelque chose.

Le cas des strings



Les chaînes de caractères sont un petit peu plus complexes à déclarer, mais rien d'insurmontable, je vous rassure. La première chose à faire est d'ajouter une petite ligne au début de votre programme. Il faut, en effet, indiquer au compilateur que nous souhaitons utiliser des strings. Sans ça, il n'inclurait pas les outils nécessaires à leur gestion. La ligne à ajouter est #include <string>.

Voici ce que ça donne.
1
2
3
4
5
6
7
8
9
#include <iostream>
#include <string>
using namespace std;
 
int main()
{
   string nomUtilisateur("Albert Einstein");
   return 0;
}

L'autre différence se situe au niveau de la déclaration elle-même. Comme vous l'avez certainement constaté, j'ai utilisé des guillemets autour de la valeur. Un peu comme pour les lettres, mais cette fois ce sont des guillemets doubles (") et pas juste des apostrophes ('). D'ailleurs votre IDE devrait colorier les mots "Albert Einstein" d'une couleur différente du 'a' de l'exemple précédent, même si ce n'est pas le cas sur le site du zéro. Confondre ' et " est une erreur à nouveau très courante qui fera hurler de douleur votre compilateur. Mais ne vous en faites pas pour lui, il en a vu d'autres. ;)

Une astuce pour gagner de la place



Avant de passer à la suite, il faut que je vous présente une petite astuce qui vous fera gagner des lignes dans vos programmes.
Si vous avez plusieurs variables du même type à déclarer, vous pouvez le faire sur une seule ligne en les séparant par une virgule (,). Voici comment:
1
2
3
int a(2),b(4),c(-1);  //On declare trois cases memoires nommees a,b et c et qui contiennent les valeurs 2,4 et -1 respectivement.
 
string prenom("Albert"), nom("Einstein"); //On declare deux cases pouvant contenir des chaines de caracteres

Ça peut être pratique quand on a besoin de beaucoup de variables d'un coup. On économise l'écriture du type à chaque fois. Vous le verrez encore par la suite, la fainéantise est une qualité importante du programmeur.


Déclarer sans initialiser


Maintenant que nous avons vu le principe général, il est temps de plonger un petit peu plus dans les détails.

Lors de la déclaration d'une variable, votre programme effectue en réalité deux opérations successives.

  • Il demande à l'ordinateur de lui fournir une zone dans la mémoire. En termes techniques, on parle d'allocation de la mémoire.
  • Il remplit cette case avec la valeur fournie. On parle alors d'initialisation de la variable.

Ces deux étapes s'effectuent automatiquement et sans que l'on ait besoin de rien faire. Voilà pour la partie vocabulaire de ce chapitre. ;)

Il arrive parfois que l'on ne sache pas quelle valeur donner à une variable lors de sa déclaration. Il est alors possible d'effectuer uniquement l'allocation sans l'initialisation.
Il suffit d'indiquer le type et le nom de la variable sans spécifier de valeur.

TYPE   NOM;

Et sous forme de code C++ complet, voilà ce que ça donne :
1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <string>
using namespace std;
 
int main()
{
   string nomJoueur;  
   int nombreJoueurs;
   bool aGagne;         //Le joueur a-t-il gagn ?
 
   return 0;
}

Simple non ? :p Je savais que ça allait vous plaire. Et je vous offre même un schéma en bonus !


On a bien trois cases dans la mémoire et les trois étiquettes correspondantes. La chose nouvelle est que l'on ne sait pas ce que contiennent ces trois cases. Nous verrons dans le chapitre suivant comment modifier le contenu d'une variable et donc remplacer ces points d'interrogation par d'autres valeurs plus intéressantes.

Je viens de vous montrer comment déclarer des variables sans leur donner de valeur initiale. Je vous conseille par contre de toujours initialiser vos variables. Ce que je vous ai montré là, n'est à utiliser que dans les cas où l'on ne sait vraiment pas quoi mettre comme valeur. Ce qui est très rare.


Il est temps d'apprendre à effectuer quelques opérations avec nos variables. Parce que vous en conviendrez, pour l'instant, on n'a pas appris grand chose d'utile. Notre écran est resté désespérément vide. ;)


Afficher la valeur d'une variable


Dans le chapitre précédent, vous avez appris à afficher du texte à l'écran. J'espère que vous vous souvenez encore de ce qu'il faut faire.

Oui, c'est bien ça. Il faut utiliser cout et les chevrons (<<). Parfait. Parce que pour afficher le contenu d'une variable, c'est la même chose. A la place du texte à afficher, on met simplement le nom de la variable.
1
cout << ageUtilisateur;

Facile non ?

Prenons un exemple complet pour essayer.
1
2
3
4
5
6
7
8
9
10
#include <iostream>
using namespace std;
 
int main()
{
   int ageUtilisateur(16);
   cout << "Votre age est : ";
   cout << ageUtilisateur;
   return 0;
}

Une fois compilé, ce code affiche ceci à l'écran:
1
Votre age est : 16

Exactement ce que l'on voulait ! ;) On peut même faire encore plus simple. Tout mettre sur une seule ligne ! Et on peut même ajouter un retour à la ligne à la fin.

Pensez à mettre une espace à la fin du texte. Comme ça la valeur de votre variable sera détachée du texte lors de l'affichage.

1
2
3
4
5
6
7
8
9
#include <iostream>
using namespace std;
 
int main()
{
   int ageUtilisateur(16);
   cout << "Votre age est : " << ageUtilisateur << endl;
   return 0;
}

Et on peut même afficher le contenu de plusieurs variables à la fois.
1
2
3
4
5
6
7
8
9
10
11
12
#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 le résultat escompté.
1
Vous vous appelez Albert Einstein et votre QI vaut 150

Mais je pense que vous n'en doutiez pas vraiment. Nous verrons dans le chapitre suivant comment faire le contraire, récupérer la saisie d'un utilisateur et la stocker dans une variable.


Les références


Avant de terminer ce chapitre, il nous reste une notion importante à voir. Il s'agit des références. Je vous ai expliqué au tout début de ce chapitre qu'une variable pouvait être considérée comme étant 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 C++ c'est la même chose, on peut coller une deuxième (troisième, ..., dixième, etc.) étiquette à une case mémoire.
On obtient alors un deuxième moyen d'accéder à la même case mémoire. Un petit peu comme si on donnait un surnom à une variable en plus de son nom normal. On parle parfois d'alias, mais le mot correct en C++ est référence.

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


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

Au niveau du code, on utilise une esperluette (&) pour déclarer une référence sur une variable. Voyons ça avec un petit exemple.
1
2
3
int ageUtilisateur(16);  //Declaration d'une variable.
 
int& maVariable(ageUtilisateur); //Declaration d'une reference nommee 'maVariable' qui est accrochee a la variable 'ageUtilisateur'.

A 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. :soleil:

On dit que maVariable fait référence à ageUtilisateur.

La référence doit impérativement être du même type que la variable à laquelle elle est accrochée ! Un int& ne peut faire référence qu'à un int, de même qu'un string& ne peut être associé qu'à une variable de type string.


Essayons pour voir. On peut afficher l'âge de l'utilisateur comme d'habitude et via une référence.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
using namespace std;
 
int main()
{
   int ageUtilisateur(18);   //Une variable pour contenir l'ge de l'utilisateur
   int& maReference(ageUtilisateur); //Et une rfrence sur la variable ageUtilisateur
 
   //On peut, a partir d'ici, utiliser 'ageUtilisateur' ou 'maReference' indistinctement.
   //puisque ce sont deux tiquettes de la mme case en mmoire
 
   cout << "Vous avez " << ageUtilisateur << "  ans. (via variable)" << endl; //On affiche comme toujours
   cout << "Vous avez " << maReference << " ans. (via reference)" << endl;    //Et on affiche en utilisant la rfrence
   
   return 0;
}

Ce qui donne évidemment le résultat escompté.
1
2
Vous avez 18 ans. (via variable)
Vous avez 18 ans. (via reference)

Une fois qu'elle a été déclarée, on peut manipuler la référence comme si on manipulait la variable elle-même. Il n'y a aucune différence entre les deux.

Euh... Mais à quoi est-ce que ça peut bien servir ?


Bonne question ! :) C'est vrai que dans l'exemple que je vous ai donné, on peut très bien s'en passer. Mais 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.
Pour l'instant, ça 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 important de se familiariser avec la notion avant de devoir l'utiliser dans des cas plus compliqués.




Bon !

Récapitulons ce que nous avons appris. A la fin de ce chapitre, vous savez :

  • Déclarer une variable, c'est-à-dire demander à l'ordinateur de nous prêter un peu de sa mémoire pour y stocker des informations.
  • Afficher le contenu d'une variable à l'écran.
  • Définir une référence (un alias) sur une autre variable.

Moi je trouve que c'est pas mal pour un seul chapitre. Il est donc temps de faire une pause avant de continuer avec des choses bien plus intéressantes : recevoir des informations de l'utilisateur et effectuer des opérations. Comme une calculatrice en fait. ;)

Assurez-vous que vous avez bien compris le tout parce que des variables vous allez en manger tout le restant de votre vie et notamment dans le chapitre suivant. ^^



Chapitre précédent     Sommaire     Chapitre suivant



Distribué et adapté par David
Consulté 15173 fois



Hébergeur du site : David
Version PHP : 5.4.45-0+deb7u2
Uptime : 240 jours 11 heures 28 minutes
Espace libre : 1570 Mo
Dernière sauvegarde : inconnue
Taille de la sauvegarde : 1112 Mo


5357110 pages ont été consultées sur le site !
Dont 2670 pages pendant les 24 dernières heures.

Page générée en 0.594 secondes


Nos sites préférés
- Création d'un jeu de plateforme de A à Z avec SDL
- Zelda ROTH : Jeux amateurs sur le thème de Zelda
- Zeste de Savoir : la connaissance pour tous et sans pépins
- YunoHost : s'héberger soi-même en toute simplicité
- Site de Fvirtman : recueil de projets et de codes en C et C++
- Par ici la sortie : le site des idées de sorties


  © 2005-2019 linor.fr - Toute reproduction totale ou partielle du contenu de ce site est strictement interdite.