Je vous ai parlé dans l'introduction de l'intérêt des tableaux dans le cas où l'on a plusieurs variables du même type à stocker. Voyons cela avec un exemple bien connu, la liste des meilleurs scores du jeu révolutionnaire que vous allez créer un jour.
Un exemple d'utilisation
Si vous voulez afficher la liste des 5 meilleurs scores des joueurs, il va vous falloir en réalité deux listes. La liste des noms de joueurs et la liste des scores qu'ils ont obtenus. Il va donc falloir déclarer 10 variables pour mettre toutes ces informations dans la mémoire de l'ordinateur. On aura par exemple :
Code : C++ - Les variables du 'Hall of fame' | string nomMeilleurJoueur1("Nanoc");
string nomMeilleurJoueur2("M@teo21");
string nomMeilleurJoueur3("Albert Einstein");
string nomMeilleurJoueur4("Isaac Newton");
string nomMeilleurJoueur5("Archimede");
int meilleurScore1(118218);
int meilleurScore2(100432);
int meilleurScore3(87347);
int meilleurScore4(64523);
int meilleurScore5(31415);
|
Et pour afficher tout ça, il va aussi falloir pas mal de travail.
Code : C++ - Affichage du 'Hall of fame' | cout << "1) " << nomMeilleurJoueur1 << " " << meilleurScore1 << endl;
cout << "2) " << nomMeilleurJoueur2 << " " << meilleurScore2 << endl;
cout << "3) " << nomMeilleurJoueur3 << " " << meilleurScore3 << endl;
cout << "4) " << nomMeilleurJoueur4 << " " << meilleurScore4 << endl;
cout << "5) " << nomMeilleurJoueur5 << " " << meilleurScore5 << endl;
|
Ce qui fait énormément de lignes ! Imaginez maintenant que vous vouliez afficher les 100 meilleurs scores et pas seulement les 5 meilleurs. Ça serait terrible. Il vous faudrait déclarer 200 variables et écrire 100 lignes quasiment identiques pour l'affichage ! Autant arrêter tout de suite, c'est beaucoup trop de travail.
C'est là qu'interviennent les tableaux. Nous allons pouvoir déclarer les 100 meilleures scores et les noms des 100 meilleurs joueurs d'un seul coup. On va créer
une seule case dans la mémoire qui aura de la place pour contenir les 100
int qu'il nous faut et une deuxième pour contenir les 100
string. Magique non ?
Il faut quand même que les variables aient un lien entre elles pour que l'utilisation d'un tableau soit justifiée. Mettre dans un même tableau l'âge de votre chien et le nombre d'internautes connectés n'est pas correct. Même si ces deux variables sont des int.
Dans cet exemple, nous avons besoin de 100 variables. C'est-à-dire 100 places dans le tableau. C'est ce qu'on appelle, en termes techniques, la
taille du tableau. Si la taille du tableau reste inchangée et est fixée dans le code source, alors on parle d'un
tableau statique. Parfait ! C'est ce dont nous avons besoin pour notre liste des 100 meilleurs scores.
Déclarer un tableau statique
Comme toujours en C++, une variable est composée d'un nom et d'un type. Comme les tableaux sont des variables, cette règle reste valable. Il faut juste ajouter une propriété supplémentaire, la taille du tableau. Autrement dit, le nombre de compartiments que notre case mémoire va pouvoir contenir.
La déclaration d'un tableau est très similaire à celle d'une variable :
On indique le type, puis le nom choisi et enfin la taille du tableau entre crochets. Voyons ça avec un exemple.
Code : C++ - Votre premier tableau | #include <iostream>
using namespace std;
int main()
{
int meilleurScore[5]; //Declare un tableau de 5 entiers
double anglesTriangle[3]; //Declare un tableau de 3 double
return 0;
}
|
Voyons à quoi ressemble la mémoire avec un de nos schémas habituels.
On retrouve nos deux zones mémoires avec leurs étiquettes, mais cette fois, chaque zone est découpée en cases. Trois cases pour le tableau
anglesTriangle et cinq cases pour le tableau
meilleurScore. Pour l'instant toutes ces cases ne sont pas initialisées. Leur contenu est donc quelconque.
Il est également possible de déclarer un tableau en utilisant comme taille une
constante de type
int ou
unsigned int. On indique simplement le nom de la constante entre les crochets plutôt qu'un nombre.
Code : C++ | int const tailleTableau(20); //La taille du tableau
double anglesIcosagone[tailleTableau];
|
Il faut impérativement utiliser une constante comme taille du tableau.
Je vous conseille de toujours utiliser des constantes comme taille de vos tableaux plutôt que d'indiquer directement la taille entre les crochets. C'est une bonne habitude à prendre.
Bon. On a de la place dans la mémoire. Il ne nous reste plus qu'à l'utiliser.
Accéder aux éléments d'un tableau
Chaque case d'un tableau peut être utilisée comme n'importe quelle autre variable. Il n'y a aucune différence. Il faut juste y accéder d'une manière un peu spéciale. Il faut indiquer le nom du tableau et le numéro de la case. Dans le tableau
meilleurScore, on a accès à cinq variables. La première case de
meilleurScore, la deuxième, etc, jusqu'à la cinquième.
Pour accéder à une case on utilise la syntaxe
nomDuTableau[numeroDeLaCase]. Il y a juste une petite subtilité, la première case possède le numéro 0 et pas 1. Tout est en quelque sorte décalé de 1. Pour accéder à la 3
e case de
meilleurScore et y écrire une valeur, il faudra donc écrire :
Code : C++
En effet,

