Chapitre 4

Initiation à la programmation : Langage C++
Chapitre 4 : Tableaux
Pr. Driss ABADA
Filière SMP - S4
Faculté des Sciences El Jadida
Année Universitaire : 2019/2020

Plan
1 Définition d’un tableau
2 Tableaux statiques unidimensionnels
3 Tableaux statiques bidimensionnels
4 Tableaux statiques multidimensionnels
5 Chaînes de caractères
6 Fonctions et tableaux
Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 2 / 29

Définition d’un tableau
1 Définition d’un tableau
Un tableau est un ensemble fini d’éléments de même type désignés par un
identificateur unique (un nom).
Les éléments d’un tableau sont stockés consécutivement en mémoire et
occupent chacun le même espace mémoire.
Chaque élément est repéré par une valeur entière ou plus appelée indice
(ou index) indiquant sa position dans l’ensemble.
Les tableaux statiques sont toujours à bornes fixes et leur indeçage
démarre toujours à partir de 0.

Tableaux statiques unidimensionnels
2 Tableaux statiques unidimensionnels

Définition
I Lorsque un élément d’un tableau n’est pas lui-même un tableau il s’agit d’un
tableau unidimensionnel ou un tableau à une seule dimension.
Déclaration
I En langage C++, la syntaxe de la déclaration d’un tableau à une dimension
est la suivante :
Syntaxe de déclaration :
type nom_tableau [ taille ] ;
I où type représente le type (int, double, char, . . . ) des éléments du tableau et
taille le nombre d’éléments dont il se compose.
I La taille d’un tableau est un entier constant qui ne peut pas changer
pendant l’exécution du programme.

Exemples
int tab [5] ; // tableau unidimensionnel de 5 entiers

char nom_etudiant [30] ; /* tableau de 30 caract è res . */

Initialisation d’un tableau unidimensionnel

I On peut affecter des valeurs aux éléments d’un tableau au moment de sa
déclaration, on parle de son initialisation.
Différentes manières pour initialiser un tableau à une dimension :
/* tab est d é clar é comme un tableau de 5 entiers et on affecte

les valeurs 10 ,20 ,... ,50 à tab [0] , tab [1] ,... , tab [4] resp . */
int tab [5] = {10 , 20 , 30 , 40 , 50} ;
// l ’ instruction suivante g é n é rera une erreur de compilation .
int tab [5] = {10 ,20 ,30 ,40 ,50 ,60}; // la taille est d é pass é e
// On peut initialiser un tableau sans indiquer sa taille
int tab [] = {10 , 20 , 30 , 40 , 50 , 60} ;
/* Cet instruction affecte à tab [0] et tab [1] les valeurs
10 et 20. tab [2] , tab [3] et tab [4] sont mis à 0. */
int tab [5] = {10 , 20} ;
int tab [5] = {0} ; // met tous les é l é ments à z é ro .

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

I Pour accéder à un élément d’un tableau à une dimension, on utilise son indice.
Syntaxe utilisée pour accéder à un élément du tableau :
nom_tableau [ indice ] ;
I où indice peut être une valeur entière, une variable ou une expression.
I Le premier élément est repéré par l’indice 0.
Premier élément : nom_tableau [ 0 ] ;
I Le dernier élément est repéré par l’indice taille - 1.
Dernier élément : nom_tableau [ taille - 1 ] ;
Exemples :
int i = 1 ; // d é claration d ’ un entier

tab [0] ; // acc è s au premier é l é ment du tableau
tab [ i ] ; // acc è s au deuxi è me é l é ment du tableau
tab [2 * i + 1] ; // acc è s au quatri è me é l é mnet

Opérations sur les tableaux unidimensionnels

I Affectation
Remplir tous les éléments du tableau tab grâce à la boucle for
for ( int i =0; i <5; i ++)

{
tab [ i ] = ( i + 1)*10 ; // affectation
}
I Lecture
Remplir le tableau tab à partir de clavier
for ( int i =0; i <5; i ++)

{
cin >> tab [ i ] ; // lecture
}

I Écriture
afficher les éléments du tableau tab
for ( int i =0; i <5; i ++)

{
cout << tab [ i ] ; // affichage
}
I Opérations logiques et arithmétiques

Les éléments du tableau dans des expressions logiques et arithmétiques
for ( int i =0; i <5; i ++)

{
if ( tab [ i ]%2 == 0) // logique
tab [ i ] = 2 * tab [ i ]; // arithm é tique
else
tab [ i ] = tab [ i ] + 2 ;
}

Tableaux statiques bidimensionnels
2 Tableaux statiques bidimensionnels

Définition
I Un tableau bidimensionnel ou un tableau à deux dimension appelé souvent
matrice est un tableau unidimensionnel dont chaque élément est un tableau

