CHAPITRE 2 : LES TABLEAUX EN C++

I. Introduction

Les variables, telles que nous les avons vues, ne permettent de stocker qu'une seule donnée
à la fois. Or, pour de nombreuses données, comme cela est souvent le cas, des variables
distinctes seraient beaucoup trop lourdes à gérer. Heureusement, le langage C++ propose
des structures de données permettant de stocker l'ensemble de ces données dans une
« variable commune ». Ainsi, pour accéder à ces valeurs il suffit de parcourir la variable de
type complexe composée de « variables » de type simple.

Le langage C++ propose deux types de structures :

 les tableaux, permettant de stocker plusieurs données de même type

 les structures, pouvant contenir des données hétérogènes

On appelle tableau une variable composée de données de même type, stockée de manière
contiguë en mémoire (les unes à la suite des autres) dont chaque élément est repéré par un
indice précisant sa position au sein de l’ensemble.

Dans la suite de ce chapitre nous allons apprendre à manipuler deux types de Tableaux.
Ceux dont la taille est connue à l’avance (tableaux statiques) comme les dix meilleures
notes dans une matière, et ceux dont la taille peut varier en permanence (tableaux
dynamiques) comme l’âge des visiteurs d’un site web.

Voici donc une manière de représenter un tableau :

donnée donnée donnée ... donnée donnée donnée

 Lorsque le tableau est composé de données de type simple (int, double , float, etc..), on
parle de tableau monodimensionnel (ou vecteur)
 Lorsque celui-ci contient lui-même d'autres tableaux on parle alors de tableaux
multidimensionnels (ou matrice).

II. Les Tableaux statiques à une dimension

Un tableau unidimensionnel est un tableau qui contient des éléments simples (des
éléments qui ne sont pas des tableaux). Un tableau unidimensionnel est donc une suite
de « cases » de même taille contenant des éléments d'un type donné.

1) Déclaration
La déclaration d’un tableau statique à une dimension se fait de la manière suivante
en C++

1
type Nom_du_tableau [Taille] ;

 type définit le type d'élément que contient le tableau (rappel : un tableau en langage C
est composé uniquement d'éléments de même type), c'est-à-dire qu'il définit la taille
d'une case du tableau en mémoire
 Nom_du_tableau est le nom que l'on décide de donner au tableau, le nom du tableau
suit les mêmes règles qu'un nom de variable
 Taille est un nombre entier qui détermine le nombre de cases que le tableau doit
comporter.
Voici par exemple la déclaration d'un tableau qui doit contenir 10 éléments de type
double :

#include <iostream>

using namespace std;

int main()

double meilleurNotes[10]; //Déclare un tableau de 10 double

return 0;

Voilà à quoi ressemble la mémoire :

Mémoire

? ? ? ? ? ? ? ? ? ?

meilleurNotes

Il est 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.

2
Ex :

#include <iostream>

using namespace std;

int main()

Const int taille = 10 ; // declarartion de la constante taille

Double meilleurNotes[taille]; //Déclare un tableau de 10 double

return 0;

2) Calcul de la taille d’un tableau

Pour connaître la taille d'un tableau, c'est-à-dire déterminer le nombre d'octets que celui-ci
occupe en mémoire, il y a deux possibilités :

 Calculer manuellement la taille du tableau : il suffit de multiplier la taille du type

d'élément par le nombre d'éléments qui composent le tableau
 Utiliser l'opérateur sizeof() : l'opérateur sizeof() permet de retourner directement la
taille de l'élément qui lui est passé en argument, ainsi en lui passant un tableau comme
opérande, sizeof() est capable de vous retourner directement la taille de celui-ci

Voici différents exemples de tableaux, et leurs tailles respectives :

Declaration du tableau Taille du tableau (en octets)

char Tableau1[12] 1 * 12 = 12

int Tableau2[10] 4 * 10 = 40

float Tableau3[8] 4 * 8 = 32

double Tableau4[15] 8 * 15 = 120

3) Accès aux éléments d’un tableau

Pour accéder à un élément du tableau, le nom que l'on a donné à celui-ci ne suffit pas
car il comporte plusieurs éléments. Ainsi, on définit un nombre appelé indice (en
anglais index) qui, combiné avec le nom du tableau, permet de décrire exactement
chaque élément.

3
 Pour accéder à un élément du tableau, il suffit donc de donner le nom du tableau, suivi
de l'indice de l'élément entre crochets :

Nom_du_tableau[indice] ;

 L'indice du premier élément du tableau est 0

 Un indice est toujours positif
 L'indice du dernier élément du tableau est égal au nombre d'éléments – 1

Ainsi, on accédera au 5ème élément du tableau en écrivant :

Nom_du_tableau[4] ;

4) Manipuler les éléments d’un tableau

