Chapitre 7

Tableaux

7.1 Introduction
Les variables que nous avons utilisées jusqu’à maintenant ne permettent de stocker qu’une
seule donnée. A chaque fois que l’on souhaitait stocker une donnée on créait donc une variable.
Exemple : Pour stocker le score d’un joueur on crée une variable scoreJoueur ; pour stocker le
score de deux joueurs, on crée deux variables : scoreJoueur1 et scoreJoueur2.
Si cette méthode est adaptée tant que le nombre de données à stocker est faible, elle n’est en
revanche plus envisageable si le nombre de données devient très grand. Par exemple si l’on doit
stocker le score de 1000 joueurs, il n’est pas réaliste d’envisager de créer 1000 variables différentes
pour cela. Dans ce cas, on utilise une structure de donnée que l’on appelle tableau.
Remarque : Lorsque le nombre de données de même type à stocker devient important il faut
penser à utiliser un tableau et non plus des variable atomiques. On peut considérer qu’à partir de
5 valeurs, le nombre de valeurs est important.
Déclarer une variable tableau revient à regrouper dans une même variable (un seul nom de
variable) un nombre déterminé d’éléments de même type plutôt que de déclarer X variables (de
noms différents) de ce type.
Exemple :
– Toutes les notes obtenues par l’étudiant Dupond en BdP pour l’année 2014.
– Toutes les températures relevées à midi tous les jours de l’année 2014.
– Tous les codes des articles qui sont vendus dans un magasin.
À retenir : Un tableau ne permet de regrouper que des valeurs de même type.

7.2 Variables de type tableau et accès aux éléments

Un tableau est un ensemble de valeurs de même type (int par exemple) placées les unes à côté
des autres dans la mémoire.

7.2.1 Déclaration d’un tableau

En C++, on déclare une variable de type tableau en donnant d’abord le type de données qu’il
va contenir, puis le nom de la variable suivi du nombre de cases du tableau entre crochets, et l’on
fini comme toujours par un point-virgule :
� �
La syntaxe pour déclarer un tableau est donc la suivante :

� �
1 type nomTableau[nbElements];

où nbElements est une valeur entière constante.

121
 IUT de Villetaneuse

� �
Exemple :

� �
1 int tab[12];

réserve en mémoire un tableau de 12 éléments (i.e., cases) pouvant contenir des valeurs de type
int (entières) et associe ce tableau au nom de variable tab.
À retenir : La taille du tableau, c’est-à-dire le nombre d’éléments du tableau, doit être une
constante, et non une variable - i.e. un littéral.
Attention : Comme pour les autres types de variables, il n’y a pas de valeur par défaut dans les
cases du tableau. Il peut donc y avoir n’importe quelle valeur !
Il est possible, lors de la déclaration d’un tableau (et uniquement à ce moment là), d’initialiser
le tableau, c’est-à-dire de donner une valeur à chaque élément du tableau. Pour cela, il faut donner
� �
ces valeurs entre accolades. Ainsi, l’instruction

� �
1 int tab[3] = {1, 3, 5};

crée un tableau de 3 éléments dont le premier vaut 1, le deuxième 3 et le troisième 5.

Si le nombre de valeurs données entre accolades est plus petit que la taille du tableau, les valeurs
indiquées correspondent aux valeurs des premiers éléments, les autres éléments étant initialisés à
� �
0. Ainsi,

� �
1 int tab[6] = {2, 3};

� �
correspond à l’instruction

� �
1 int tab[6] = {2, 3, 0, 0, 0, 0};

Remarque : Au moins une valeur doit être donnée entre accolades.

Finalement, il n’est pas obligatoire, lorsqu’on initialise toutes les valeurs d’un tableau, d’indi-
quer la taille de ce dernier. En effet, la taille est automatiquement calculée comme étant égale au
� �
nombre de valeurs données entre accolades. Ainsi,

� �
1 int tab[] = {18, 32, 23, 1, 0};

correspond à un tableau de 5 éléments dont les éléments sont initialisés avec les valeurs données
entre accolades.
Attention : Il n’est pas possible d’initialiser un tableau avec un autre tableau. Ainsi, le code
� �
suivant est incorrect :
1 int tab[] = {1, 2, 3};

� �
2 int t2[] = tab; //Impossible

Remarque : Comme pour les autres types de variables, une variable de type tableau est détruite
dès que le programme rencontre l’accolade fermante correspondant au bloc d’instructions où la
variable est déclarée.
� Sur ce thème : Exercice 7

7.2.2 Accès aux éléments d’un tableau

On accède aux éléments d’un tableau par le numéro de leur position dans ce tableau. Le numéro
de cette position est un entier que l’on appelle indice du tableau.
� �
La syntaxe est la suivante :

� �
1 nomTableau[indice];