unidimensionnel.
Déclaration d’un tableau bidimensionnel
I Un tableau bidimensionnel est déclaré en C++ de la façon suivante :
type nom_tableau [ N ] [ M ] ;
I On a déclaré une matrice nom_tableau de N lignes et de M colonnes, où N

et M sont des constantes entières.
Exemple de déclaration d’une matrice en C++ :
// d é clarer une matrice des float de 2 lignes et 3 colonnes .

float mat [2][3] ;

Initialisation d’un tableau bidimensionnel

I On peut aussi initialiser les tableaux bidimensionnels :
Différentes manières pour initialiser un tableau à deux dimension :
// Un tableau mat de trois é l é ments

int mat [2][3]={{1 ,5 , -4} ,{10 , -2 , 0}}
// ou bien
int mat [2][3] = {1 ,5 , -4 , 10 , -2 ,0} ;
// Initialiser tous les é l é ments à z é ro .
int a [2][3] = {0};
// tableau à 2 dimensions de 2 lignes et 5 colonnes :
int m [2][5] = { 2 , 6 , -4 , 8 , 11 , 3 , -1 , 0 , 9 , 2 } ;
// Les r è gles d ’ initialisation des tab 1 dim sont respect é es
int a [][3]= {{2} ,{5} ,{8}};
/* 2 0 0
5 0 0
8 0 0 */

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

I Un tableau bidimensionnel est déterminé par deux indices.
Syntaxe utilisée pour accéder à un élément du tableau bidimensionnel :
nom_tableau [ indice1 ] [ indice2 ] ;
I où indice1 fait référence à la ligne et indice2 à la colonne.

I Le premier élément du tableau est désigné par : nom_tableau [ 0 ] [ 0 ] ;
I Le dernier élément est désigné par : nom_tableau [ N-1 ] [ M-1 ] ;
Exemples :
float Note [3 ] [ 4 ];
/* Note [0][0] , Note [0][1] , Note [0] [2] , Note [0] [3] ,
Note [1][0] , Note [1][1] , Note [1] [2] , Note [1] [3] ,
Note [2][0] , Note [2][1] , Note [2] [2] , Note [2] [3] ,
*/

Opérations sur les tableaux bidimensionnels

I Affectation
Initialiser le tableau mat grâce à la boucle for
for ( int i =0; i < 2; i ++)

{
for ( int j =0 ; j < 3 ; j ++)
{
mat [ i ][ j ]= i + j ; // affectation
}
}
I Lecture
Saisir des données dans le tableau mat :
for ( int i =0; i < 2; i ++)

{
for ( int j =0 ; j < 3 ; j ++)
{
cin > > mat [ i ][ j ]; // lecture
}
}
I Écriture
Afficher les éléments du tableau mat
for ( int i =0; i < 2; i ++)

{
for ( int j =0 ; j < 3 ; j ++)
{
cout < < mat [ i ][ j ]; // affichage
}
}
I Remarque :
Pour déterminer la taille d’un tableau unidimensionnel ou la dimension d’un
tableau bidimensionnel, on peut utiliser la fonction sizeof() :
int taille = sizeof ( tab )/ sizeof ( tab [0]); // taille de tab

int dim = sizeof ( mat )/ sizeof ( mat [0][0]) ; // dimension de mat

Tableaux statiques multidimensionnels
3 Tableaux statiques multidimensionnels

Définition
I Un tableau multidimensionnel ou tableau à plusieurs dimensions est un
tableau dont ses éléments sont eux même des tableaux. C’est donc un tableau
de dimension supérieur ou égale à deux.
Déclaration d’un tableau multidimensionnel
I La déclaration d’un tableau multidimensionnel de dimension N se fait de la
manière suivante :
type nom_tableau [ dim1 ] [ dim2 ] [ dim3 ] ... [ dimN ] ;
Exemple de déclaration :
float T [ 5 ] [ 4 ] [ 2 ]; // T est un tableau de 5 tableaux à 2 dim.
Manipulation d’un tableau multidimensionnel

I Le principe de manipulation d’un tableau multidimensionnel est le même que
celui de la manipulation d’un tableau bidimensionnel.
Chaînes de caractères
4 Chaînes de caractères
Définition
I Une chaîne de caractères est un tableau unidimensionnel de caractères.
I En C++, toute chaîne de caractères se termine par le caractère ’\0’.
I Une chaîne de caractères constante est délimitée par des doubles quotes "".
Déclaration d’une chaîne de caractère

Syntaxe de déclaration d’une chaîne de caractère en C/C++ :
char nom_chaine [ taille ] ;
Initialisation d’une chaîne de caractère
// Par une liste de constantes caract è res