Un élément du tableau (repéré par le nom du tableau et son indice) peut être
manipulé exactement comme une variable, on peut donc effectuer des opérations
avec (ou sur) des éléments de tableau.

Ex : Déclarons un tableau de 5 entiers

#include <iostream>

using namespace std;

int main()

const int taille = 5 ; // declarartion de la constante taille

int Note[taille]; //Déclare un tableau de 5 entiers

Note[0]= 10 ; // Remplissage de la première case du tableau avec valeur 10

Note[1]=15 ; // Remplissage de la deuxième case du tableau avec valeur 15

Note[2]=20 ;//Remplissage de la troisième case du tableau avec valeur 20

Note[3]= Note[2]+10 ;//Remplissage de la quatrième case du tableau

Note[4]= 0 ; //Remplissage de la 5 ième case du tableau avec valeur 0

// Affichage des éléments du tableau Note

cout<<"la premiere case du tableau contient : "<<Note[0] <<endl ;

cout<<"la deuxième case du tableau contient : "<<Note[1] <<endl ;

cout<<"la troisieme case du tableau contient: "<<Note[2] <<endl ;

cout<<"la quatrieme case du tableau contient: "<<Note[3] <<endl ;

4
cout<<"la cinquieme case du tableau contient: "<<Note[4] <<endl ;

return 0;

5) Initialiser les éléments d’un tableau

Lorsque l'on créé un tableau en mémoire, les valeurs des éléments qu'il contient ne sont
pas définies. Il est souvent nécessaire de les initialiser.

 Une méthode fastidieuse consiste à affecter des valeurs aux éléments un par un.
 Une manière plus élégante consiste à utiliser le fait que pour passer d'un élément
du tableau à l'élément suivant il suffit d'incrémenter son indice. Il est donc
possible d'utiliser une boucle qui va permettre d'initialiser successivement
chacun des éléments grâce à un compteur qui servira d'indice :

Const int taille = 10;

int Tableau2[taille];
int i;
for (i = 0; i < 10; i++) {
Tableau2[i] = 0;
}

Cette méthode, aussi utile soit elle, n'a d'intérêt que lorsque les éléments du tableau
doivent être initialisés à une valeur unique. Pour initialiser un tableau avec des valeurs
spécifiques, il est possible d'initialiser le tableau à la création en plaçant entre accolades
les valeurs, séparées par des virgules.

const int taille =10 ;

int Tableau3 [taille] = {1, 2, 6, 5, 2, 1, 9, 8, 1, 5};

 Le nombre de valeurs entre accolades ne doit pas être supérieur au nombre

d'éléments du tableau ;
 Les valeurs entre accolades doivent être des constantes (l'utilisation de variables
provoquera une erreur du compilateur) ;
 Si le nombre de valeurs entre accolades est inférieur au nombre d'éléments du
tableau, les derniers éléments sont initialisés à 0 ;
 Il doit y avoir au moins une valeur entre accolades ;

Ainsi, l'instruction suivante permet d'initialiser tous les éléments du tableau à zéro :

int Tableau1[10] = {0};

5
 Exercice d’application

1. Créer un tableau T1 de taille N=10 ;

2. Remplir le tableau par des valeurs lues à partir du clavier ;
3. Afficher le tableau T1 ;

6) Quelques techniques classiques appliquées aux tableaux à une dimension

a) Somme et maximum des éléments d’un tableau

Dans le précédent chapitre, nous avons appris à calculer la somme ou le maximum

de plusieurs valeurs lues en données. Les techniques utilisées peuvent s’appliquer
sans difficulté au cas où les valeurs en questions sont les éléments d’un tableau.

Algorithme : Somme des éléments d’un tableau

 Utilisation d'une variable auxiliaire "Somme courante" pour stocker la

somme ;

 Initialisation de cette variable avec la valeur 0 ;

 Parcours séquentiel complet du reste du tableau ;

 A chaque nouvel indice, ajout de l’élément correspondant à la somme

courante.

Exercice d’application

Ecrire un programme qui lit la dimension N d'un tableau T2 du type int (dimension
maximale: 10 composantes), remplit le tableau par des valeurs entrées au clavier et
affiche le tableau. Calculer et afficher ensuite la somme des éléments du tableau.

Algorithme : Recherche de maximum dans un tableau

 Utilisation d'une variable auxiliaire "maximum courant" pour stocker le

maximum déjà trouvé ;

 Initialisation de cette variable avec la première valeur du tableau ;

 Parcours séquentiel complet du reste du tableau ;

 A chaque nouvelle valeur, réaffectation du maximum courant avec la

valeur en cours si celle-ci est plus grande que le maximum courant.

6
 Exercices d’applications

Exercice 1 :

A partir du tableau précédent T2 de l’exercice précédent, écrire les instructions permettant