On donne le nom de la variable de type tableau suivi de l’indice entre crochets.

Attention : L’indice d’un tableau de n éléments commence à 0 et se termine à n − 1.
� �
Intro à l’algorithmique et à la programmation �122 � 1er semestre
 Departement informatique

indice 0 1 2 ... i ... n-2 n-1

tab val1 val2 val3 ... vali+1 ... valn−1 valn
↑ ↑ ↑ ↑ ↑ ↑
accès tab[0] tab[1] tab[2] ... tab[i] ... tab[n-2] tab[n-1]

Chaque élément d’un tableau peut être vu comme une variable (c’est une zone mémoire dans
laquelle on stocke une donnée). On peut donc affecter une valeur à un élément du tableau ou se
� �
servir de la valeur stockée dans un tableau pour un calcul ou un affichage. L’exécution du code :
1 int main()
2 {
3 int tab[3] = {45, 5, 1};
4

5 cout << "le premier élément du tableau tab est : " << tab[0] << endl;
6 cout << "le deuxième élément du tableau tab est : " << tab[1] << endl;
7 cout << "le troisième élément du tableau tab est : " << tab[2] << endl;
8

9 tab[0]=25;
10 tab[0]+=tab[1];
11

12 cout << "le premier élément du tableau tab est maintenant : " << tab[0] << endl;
13 return 0;

� �
14 }

produira l’affichage suivant :

le premier élément du tableau tab est : 45

le deuxième élément du tableau tab est : 5
le troisième élément du tableau tab est : 1
le premier élément du tableau tab est maintenant : 30

Attention : Hormis lors de sa déclaration, une variable de type tableau ne peut être à gauche
d’une affectation sans être indicée (c’est-à-dire suivie d’un indice entre crochets). Le code suivant
� �
est incorrect.
1 int tab[12];
2 tab = {1,2,3}; //Incorrect car permis uniquement lors de la déclaration

� �
3 tab[0] = 18; //Correct car on a tab[0] (et non tab)

� Sur ce thème : Exercice 1, TD, Questions 1.1 , 1.2 et 1.3

7.3 Parcours d’un tableau

Parcourir un tableau implique nécessairement une itérative (boucle). Atteindre successivement
tous les éléments d’un tableau (dans l’ordre croissant ou décroissant des indices) correspond à une
itérative dont le nombre d’itérations est connu (le nombre d’éléments du tableau).

� �
Exemple : Parcours dans l’ordre croissant :
1 int main()
2 {
3 int tab[5]={6,78,99,4,5}; /* initialisation du tableau */
4 int i = 0;
5 while (i<5) /* parcourir tous les éléments effectifs du tableau */
6 {
7 tab[i]+=2; /* incrémenter de 2 l’élément i du tableau tab */
8 cout << tab[i] << endl;

� �
1er semestre �123 � Intro à l’algorithmique et à la programmation
 IUT de Villetaneuse

9 i++;
10 }
11

12 return 0;

� �
13 }

Le code ci-dessus produira l’affichage suivant :

8
80
101
6
7

� �
Exemple : Parcours dans l’ordre décroissant :
1 int i=4;
2 while (i>=0)
3 {
4 tab[i]=tab[i]+2; /* incrémenter de 2 l’élément i du tableau tab */
5 cout << tab[i] << endl;
6 i--;

� �
7 }

Le code ci-dessus produira l’affichage suivant

7
6
101
80
8
� Sur ce thème : Exercice 1, TD 4, Question 1.4
� Sur ce thème : Exercice 3 et 4, TD 4

7.3.1 Utilisation d’un tableau dont on ne connaît pas le nombre d’élé-

ments lors de la programmation
En C++, la taille du tableau doit être déclarée à l’aide d’une constante. Si l’on ne connaît
pas le nombre de valeurs qui vont être stockées dans ce tableau, il faut alors déclarer un tableau
de taille supérieure aux besoins du programme, et utiliser une variable pour connaître le nombre
d’éléments (c’est-à-dire le nombre de valeurs stockées) durant le programme.
Exemple : Si le programme doit stocker des valeurs saisies par l’utilisateur et que l’on ne connaît
� �
pas leur nombre, il convient de programmer de cette manière.
1 int main ()
2 {
3 //Déclaration d’un tableau pouvant contenir au plus 1000 entiers
4 int tableau[1000];
5 //Nombre de cases utilisées dans le tableau - 0 au départ car aucune valeur
6 int nbElementsTableau = 0;
7

8 //Saisie du nombre de valeurs à stocker dans le tableau

9 int nbSaisies = -1;
10

11 while (nbSaisies <= 0 || nbSaisies > 1000)

12 {

� �
Intro à l’algorithmique et à la programmation �124 � 1er semestre
 Departement informatique

13 cout << "Veuillez saisir le nombre de valeurs à stocker (entre 1 et 1000) :"<< endl ;
14 saisie(nbSaisies) ;
15 }
16

17 //Saisie des valeurs dans le tableau

18 int nbElementsTableau = 0;
19

20 while (nbElementsTableau < nbSaisies)

21 {
22 saisie( tableau[nbElementsTableau] );
23 nbElementsTableau++ ;
24 }
25

26 //A ce moment là, nbElementsTableau correspond au nombre de valeurs stockées dans le tableau
27 cout << "nombre d’éléments dans le tableau : "<< nbElementsTableau << endl;
28

29 //Les indices des éléments du tableau sont compris entre 0 et nbElementsTableau-1

30 int i=0;
31 while ( i < nbElementsTableau )
32 {
33 cout <<"élément numéro" << i << "du tableau : "<< tableau[i] <<endl;
34 i++;
35 }
36 return 0;

� �
37 }