, la 3
e case possède le numéro 2. Si je veux remplir mon tableau des meilleurs scores comme dans l'exemple initial, je peux donc écrire :
Code : C++ - Remplissage d'un tableau | int const nombreMeilleursScores(5); //La taille du tableau
int meilleursScores[nombreMeilleursScores]; //Declaration du tableau
meilleursScores[0] = 118218; //Remplissage de la premiere case
meilleursScores[1] = 100432; //Remplissage de la deuxiemecase
meilleursScores[2] = 87347; //Remplissage de la troisieme case
meilleursScores[3] = 64523; //Remplissage de la quatrieme case
meilleursScores[4] = 31415; //Remplissage de la cinquieme case
|
Comme tous les numéros de cases sont décalés, la dernière case a le numéro 4 et pas 5 !
Parcourir un tableau
Le gros point fort des tableaux, c'est qu'on peut les parcourir en utilisant une boucle. On peut ainsi effectuer une action sur chacune des cases d'un tableau l'une après l'autre. Par exemple afficher le contenu des cases.
On connaît à priori le nombre de cases du tableau, on peut donc utiliser une boucle
for. Nous allons pouvoir utiliser la variable
i de la boucle pour accéder au
ième élément du tableau. C'est fou, on dirait que c'est fait pour !
Code : C++ - Parcourir un tableau 1
2
3
4
5
6
7
8
9
10
11
12
13 | int const nombreMeilleursScores(5); //La taille du tableau
int meilleursScores[nombreMeilleursScores]; //Declaration du tableau
meilleursScores[0] = 118218; //Remplissage de la premiere case
meilleursScores[1] = 100432; //Remplissage de la deuxiemecase
meilleursScores[2] = 87347; //Remplissage de la troisieme case
meilleursScores[3] = 64523; //Remplissage de la quatrieme case
meilleursScores[4] = 31415; //Remplissage de la cinquieme case
for(int i(0); i<nombreMeilleursScores; ++i)
{
cout << meilleursScores[i] << endl;
}
|
La variable
i va prendre successivement les valeurs 0,1,2,3 et 4. Ce qui veut dire que ce seront les valeurs de
meilleursScores[0] puis
meilleursScores[1] etc. qui seront envoyées dans
cout.
Il faut faire très attention à ne pas dépasser la taille du tableau dans la boucle. Sinon, vous aurez droit à un plantage de votre programme. La dernière case dans cet exemple a le numéro nombreMeilleursScores moins un. Les valeurs autorisées de i sont tous les entiers entre 0 et nombreMeilleursScores moins un compris.
Vous allez voir, le couple tableau - boucle
for va devenir votre nouveau meilleur ami. En tout cas je l'espère.