char ch1 [10]={ ’B ’ , ’o ’ , ’n ’ , ’j ’ , ’o ’ , ’u ’ , ’r ’ };
char ch2 []={ ’B ’ , ’o ’ , ’n ’ , ’j ’ , ’o ’ , ’u ’ , ’r ’ , ’ \0 ’ };
char ch3 [10]= " Bonjour " ; // par une chaine litt é rale
char ch4 [] = " Bonjour " ; // cha4 aura 8 é l é ments
Chaînes de caractères
Saisie d’une chaîne de caractères
char nom_chaine [30];

cin >> nom_chaine ;
Affichage d’une chaîne de caractères
cout << nom_chaine ;
Saisie d’un tableau de 10 chaînes de 25 caractères au maximum
char ch [10][25]; // chaine [ nb_chaines ][ longueur_max ]

for ( int i =0; i <10; i ++)
{
cout <<" Entrer la chaine " <<i +1 < < endl ;
cin > > ch [ i ];
}
Fonctions et tableaux
5 Fonctions et tableaux
Passage d’un tableau à une fonction
I Une fonction peut recevoir en argument un tableau de n’importe quel type.
I La syntaxe d’une fonction recevant un tableau en argument est :
Syntaxe de déclaration
type_retourné nom_fonction ( type nom_tableau[] ) ;
I La syntaxe d’appel d’une fonction recevant un tableau en argument est :

Syntaxe d’appel :
nom_fonction ( nom_tableau );
Retour d’un tableau par une fonction

I Une fonction peut retourner un tableau de n’importe quel type à la fonction
appelante.
I La syntaxe d’une fonction retournant un tableau (pointeur) :
type_retourné *nom_fonction ( type1 arg1, type2 arg2, ... ) ;
Fonctions et tableaux
Exemple :
// D é claration de la fonction
double somme ( double x [] , int n );
// pogramme principale
int main () {
double x [5] = {1 , 2 , 3 , 4 , 5};
double y = somme (x ,5);
cout << " somme = " << y << endl ;
return 0;
}
// D é finition de la fonction
double somme ( double x [] , int n ) {
double somme =0.;
for ( int i =0; i < n ; i ++)
somme = somme + x [ i ];
return somme ;
}

Exercices corrigés
Exercice 1 :
1 Ecrire les fonctions qui permettent d’effectuer sur un vecteur numérique les
opérations suivantes :
I Saisie ;
I Affichage ;
I Module ;
I Somme des éléments ;
2 Proposer un programme piloté par un menu qui permet de saisir la taille du
vecteur et appliquer les opérations par choix. La taille maximale du vecteur
est 300.
Indication : pour calculer la racine carrée, on peut faire appel à la fonction
standard sqrt() définie dans la librairie cmath.

Exercices corrigés
Corrigé de l’exercice 1
# include < iostream >

# include < cmath >
using namespace std ;
const int Tmax =300 ; // ou # define Tmax 300
void Saisie ( double V [] , int n );
void Afficher ( double V [] , int n );
double Somme ( double V [] , int n );
double Module ( double V [] , int n );
int main () {
double U [ Tmax ];
int n ; char choix ;
cout < < " ========== MENU ============== " << endl ;
cout < < " (1) *=*=* Saisie *=*=*= " << endl ;
cout < < " (2) *=*=* Afficher *=*=*= " << endl ;
cout < < " (3) *=*=* Somme *=*=*= " << endl ;
cout < < " (4) *=*=* Module *=*=*= " << endl ;
cout < < " ( Q ou q ) *=*=* Quitter *=*=*= " << endl ;
Exercices corrigés
do {
cout < < " Donner votre choix " << endl ;
cin > > choix ;
switch ( choix ) {
case ’1 ’ :
cout < < " Saisir la taille du vecteur " << endl ;
cin > > n ;
Saisie (U , n );
case ’2 ’ :
Afficher (U , n );
break ;
case ’3 ’ :
cout < < " La somme est : " << Somme (U , n ) < < endl ;
break ;
Exercices corrigés
case ’4 ’ :
cout < < " Le module est " << Module (U , n ) < < endl ;
break ;
case ’q ’ :
case ’Q ’:
cout < < " ----- Fin du programme ------ " << endl ;
break ;
default :
cout < < " Vous avez que les choix 1 ,2 ,3 , q et Q " ;
}
} while (( choix != ’Q ’ )&& ( choix != ’q ’ ));
return 0;
}
Exercices corrigés
void Saisie ( double V [] , int n )

{
for ( int i =0; i < n ; i ++)
{
cout < < " Saisir l element " <<i +1 < < endl ;
cin > > V [ i ];
}
}
void Afficher ( double V [] , int n )
{
int i =0;
while ( i ++ < n )
cout < < " Element [ " <<i < < " ] = " <<V [i -1] < < endl ;
}
Exercices corrigés
double Somme ( double V [] , int n )