Il faut donc bien différencier le nombre de valeurs possibles que l’on peut stocker dans le
tableau (correspondant à la taille du tableau donnée lors de sa déclaration), le nombre de valeurs
que l’on voudra stocker dans le tableau lors d’une exécution de l’algorithme et le nombre de cases
effectivement utilisées durant l’algorithme pour stocker des valeurs du programme.
Dans l’exemple précédent,
1000 est la taille du tableau. C’est l’espace mémoire qui a été attribué à la variable tableau lors
de sa déclaration ligne 4. Cette taille définie le nombre maximal de valeurs qui peuvent être
stockées dans ce tableau.
nbSaisies est le nombre de valeurs que l’on envisage de placer dans ce tableau de 1000 cases. Il
faut impérativement s’assurer que ce nombre de valeur est bien inférieur à la capacité du
tableau (ligne 11)
nbElementsTableau est le nombre de cases effectivement utilisées dans le tableau. Au départ,
quand aucune valeur n’a encore été mise en mémoire dans le tableau nbElementsTableau,
elle vaut 0. Elle est donc initialisé à 0 (ligne 18), puis elle doit être mise à jour explicitement
lors de chaque ajout ou retrait d’une valeur du tableau par incrémentation ou décrémentation
(ligne 23).
Remarque : Quand on remplit itérativement le tableau, la variable nbElementsTableau indique
l’indice de la prochaine case à "remplir".

7.3.2 Remplacement des "nombres magiques" par des constantes nom-

mées
Dans le paragraphe précédent, la valeur 1000 apparait plusieurs fois (lignes 4, 11, 13). Une fois
avec explication (ligne 3-4) et 2 fois sans aucune indication explicite. Ici, la valeur 1000 règle la
capacité du tableau. Si l’indice d’accès à un élément du tableau prend une valeur supérieur à ce
"1000", cela conduit à un dépassement de la taille du tableau et provoque un comportement non
contrôlé du programme (ce qui est à bannir). La bonne pratique veut qu’on utilise des constantes
nommées plutôt que ces nombres arbitraires.
� �
1er semestre �125 � Intro à l’algorithmique et à la programmation
 IUT de Villetaneuse

En C++ on définit les constantes nommées au moyen de la déclaration d’une macro de la façon

� �
suivante :

� �
1 #define NOM_DE_LA_CONSTANTE_EN_MAJUSCULE valeur

Cette instruction est à placer en en-tête du programme (avant les fonctions que vous définissez
et avant le main()).
À retenir : Par convention les noms des constantes sont donnés en MAJUSCULES pour bien
mettre en évidence leur caractère particulier.
Cette constante, ainsi définie, est alors accessible n’importe où dans le programme ! Sa portée
n’est pas limitée. En fait, il ne s’agit pas d’une variable mais d’un code qui sera traité par le
préprocesseur. Chaque occurrence de la macro (le nom de la constante) sera remplacée avant
compilation par sa valeur. Dans le code compilé c’est la valeur qui apparait. Dans le code écrit
c’est le nom de la macro (ce qui est plus explicite).
Remarque : Lorsqu’on définit en C++ des tableaux de taille fixe, il est d’usage de paramétrer
leur taille maximale (leur capacité) par une constante nommée. On peut alors faire référence à
cette taille limite par un nom de constante explicite, plutôt que par un nombre magique

� �
Exemple : Pour reprendre l’exemple précédent, cela donnerait :

1 #define TAILLE_TAB_MAX 1000

2

3 int main ()
4 {
5 int tableau[TAILLE_TAB_MAX];
6

7 [...]
8

9 int nbSaisies = -1;

10

11 while (nbSaisies <= 0 || nbSaisies > TAILLE_TAB_MAX)

12 {
13 cout << "Nombre de valeurs à stocker (entre 1 et "<< TAILLE_TAB_MAX <<") ?"<< endl ;
14 saisie(nbSaisies) ;
15 }
16

17 [...]
18

19 return 0;

� �
20 }