de déterminer son plus grand élément et sa position dans le tableau T2.

Exercice 2 :

Ecrire un programme qui demande à l'utilisateur de saisir 12 entiers stockés dans un tableau. Le
programme doit afficher la moyenne des éléments du tableau.

Exercice 3:

Ecrire un programme qui demande à l'utilisateur de saisir 10 entiers stockés dans un tableau. Le
programme doit afficher le nombre d'entiers supérieurs ou égaux à 10.

b) Recherche de la présence d'une valeur dans un tableau :

Méthode séquentielle
Un besoin qui apparait fréquemment dans l’usage des tableaux est de déterminer si une valeur
donnée est présente ou non dans un tableau.

Algorithme : Recherche séquentielle

 Utilisation d'une variable auxiliaire booléenne pour indiquer si la valeur

recherchée a été trouvée ;

 Parcours séquentiel du tableau

 A chaque nouvelle valeur, si celle-ci est égale à la valeur recherchée,

inutile d'aller plus loin car on l'a trouvée
-> Retourner vrai ;

 Parcours stoppé lorsque la dernière valeur du tableau a été traitée

-> Retourner faux ;

Implantation

o Utilisation d'une variable auxiliaire booléenne pour

indiquer si la valeur recherchée a été trouvée
o Initialisation de cette variable à faux car avant d'avoir
commencé à chercher, on n'a pas trouvé

7
 o Parcours séquentiel au moyen d'une "boucle tant que" pour
qu'il puisse être complet mais aussi qu'il puisse être
interrompu si la valeur recherchée a été trouvée

Exercice d’application

Ecrire un programme qui demande à l'utilisateur de saisir 10 entiers stockés dans un tableau
ainsi qu'un entier N. Le programme doit rechercher si N se trouve dans le tableau et afficher
"N se trouve dans le tableau" ou "N ne se trouve pas dans le tableau".

c) Tri d’un tableau à une dimension : tri par extraction simple

L’utilisation d’un tableau permet de résoudre un problème assez fréquent, à savoir ordonner,
par exemple de manière croissante, une suite de valeurs ;

Dans tous les cas, on commence par placer les valeurs en questions dans un tableau. Puis,
on effectue un tri des valeurs de ce tableau. Plusieurs techniques existent à cet effet ; la plus
simple se nomme « tri par extraction simple ».

Algorithme du tri par extraction simple

Si t représente le tableau et n son nombre d’éléments :

 On compare le premier élément t[0] à tous ses suivants t[j], en procédant à un

échange des valeurs de t[0] et de t[j], à chaque fois que ce premier élément t[0] est
supérieur à t[j] ;
 Le plus petit élément se trouve alors en première position. On peut alors appliquer
l’opération précédente aux n-1 éléments restants, puis aux n-2 …….. et cela jusqu’à
ce qu’il ne reste plus qu’un seul élément(le dernier) qui est alors le plus grand.

Exercice d’application

1. Créer un tableau T de taille N=10 ;

2. Remplir le tableau ;
3. Afficher le tableau (non trié) ;
4. Trier le tableau T par ordre croissant de ces éléments ;
5. Afficher le tableau trié.

8
III. Les Tableaux multidimensionnels

Un tableau peut avoir plus d’une dimension. Chacune d’elles est représentée par un indice
du tableau. Un tableau bidimensionnel aura donc deux indices, un tableau tridimensionnel
trois indices, et ainsi de suite. Vous pouvez créer autant de dimensions que vous le souhaitez,
bien qu’en pratique la plus part de vos tableaux n’auront qu’une ou deux dimensions.
Un échiquier est un bon exemple de tableaux à deux dimensions. Une dimension représente
les 8 lignes, l’autre les 8 colonnes.

1) Déclaration d’un tableau bidimensionnel

Syntaxe : Type nom_tableau [Nb Lignes][Nb Colonnes] ;

Exemple :
Un tableau d'entiers positifs à deux dimensions (3 lignes, 4 colonnes) se déclare avec
la syntaxe suivante :

int Tableau [3][4] ;

On peut représenter un tel tableau de la manière suivante :

Tableau[0][0] Tableau[0][1] Tableau[0][2] Tableau[0][3]

Tableau[1][0] Tableau[1][1] Tableau[1][2] Tableau[1][3]

Tableau[2][0] Tableau[2][1] Tableau[2][2] Tableau[2][3]

2) Accès aux éléments d’un tableau à deux dimensions

Un élément quelconque d’un tableau à deux dimensions est repéré par deux indices (indice
de lignes et indice de colonnes).
Exemple :
Tableau[0][1]
Dans cet exemple on accède à l’élément qui se trouve à l’intersection entre la première ligne
et la deuxième colonne du tableau.

9
 3) Initialisation