C'est un outil très puissant.
Un petit exemple
Allez, je vous propose un petit exemple un petit peu plus complexe. Nous allons utiliser le C++ pour calculer la moyenne de vos notes de l'année. Je vous propose de mettre toutes vos notes dans un tableau et d'utiliser une boucle
for pour le calcul de la moyenne.
Vous voyez comment faire ? Parfait ! Je vous regarde.
Bon. Ok. J'accepte de vous aider. Voyons donc tout ça étape par étape. Premièrement, il nous faut un tableau pour stocker les notes. Comme ce sont des nombres à virgule, il nous faut des
double.
Code : C++ | int const nombreNotes(6);
double notes[nombreNotes];
|
La deuxième étape consiste à remplir ce tableau avec vos notes. J'espère que vous savez encore comment faire !
Code : C++ | int const nombreNotes(6);
double notes[nombreNotes];
notes[0] = 12.5;
notes[1] = 19.5; //Bieeeen !
notes[2] = 6.; //Pas bien !
notes[3] = 12;
notes[4] = 14.5;
notes[5] = 15;
|
Je me répète, mais c'est important. La première case du tableau a le numéro 0. La deuxième a le numéro 1 et ainsi de suite.
Pour calculer la moyenne, il nous faut additionner toutes les notes et ensuite diviser par le nombre de notes. Nous connaissons déjà le nombre de notes, puisque nous avons la constante
nombreNotes. Il ne reste donc qu'à déclarer une variable pour contenir la moyenne.
Le calcul de la somme s'effectue dans une boucle
for qui va parcourir toutes les cases du tableau.
Code : C++ | double moyenne(0);
for(int i(0); i<nombreNotes; ++i)
{
moyenne += notes[i]; //On additionne toutes les notes
}
//En arrivant ici, la variable moyenne contient la somme des notes (79.5)
//Il ne reste donc qu'a diviser par le nombre de notes
moyenne /= nombreNotes;
|
Avec une petite ligne pour l'affichage de la valeur, on obtient le résultat voulu. Un programme qui calcule la moyenne de vos notes.
Code : C++ - Calcul de la moyenne des notes 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 | #include <iostream>
using namespace std;
int main()
{
int const nombreNotes(6);
double notes[nombreNotes];
notes[0] = 12.5;
notes[1] = 19.5; //Bieeeen !
notes[2] = 6.; //Pas bien !
notes[3] = 12;
notes[4] = 14.5;
notes[5] = 15;
double moyenne(0);
for(int i(0); i<nombreNotes; ++i)
{
moyenne += notes[i]; //On additionne toutes les notes
}
//En arrivant ici, la variable moyenne contient la somme des notes (79.5)
//Il ne reste donc qu'a diviser par le nombre de notes
moyenne /= nombreNotes;
cout << "Votre moyenne est : " << moyenne << endl;
return 0;
}
|
Voyons ce que ça donne quand on l'exécute.
Code : Console | Votre moyenne est : 13.25 |
Et ça marche ! Vous n'en doutiez pas j'espère.
Les tableaux et les fonctions
Ah ! les fonctions. Vous n'avez pas oublié ce que c'est j'espère. Il faut quand même que je vous en reparle un peu. Comme vous allez le voir, les tableaux et les fonctions ne sont pas les meilleurs amis du monde.
La première restriction est qu'
on ne peut pas écrire une fonction qui renvoie un tableau statique. C'est impossible.
La deuxième restriction est qu'un tableau statique est
toujours passé par référence. Et il n'y a pas besoin d'utiliser l'esperluette (
&). C'est fait automatiquement. Cela veut dire que lorsqu'on passe un tableau à une fonction, cette dernière peut le modifier.
Voici donc une fonction qui reçoit un tableau en argument.
Code : C++ | void fonction(double tableau[])
{
//...
}
|
Il ne faut rien mettre entre les crochets.
Mais ce n'est pas tout ! Très souvent, on va vouloir parcourir le tableau, avec une boucle
for par exemple. Il nous manque une information cruciale. Vous voyez laquelle ?
La taille ! A l'intérieur de la fonction précédente, il n'y a aucun moyen de connaître la taille du tableau ! Il faut donc
impérativement ajouter un deuxième argument contenant la taille. Ce qui donne :
Code : C++ | void fonction(double tableau[], int tailleTableau)
{
//...
}
|
Oui, je sais c'est ennuyeux. Mais il ne faut pas vous en prendre à moi. Je n'ai pas créé le langage.
Pour vous entraîner, je vous propose d'écrire une fonction
moyenne() qui calcule la moyenne des valeurs d'un tableau.
Voici ma version :
Secret (cliquez pour afficher)Code : C++ 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | /*
* Fonction qui calcule la moyenne des éléments d'un tableau
* - tableau: Le tableau dont on veut la moyenne
* - tailleTableau: La taille du tableau
*/
double moyenne(double tableau[], int tailleTableau)
{
double moyenne(0);
for(int i(0); i<tailleTableau; ++i)
{
moyenne += tableau[i]; //On additionne toutes les valeurs
}
moyenne /= tailleTableau;
return moyenne;
}
|
Bon bon, assez parlé de ces tableaux. Passons à la suite.