� Sur ce thème : Exercice 3

� Sur ce thème : Exercice 8, TD 4, Question 7.6
� Sur ce thème : Exercice Tous les autres aussi !

7.4 Tableaux comme paramètres de fonctions et portée des

modifications
Dans l’en-tête d’une fonction, pour spécifier qu’un paramètre est de type tableau, on ajoute
après le nom du paramètre les symboles []. Ainsi, si l’on souhaite définir comme paramètre un
tableau d’entiers appelé tab, le paramètre sera int tab[].

Attention : Dans l’en-tête, il ne faut absolument rien mettre entre les crochets. Lors d’un appel
de la fonction, la valeur du paramètre de type tableau sera le nom de la variable (de type tableau)
sans les crochets !
� �
Intro à l’algorithmique et à la programmation �126 � 1er semestre
 Departement informatique

De plus, si l’on a besoin dans la fonction de connaître la taille du tableau (pour le parcourir
par exemple), il faut alors passer un deuxième paramètre de type int à cette fonction. À l’appel,
� �
sa valeur sera la taille du tableau passé en paramètre.
1 // La fonction affiche reçoit l’adresse du tableau et sa taille
2 void affiche_tableau(int tab[], int taille)
3 {
4 int i = 0;
5 while (i<taille)
6 {
7 cout << tab[i] << endl;
8 i++;
9 }
10 }
11

12 int main()
13 {
14 int tabint1[] = {3, 7, 2, 6, 1, 45, 23} ;
15 int tabint2[] = {23, 5, 40, 8, -2, 39, -31,25, 62, 12 };
16 int longtab1 = 7 ; // longueur de tabint1
17 int longtab2 = 10 ; // longueur de tabint2
18

19 affiche_tableau(tabint1, longtab1) ;
20 affiche_tableau(tabint2, longtab2) ;
21 return 0;

� �
22 }

Ainsi, l’exécution du code affichera à l’écran :

3
7
2
6
1
45
23
23
5
40
8
-2
39
-31
25
62
12

Attention : Lorsque l’on passe un tableau en paramètre d’une fonction, les modifications des
éléments du tableau effectuées par les instructions de la fonction sont répercutées dans le reste du
programme.
À retenir : Du point de vue pratique, on retiendra que l’on peut modifier les éléments d’un
� �
tableau passé en paramètre. On peut écrire par exemple :
1 void incremente_tableau(int tab[], int taille)
2 {
3 int i = 0;
4

� �
1er semestre �127 � Intro à l’algorithmique et à la programmation
 IUT de Villetaneuse

5 while (i< taille)

6 {
7 adrtab[i]++;
8 i=i+1;
9 }
10 }
11

12 int main()
13 {
14 int tabint1[] = {3, 7, 2, 6, 1, 45, 23} ;
15

16 int longtab1 = 7 ; // longueur de tabint1

17

18 incremente_tableau(tabint1, longtab1);
19 affiche_tableau(tabint1, longtab1) ;
20

21 return(0);

� �
22 }

Ainsi, l’exécution du code affichera à l’écran :

4
8
3
7
2
46
24
� Sur ce thème : Exercice 5, TD 4, Question 1.4

� �
Intro à l’algorithmique et à la programmation �128 � 1er semestre
 Departement informatique

TD7 : Tableaux (Corrigé)

� Exercice 1 : Test de compréhension *

Question 1.1 : [Indice] Qu’est-ce que l’indice d’un élément dans un tableau ? Quelle(s) valeur(s)
peut-il prendre ?
Correction :
L’indice d’un élément correspond à la position de cet élément dans le tableau. L’indice est un nombre compris entre
0 et n − 1 pour un tableau comprenant n éléments. �

Question 1.2 : [Indice et valeur] Quelle différence y a-t-il entre l’indice d’un élément d’un tableau
et sa valeur ?
Correction :
Ce sont deux choses différentes. L’indice est un entier correspondant à la position de l’élément dans un tableau
alors que la valeur est une donnée (nombre, chaîne de caractères, etc) stockée dans le tableau. �

Question 1.3 : Déclarer un tableau de nombres réels double précision de taille 6 qui sera initialisé
avec des valeurs quelconques.
Question 1.4 : Afficher le tableau à l’endroit puis à l’envers.
� �
Correction :
1 int main ()
2 {
3 double tab[] = {1.2, 2.3, 4.3, -6.6, 9., -23.3};
4

5 cout << "Affichage du tableau à l’endroit :" << endl ;

6 int i =0 ;
7 while (i < 6)
8 {
9 cout << tab[i] <<endl ;
10 i++ ;
11 }
12

13 cout << "Affichage du tableau à l’envers :" << endl ;

14 i=5;
15 while ( i >=0)
16 {
17 cout << tab[i] <<endl ;
18 i-- ;
19 }
20 return 0;

� � �
21 }