L'initialisation d'un tableau bidimensionnel se fait à peu près de la même façon que
pour les tableaux unidimensionnels. Il y a donc plusieurs façons d'initialiser un
tableau bidimensionnel :

 Initialisation individuelle de chaque élément :

Nom_du_tableau[0][0] = 2 ;
Nom_du_tableau[0][1] = 3 ;
...

 Initialisation grâce à des boucles :

Il faut faire des boucles imbriquées correspondant chacune à un indice d'une
dimension. Par exemple les éléments de Tableau[3][4] pourront être
initialisés à 0 par les instructions suivantes :

int i,j;

for (i=0; i<3; i++){

for (j=0; j<4; j++){
Tableau[i][j] = 0;

}
}

 Initialisation à la déclaration :

type nom_du_tableau[L][C] = { { l0c0, l0c1, …, l0cm},{l1c0,l1c2,…,l1cm},...,{lnc0,lnc1,…,lncm}} ;

Ex :
int carree[3][3] = {{3,2,3},{4,3,4},{3,2,3}} ;

3 2 3
4 3 4
3 2 3

10
 4) Déclaration avec une constante

Exemple :

#include <iostream>
using namespace std;

int main()
{
int const L = 3;
int const C = 4;

int i, j;
int t[L][C];

for(i=0; i<L; i++)

for(j=0; j<C; j++)
{
cout<<"Tapez t["<< i <<"]["<< j <<"] :";
cin >> t[i][j];
}
cout<<"Voici le tableau :"<<endl;
for(i=0; i<L; i++)
{
for(j=0; j<C; j++) cout<< t[i][j] <<" ";
cout<<endl;
}
return 0;
}

11
 IV. Les tableaux dynamiques en C++

Un tableau dynamique est un tableau dont la taille peut varier lors de l’exécution d’un
programme.

1. Déclaration
Il faut tout d’abord noter qu’avant d’utiliser un tableau dynamique en langage C++, il
faut inclure la bibliothèque vector par l’instruction #include<vector>.
La manière de déclarer un tableau dynamique est différente de celle de la
déclaration d’un tableau statique. On utilise la syntaxe suivante :

Vector <TYPE> nom_du_Tableau (TAILLE);

Exemple
Pour un tableau dynamique de 8 entiers on aura :

#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> tableau1(8);
return 0;
}

On peut directement remplir toutes les cases du tableau en ajoutant un deuxième

argument entre les parenthèses :

vector<int> tableau2(7, 0);

vector<double> tableau3(7, 5.12);

On peut également déclarer un tableau vide qui n’a pas de taille de départ.

vector<float> tableau;

2. Accès aux éléments

Contrairement à la déclaration, l’accès aux éléments est exactement la même. Nous

pouvons donc écrire :

Const int nbreElementDepart(5); //La taille de départ

vector<int> tableau(nbreElementDepart); //Déclaration du
tableau

tableau[0] = 100; //Remplissage de la première case

tableau[1] = 879;
tableau[2] = 781;

12
 tableau[3] = 534;
tableau[4] = 467;

3. Ajouter ou enlever des éléments

En utilisant un tableau dynamique en C++, nous avons la possibilité d’augmenter ou

de diminuer la taille.

Pour ajouter des cases à la fin du tableau, il faut utiliser la fonction push_back().
On écrit le nom du tableau, suivi d’un point et du mot push_back avec, entre
parenthèses, la valeur qui va remplir la nouvelle case.

vector<int> tableau(5, 3);

tableau.push_back(10);

Pour la suppression d’un élément du tableau, on utilise la fonction pop_back () sauf

qu’on ne met rien dans les parenthèses.

vector<int> tableau (5, 3); //déclare un tableau de 5,

tous 3.
tableau.push_back(10); Ajoute un sixième élément
tableau.push_back(12); Ajoute un septième élément
tableau.pop_back(); //Supprime le septième élément
tableau.pop_back(); //Supprime le sixième élément
tableau.pop_back(); //Supprime le cinquième élément

4. Taille d’un tableau dynamique

Comme la taille peut changer, on ne sait pas de manière certaine combien

d’éléments contient un tableau. Heureusement, la fonction size() est là pour
cela. En faisant tableau.size(), on récupère un entier représentant le nombre
d’éléments du tableau.

13
Exemple:

#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<double> notes; int i;
notes.push_back(12.5);
notes.push_back(19.5);
notes.push_back(6.6);
notes.push_back(12);
notes.push_back(14.5);
notes.push_back(15);
double moyenne=0, somme=0 ;
for( i=0; i<notes.size(); ++i)
{
somme += notes[i]; //On additionne toutes les notes
}

moyenne = somme / notes.size();

cout << "Votre moyenne est : " << moyenne << endl;
return 0;
}

14