• 8 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

Ce cours existe en livre papier.

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 15/02/2022

Manipulez des tableaux statiques

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Vous vous en doutez certainement, les tableaux dont la taille est fixée à l'avance sont plus faciles à utiliser, et c'est donc par eux que nous allons commencer. Voyons cela avec un exemple : la liste des meilleurs scores d'un jeu.

Si vous voulez afficher la liste des 5 meilleurs scores des joueurs, il va vous falloir en réalité deux listes :

  1. La liste des noms de joueurs.

  2. Et la liste des scores qu'ils ont obtenus.

Nous allons donc devoir déclarer 10 variables pour mettre toutes ces informations dans la mémoire de l'ordinateur :

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 cela, il va aussi falloir pas mal de travail :

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;

Imaginez maintenant que vous vouliez afficher les 100 meilleurs scores et pas seulement les 5 meilleurs. Ce serait terrible, il 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 meilleurs scores et les noms des 100 meilleurs joueurs d'un seul coup. On va créer une 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 ?

Déclarez 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.

On indique le type, puis le nom choisi et enfin, entre crochets, la taille du tableau :

TYPE NOM[TAILLE];

Voyons cela avec un exemple :

#include <iostream>
using namespace std;
int main()
{
int meilleurScore[5]; //Déclare un tableau de 5 int
double anglesTriangle[3]; //Déclare un tableau de 3 double
return 0;
}

Et maintenant, voyons à quoi ressemble la mémoire :

On retrouve les deux zones mémoire 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 .
La mémoire de l'ordinateur après avoir déclaré deux tableaux

On retrouve les deux zones mémoire 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, aucune de ces cases n'est initialisée. 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, à la place du nombre :

int const tailleTableau(20); //La taille du tableau
double anglesIcosagone[tailleTableau];

Je vous conseille de toujours utiliser des constantes pour exprimer les tailles de vos tableaux plutôt que d'indiquer directement la taille entre les crochets. C'est une bonne habitude à prendre.

Bon. Nous avons de la place dans la mémoire. Il ne nous reste plus qu'à l'utiliser.

Accédez aux éléments d'un tableau statique

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. On doit 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 simplement 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 troisième case de meilleurScore et y stocker une valeur, il faudra donc écrire :

meilleurScore[2] = 5;

En effet, 31=2 ; la troisième case possède donc le numéro 2. Si je veux remplir mon tableau des meilleurs scores comme dans l'exemple initial, je peux donc écrire :

int const nombreMeilleursScores(5); //La taille du tableau
int meilleursScores[nombreMeilleursScores]; //Déclaration du tableau
meilleursScores[0] = 118218; //Remplissage de la première case
meilleursScores[1] = 100432; //Remplissage de la deuxième case
meilleursScores[2] = 87347; //Remplissage de la troisième case
meilleursScores[3] = 64523; //Remplissage de la quatrième case
meilleursScores[4] = 31415; //Remplissage de la cinquième case

Parcourez un tableau statique

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 !

int const nombreMeilleursScores(5); //La taille du tableau
int meilleursScores[nombreMeilleursScores]; //Déclaration du tableau
meilleursScores[0] = 118218; //Remplissage de la première case
meilleursScores[1] = 100432; //Remplissage de la deuxième case
meilleursScores[2] = 87347; //Remplissage de la troisième case
meilleursScores[3] = 64523; //Remplissage de la quatrième case
meilleursScores[4] = 31415; //Remplissage de la cinquième case
for(int i(0); i<nombreMeilleursScores; ++i)
{
cout << meilleursScores[i] << endl;
}

La variable i prend successivement les valeurs 0, 1, 2, 3 et 4, ce qui veut dire que les valeurs de meilleursScores[0]  , puis meilleursScores[1]  , etc., sont envoyées dans cout  .

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.

Découvrez un exemple d'utilisation

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. Voyons donc tout cela étape par étape.

Étape 1 : déclarez un tableau pour stocker les notes

Comme ce sont des nombres à virgule, il nous faut des double  .

int const nombreNotes(6);
double notes[nombreNotes];

Étape 2 : remplissez ce tableau avec vos notes

J'espère que vous savez encore comment faire :

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;

Pour calculer la moyenne, il nous faut additionner toutes les notes puis diviser le résultat obtenu 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.

Étape 3 : déclarez une variable pour contenir la moyenne

Le calcul de la somme s'effectue dans une boucle for qui parcourt toutes les cases du tableau :

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'à 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.

#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'à diviser par le nombre de notes
moyenne /= nombreNotes;
cout << "Votre moyenne est : " << moyenne << endl;
return 0;
}

Voyons ce que cela donne quand on l'exécute :

Votre moyenne est : 13.25

Et cela marche ! Mais vous n'en doutiez pas, bien sûr ?

Dans le screencast suivant, nous allons voir comment manipuler un tableau, notamment pour parcourir ou modifier les valeurs contenues dans chaque case. Nous allons tout d’abord créer un tableau et le remplir à l’aide d’un std::cin  . Nous afficherons ensuite toutes les valeurs contenues dans ce tableau. Pour terminer, nous assignerons la valeur 0 à toutes les cases qui ont un numéro de case pair. Allez c'est parti !

Les tableaux statiques et les fonctions

Les tableaux statiques et les fonctions ne sont pas les meilleurs amis du monde :

  1. On ne peut pas écrire une fonction qui renvoie un tableau statique. C'est impossible.

  2. 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 :

void fonction(double tableau[])
{
//…
}

Mais ce n'est pas tout ! Très souvent, on veut parcourir le tableau, avec une boucle for par exemple. Il nous manque une information cruciale. Vous voyez laquelle ?

La taille ! À 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 :

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 :

/*
* 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;
}

En résumé

  • Les tableaux sont des successions de variables en mémoire. Un tableau à 4 cases correspond donc en mémoire à 4 variables les unes à la suite des autres.

  • Un tableau s'initialise comme ceci : int meilleurScore[4];  (pour 4 cases).

  • La première case est toujours numérotée 0 ( meilleurScore[0]  ).

Les tableaux statiques c'est sympa mais ça ne fait qu'un type de tableaux. Dans le prochain chapitre, nous allons notamment nous intéresser aux tableaux dynamiques, c'est parti !

Exemple de certificat de réussite
Exemple de certificat de réussite