� Exercice 2 : Vérification de tri **

Écrire un algorithme qui vérifie si un tableau de 10 entiers est trié ou pas.
� �
Correction :
1 int main(void)
2 {
3 int tab[]={1,2, 3,4,5,21,7,8,9,10};
4 int i=0;

� �
1er semestre �129 � Intro à l’algorithmique et à la programmation
 IUT de Villetaneuse

5 bool ok = true;
6

7 while (ok && i < 9)

8 {
9 if (tab[i] > tab[i+1])
10 ok = false;
11 else
12 i++;
13 }
14

15 if (!ok)
16 cout << "non" << endl;
17 else
18 cout << "oui" << endl;
19

20 return 0;

� � �
21 }

� Exercice 3 : Recherche du maximum **

Écrire un programme qui recherche le plus grand élément présent dans un tableau donné. Par
exemple, si le tableau est égal à {32, 5, 12, 8, 3, 75, 2, 15}, ce programme doit afficher :
le plus grand élément du tableau a la valeur 75.
Vous ferez attention à ne pas utiliser de nombres magiques !
� �
Correction :
1 #define TAILLE_TAB 8
2

3 int main ()
4 {
5 int t[TAILLE_TAB] = {32, 5, 12, 83, 3, 75, 2, 15};
6 int i = 1;
7 int plusgrand = t[0];
8

9 while (i< TAILLE_TAB)

10 {
11 if (t[i] > plusgrand)
12 plusgrand = t[i] ;
13 i ++;
14 }
15

16 cout << "le plus grand element du tableau a la valeur " << plusgrand << endl;
17 return 0;

� � �
18 }

� Exercice 4 : (suite) **
Question 4.1 : Écrire un programme affichant le plus grand entier pair contenu dans un tableau
d’entiers strictement positifs. Attention, si le tableau ne contient aucun entier pair, le programme
doit afficher le message Le tableau ne contient aucun entier pair.
� �
Correction :
1 #define TAILLE_MAX 10
2

3 int main ()

� �
Intro à l’algorithmique et à la programmation �130 � 1er semestre
 Departement informatique

4 {
5 int tab[TAILLE_MAX] = {5, 8 , 98, 45, 89, 102, 56, 111, 79, 51};
6 int i=0;
7

8 //Affichage du tableau
9 cout << "Affichage du tableau : " << endl ;
10

11 while (i < TAILLE_MAX)

12 {
13 cout << tab[i] << endl ;
14 i++;
15 }
16

17 i = 0;
18 int plusGrandEntierPair = 0;
19

20 while (i < TAILLE_MAX)

21 {
22 if (tab[i]%2==0 && tab[i]>plusGrandEntierPair)
23 plusGrandEntierPair = tab[i];
24 i++;
25 }
26

27 if (plusGrandEntierPair)
28 cout << "Le plus grand entier pair est:" << plusGrandEntierPair << endl ;
29 else
30 cout << "Le tableau ne contient pas de nombre pair "<< endl ;
31

32 return 0;

� �
33 }
�

Question 4.2 : Modifier le programme ci-dessus pour qu’il prenne en compte n’importe quel type
d’entier (positif ou négatif)

� �
Correction :

1 #define TAILLE_MAX 10
2 int main ()
3 {
4 int tab[TAILLE_MAX] = {-5, 8 , 98, 45, -89, -102, 56, 1111, -79, 51};
5 int i=0;
6

7 //Affichage du tableau
8 cout << "Affichage du tableau : " << endl ;
9

10 while (i < TAILLE_MAX)

11 {
12 cout << tab[i] << endl ;
13 i++;
14 }
15 i = 0;
16 int IndplusGrandEntierPair = -1;
17

18 while (i < TAILLE_MAX)

19 {
20 if (tab[i]%2==0 &&
21 ((IndplusGrandEntierPair==-1)||(tab[i]>tab[IndplusGrandEntierPair])))
22 IndplusGrandEntierPair = i;

� �
1er semestre �131 � Intro à l’algorithmique et à la programmation
 IUT de Villetaneuse

23 i++;
24 }
25

26 if (IndplusGrandEntierPair !=-1)
27 cout << "Le plus grand entier pair est:" << tab[IndplusGrandEntierPair] << endl ;
28 else
29 cout << "Le tableau ne contient pas de nombre pair "<< endl ;
30 return 0;

� � �
31 }

� Exercice 5 : Fonction et passage de tableau **