{
double somme =0;
for ( int i =0; i < n ; i ++)
somme += V [ i ];
return somme ;
}
double Module ( double V [] , int n )
{
double somme =0;
for ( int i =0; i < n ; i ++)
somme += V [ i ]* V [ i ];
return sqrt ( somme );
}
Exercices corrigés
Exercice 2 :
Écrire un programme qui met à zéro les éléments de la diagonale principale d’une
matrice carrée A saisi au clavier. La dimension maximale de la matrice est 20x20.
Corrigé de l’exercice 2 :

int main () {
int A [20][20];
int N ; // dimension
cout < < " Saisir la dimension " << endl ;
cin > > N ;
for ( int i =0; i < N ; i ++) { // Saiaie de la matrice
for ( int j =0; j < N ; j ++) {
cin > > A [ i ][ j ];
}
}
Exercices corrigés
// Mise à z é ro de la diagonale principale

for ( int i =0; i < N ; i ++)
{
A [ i ][ i ]=0;
}
for ( int i =0; i < N ; i ++) // Affichage de la matrice
{
for ( int j =0; j < N ; j ++)
{
cout < < A [ i ][ j ] < < " \ t " ;
}
cout < < " \ n " ;
}
return 0;
}
Exercices corrigés
Exercice 3 :
1 Écrire une fonction qui retourne la longueur (nombre de caractère) d’ une
chaîne de caractères donnée.

2 Écrire un programme qui permet de saisir une chaîne de caractère et de
renvoyer sa longueur.
Corrigé de l’exercice 3 :
int longueur ( char chaine []); // prototype
int main () {
char ch [30] , car ;

Exercices corrigés
cout < < " Saisir une chaine de caractere \ n " ;

cin > > ch ;
cout < < " Le nombre de caractere : " << longueur ( ch );
return 0;
}
int longueur ( char chaine []) // d é finition
{
int i =0;
while ( chaine [ i ]!= ’ \0 ’)
i ++;
return i ;
}

Chapitre 4

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 4

Transféré par

Droits d'auteur :

Formats disponibles

Initiation à la programmation : Langage C++

Pr. Driss ABADA

Faculté des Sciences El Jadida

Année Universitaire : 2019/2020

1 Définition d’un tableau

2 Tableaux statiques unidimensionnels

3 Tableaux statiques bidimensionnels

4 Tableaux statiques multidimensionnels

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 2 / 29

1 Définition d’un tableau

Un tableau est un ensemble fini d’éléments de même type désignés par un

identificateur unique (un nom).

Les éléments d’un tableau sont stockés consécutivement en mémoire et

occupent chacun le même espace mémoire.

(ou index) indiquant sa position dans l’ensemble.

Les tableaux statiques sont toujours à bornes fixes et leur indeçage

démarre toujours à partir de 0.

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 3 / 29

2 Tableaux statiques unidimensionnels

tableau unidimensionnel ou un tableau à une seule dimension.

I où type représente le type (int, double, char, . . . ) des éléments du tableau et

taille le nombre d’éléments dont il se compose.

pendant l’exécution du programme.

int tab [5] ; // tableau unidimensionnel de 5 entiers

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 5 / 29

Initialisation d’un tableau unidimensionnel

/* tab est d é clar é comme un tableau de 5 entiers et on affecte

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 6 / 29

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

int i = 1 ; // d é claration d ’ un entier

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 7 / 29

Opérations sur les tableaux unidimensionnels

for ( int i =0; i <5; i ++)

for ( int i =0; i <5; i ++)

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 8 / 29

for ( int i =0; i <5; i ++)

I Opérations logiques et arithmétiques

for ( int i =0; i <5; i ++)

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 9 / 29

2 Tableaux statiques bidimensionnels

matrice est un tableau unidimensionnel dont chaque élément est un tableau

I On a déclaré une matrice nom_tableau de N lignes et de M colonnes, où N

// d é clarer une matrice des float de 2 lignes et 3 colonnes .

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 10 / 29

Initialisation d’un tableau bidimensionnel

// Un tableau mat de trois é l é ments

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 11 / 29

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

I où indice1 fait référence à la ligne et indice2 à la colonne.

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 12 / 29

Opérations sur les tableaux bidimensionnels

for ( int i =0; i < 2; i ++)

for ( int i =0; i < 2; i ++)

for ( int i =0; i < 2; i ++)

int taille = sizeof ( tab )/ sizeof ( tab [0]); // taille de tab

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 14 / 29

3 Tableaux statiques multidimensionnels

Manipulation d’un tableau multidimensionnel

Déclaration d’une chaîne de caractère

Initialisation d’une chaîne de caractère

// Par une liste de constantes caract è res

Saisie d’une chaîne de caractères

char nom_chaine [30];