Définir une fonction somme prenant en paramètre un tableau d’entiers et retournant la somme
des nombres de ce tableau. Dans le programme principal, affecter à la variable tab le tableau
5,6,8,14,17. Afficher ensuite la somme du tableau à l’aide de la fonction somme.
� �
Correction :
1 #define TAILLE_MAX 5
2

3 int somme(int t[], int taille)

4 {
5 int somme = 0;
6 int i = 0;
7 while (i<taille)
8 {
9 somme += t[i];
10 i++;
11 }
12 return somme;
13 }
14

15 int main ()
16 {
17 int tab [TAILLE_MAX] = {5,6,8,14,17};
18 cout << "la somme est :" << somme(tab,TAILLE_MAX) << endl;
19 return 0;

� � �
20 }

Exercice 6 : Rotations **
Ecrire un programme qui permet d’effectuer une rotation à droite des éléments d’un tableau
d’entiers, quelque soit le nombre d’éléments qu’il contient.
Exemple d’affichage attendu :
Avant rotation a droite
{15, -10, 70, 74, 12, 20}
Apres rotation a droite
{20, 15, -10, 70, 74, 12}
Correction :
� �
On peut passer rapidement sur l’affichage !

1 #define TAILLE_MAX 6
2

3 int main()
4 {

� �
Intro à l’algorithmique et à la programmation �132 � 1er semestre
 Departement informatique

5 int tab[TAILLE_MAX] = {15,-10,70,74,12,20};

6

7 // Affichage
8 cout << "Avant rotation a droite" << endl ;
9 int i=0;
10 while ( i < TAILLE_MAX)
11 {
12 cout << tab[i] << " , " ;
13 i++ ;
14 }
15 cout << endl ;
16

17 // Rotation
18 int aux=tab[TAILLE_MAX-1];
19 i = TAILLE_MAX - 1;
20 while (i>=1)
21 {
22 tab[i]=tab[i-1];
23 i--;
24 }
25 tab[0]=aux;
26

27 // Affichage
28 cout << "Apres rotation a droite" << endl ;
29 i=0;
30 while ( i < TAILLE_MAX)
31 {
32 cout << tab[i] << " , " ;
33 i++ ;
34 }
35 cout << endl ;
36 return 0;

� � �
37 }

� �
1er semestre �133 � Intro à l’algorithmique et à la programmation
 IUT de Villetaneuse

TP7 : Tableaux (Corrigé)

� Exercice 7 : Les valeurs par défaut *

Écrire un programme permettant d’identifier les valeurs prises par défaut lors de l’initialisation
d’un tableau avec une liste de littéraux trop courte pour les tableaux de type int, double, char,
string et bool.

� �
Correction :
1 int main()
2 {
3 int tabint[2] = {1} ;
4 cout << "-" << tabint[1] << "-" << endl;
5

6 double tabdouble[2] = {1.0} ;

7 cout << "-" << tabdouble[1] << "-" << endl;
8

9 char tabchar[2] = {’a’} ;

10 cout << "-" << tabchar[1] << "-" << endl;
11

12 string tabstring[2] = {"a"} ;

13 cout << "-" << tabstring[1] << "-" << endl;
14

15 bool tabbool[2] = {true} ;

16 cout << "-" << tabbool[1] << "-" << endl;
17

18 return 0;

� � �
19 }

� Exercice 8 : Saisie et traitement d’un tableau de notes * & **

Le but de cet exercice est d’écrire un programme qui permet à un utilisateur de saisir les notes
d’un étudiant et de les stocker dans un tableau. La saisie s’arrête lorsque l’utilisateur a saisi un
nombre strictement inférieur à 0 ou strictement supérieur à 20. Le programme affiche ensuite le
minimum, le maximum et la moyenne.
Question 8.1 : Écrire une fonction affiche permettant d’afficher un tableau de nombre réels et
le programme principal permettant de la tester.

� �
Correction :
1 void affiche_tableau(double tab[], int taille)
2 {
3 int i = 0;
4 while (i<taille)
5 {
6 cout << tab[i] << endl;
7 i++;
8 }
9 }
10

11 int main()
12 {
13 double tab[10] = {3.,2.65,7.0,-9.5};
14 affiche_tableau(tab, 4);

� �
Intro à l’algorithmique et à la programmation �134 � 1er semestre
 Departement informatique

15 cout << "----" << endl;

16 affiche_tableau(tab, 5);
17 return 0;

� � �
18 }

Question 8.2 : Définir une fonction moyenneTab prenant en paramètre un tableau de réels et
retournant la moyenne des nombres du tableau. Testez la fonction !
� �
Correction :
1 double moyenneTab(double tab[], int taille)
2 {
3 double somme=0;
4 int i =0;
5 while (i<taille)
6 {
7 somme += tab[i];
8 i++;
9 }
10 return somme/ taille ;
11 }
12

13 int main()
14 {
15 double tab[10] = {3.,2.65,7.0,-9.5};
16 moyenneTab(tab, 4);
17 cout << "moy = " << moyenneTab(tab, 4) << endl;
18 return 0;

� � �
19 }

Question 8.3 : Définir une fonction minMax prenant en paramètre un tableau de réels (et bien sûr
sa taille) et deux paramètres réels min et max. La fonction déterminera le minimum et le maximum
des éléments du tableau et modifiera les paramètres min et max en conséquence. La fonction ne
retournera aucune valeur.
� �
Correction :
1 void minMax(double tab[], int taille, double & min, double & max)
2 {
3 min = tab[0];
4 max = tab[0];
5 int i =1;
6 while (i<taille)
7 {
8 if (tab[i] < min)
9 min = tab[i];
10

11 if (tab[i] > max)

12 max = tab[i];
13 i++;
14 }
15 }
16

17 int main()
18 {
19 double min ;
20 double max ;
21 double tab[10] = {3.,2.65,7.0,-9.5};

� �
1er semestre �135 � Intro à l’algorithmique et à la programmation
 IUT de Villetaneuse

22 minMax(tab, 4, min, max);

23 cout << "min = " << min << endl;
24 cout << "max = " << max << endl;
25 return 0;

� � �
26 }

Question 8.4 : Définir une fonction saisieNotes prenant en paramètre un tableau de réels (mais
pas sa taille). La fonction permettra à un utilisateur de saisir les notes d’un étudiant et de les
stocker dans le tableau passé en paramètre. La saisie s’arrête lorsque l’utilisateur a saisi un nombre
strictement inférieur à 0 ou strictement supérieur à 20. La fonction retournera le nombre de notes
saisies par l’utilisateur.

� �
Correction :
1 int saisieNotes(double tab[])
2 {
3 int taille = 0;
4 double nb;
5 cout << "Saisissez une note : " ;
6 saisie( nb );
7 while (nb >= 0.0 && nb <= 20.0)
8 {
9 tab[taille] = nb ;
10 taille++;
11 cout << "Saisissez une note : " ;
12 saisie( nb );
13 }
14 return taille;

� � �
15 }

Question 8.5 : Écrire le programme principal en utilisant les fonctions définies précédemment.
Le tableau de notes sera déclaré comme un tableau de taille 1000 afin de s’assurer que l’utilisa-
teur ne dépasse pas la capacité du tableau. Si l’utilisateur ne saisit aucune note, le programme
devra afficher Aucune note n’a été saisie pour l’étudiant au lieu des minimum, maximum
et moyenne. Ajouter également la mention de l’étudiant : redoublement (< 10), passable (entre 10
et 12), assez-bien (entre 12 et 14), bien (entre 14 et 16) et très bien (supérieur ou égal à 16).

� �
Correction :
1 int main ()
2 {
3 double notes[10000] ;
4 int nbNotes = saisieNotes(notes);
5

6 if (nbNotes > 0 )
7 {
8 affiche_tableau(notes, nbNotes) ;
9 double min,max;
10 minMax(notes,nbNotes,min,max);
11 cout << "la note minimale : " << min << endl;
12 cout << "la note maximale : " << max << endl;
13

14 double moy=moyenneTab(notes, nbNotes);

15 if (moy < 10.0)
16 cout << "Redoublement avec une moyenne : " << moy << endl;
17 else if (moy < 12.0)
18 cout << "Passable avec une moyenne : " << moy << endl;

� �
Intro à l’algorithmique et à la programmation �136 � 1er semestre
 Departement informatique

19 else if (moy < 14.0)

20 cout << "Assez bien avec une moyenne :" << moy << endl;
21 else if (moy < 16.0)
22 cout << "Bien avec une moyenne :" << moy << endl;
23 else
24 cout << "Très bien avec une moyenne :" << moy << endl;
25 }
26 else
27 cout << "Aucune note n’a été saisie pour l’étudiant" << endl;
28

29 return 0;

� � �
30 }

Question 8.6 : Remplacer les nombres magiques par des constantes nommées si cela n’a pas été
fait.
� �
Correction :
1 #define MAX_SIZE 10000
2

3 int main ()
4 {
5

6 double notes[MAX_SIZE] ;
7 int nbNotes = saisieNotes(notes);
8

9 //...
10

11 return 0;

� � �
12 }

Exercice 9 : Pour poursuivre le TD * & ** & ***

Question 9.1 : * Définir une fonction initAlea prenant en paramètre un tableau d’entiers (et sa
taille) et initialisant les éléments du tableau avec des nombres aléatoires compris entre 1 et 100.
� �
Correction :
1 void initAlea(int tab[], int lon)
2 {
3 int i = 0 ;
4 while (i<lon)
5 {
6 tab[i] = 1 + (int) (100.0 * rand() / (RAND_MAX + 1.0) );
7 i++;
8 }

� � �
9 }

Question 9.2 : * Écrire une fonction qui affiche un tableau d’entiers.

� �
Correction :
1 void affichetab(int tab[], int lon)
2 {
3 int i =0 ;
4 while (i<lon)
5 {

� �
1er semestre �137 � Intro à l’algorithmique et à la programmation
 IUT de Villetaneuse

6 cout << tab[i] <<endl ;

7 i++;
8 }

� � �
9 }

Question 9.3 : ** Écrire une fonction qui reçoit un tableau d’entiers et sa taille, et qui renvoie
vrai ou faux selon que le tableau est trié dans l’ordre croissant ou non.

� �
Correction :
1 bool est_trie(int tab[], int lon)
2 {
3 int i = 1 ;
4 while (i<lon)
5 {
6 if (tab[i]<tab[i-1])
7 return false ;
8 i++;
9 }//fin du while
10 return true ;

� � �
11 }

Question 9.4 : * Écrire le programme principal déclarant un tableau de 25 entiers, l’initialisant

aléatoirement et indiquant si le tableau est trié.

� �
Correction :
1 int main(void)
2 {
3 srand(time(NULL));
4

5 int tabint[25] ;
6 initAlea(tabint,25);
7 affichetab(tabint, 25);
8 if (est_trie(tabint, 25))
9 cout <<"Dans l’ordre croissant" << endl;
10 else
11 cout << "Pas dans l’ordre" << endl;
12 return 0;

� � �
13 }

Question 9.5 : *** Écrire une fonction inserer qui reçoit un tableau d’entiers et sa taille. Le
tableau est trié dans l’ordre croissant, sauf le dernier élément qui peut être n’importe quoi. La
fonction met le dernier élément à sa place par rapport au reste sans rien perdre, de façon que
le tableau soit trié (cela s’appelle insérer le dernier élément). Tester la fonction précédente sur
quelques exemples.

� �
Correction :
1 void insere(int tab[], int lon)
2 {
3 int i = lon - 2 ;
4 int tmp = tab[lon -1] ;
5 bool fait = false ;
6 while (i >= 0 && ! fait)
7 {
8 if (tmp < tab[i])

� �
Intro à l’algorithmique et à la programmation �138 � 1er semestre
 Departement informatique

9 tab[i+1] = tab[i];
10 else
11 {
12 tab[i+1] = tmp ;
13 fait = true ;
14 }
15 i-- ;
16 }//fin du while
17 if (! fait)
18 tab[0] = tmp ;

� � �
19 }

Question 9.6 : * Modifier le programme principal afin de trier le tableau à l’aide de la fonction
inserer.
� �
Correction :
1 int i = 1;
2 while (i<=25)
3 {
4 insere(tabint,i);
5 i++;
6 }

� � �
7 affichetab(tabint, 25) ;

Question 9.7 : ** Terminer le programme en déterminant si l’utilisateur a rentré deux fois le

même nombre (dans le tableau trié).
� �
Correction :
1 //Puisque le tableau est trié
2 bool deuxfois = false ;
3 for (i = 0; i<24 && ! deuxfois; i++)
4 if (tabint[i] == tabint[i+1])
5 deuxfois = true;
6

7 if (deuxfois)
8 cout << "Il y a une répétition" << endl ;
9 else

� � �
10 cout << "Il n’y a pas de répétition" << endl;

� Exercice 10 : **
Question 10.1 : ** En modifiant légèrement les fonctions de l’exercice précédent, écrire un
programme qui permet de trier un tableau de 5 prénoms par ordre alphabétique, les noms étant
saisis par l’utilisateur.
Correction :
C’est la même chose que l’exercice précédent, il faut juste remplacer les paramètres type tableau d’entiers par
tableaux de string. �

Question 10.2 : ** Modifier ce programme en triant les prénoms par taille. Pour ce dernier vous
pouvez utiliser la fonction int size(string s) qui permet de retourner la taille d’une chaîne.
� �
Correction :
1 void insere(string tab[], int lon)

� �
1er semestre �139 � Intro à l’algorithmique et à la programmation
 IUT de Villetaneuse

2 {
3 int i = lon - 2 ;
4 string tmp = tab[lon -1] ;
5 int fait = 0 ;
6 while (i >= 0 && ! fait)
7 {
8 if (size(tmp) < size(tab[i]))
9 tab[i+1] = tab[i];
10 else
11 {
12 tab[i+1] = tmp ;
13 fait = 1 ;
14 }
15 i-- ;
16 }//fin du while
17 if (! fait)
18 tab[0] = tmp ;

� � �
19 }

� �
Intro à l’algorithmique et à la programmation �140 � 1er semestre