Tableaux

Notion de tableau
Un tableau est une séquence finie d’éléments de même type, stockés
en mémoire à des adresses contigües (consécutives).
Les éléments d’un tableau correspondent au même identificateur de
variable.
La distinction entre les différentes valeurs se fait à travers un indice
Notion de tableau
Il est évident qu’un tableau ne peut être manipulé que s’il est déclaré.
La déclaration d’une variable tableau précise :
• Le nom du tableau (l’identificateur).
• Le type du tableau (ou bien le type de tous les éléments du tableau).
• Le nombre d’éléments du tableau.
Tableaux à Une Seule
Dimension
Exemple
La figure ci-contre présente un
tableau nommé « t » composé de
100 éléments. Ces éléments sont
notés t[0], t[1], ….., t[99].
Les éléments du tableau « t »
correspondent à des adresses
mémoire consécutives et ils sont
tous de même type.
Déclaration d’un tableau
Voici des exemples de déclarations de tableaux à un seul indice :
int tab1 [20], tab2 [15] ;
double tab3 [50] ;

Remarques :
• Le nombre d’éléments d’un tableau doit être une constante ou une
expression entière dont la valeur est connue au moment de la
compilation.
• Il est en général préférable que la taille d’un tableau soit définie par
une constante symbolique.
Exemple
#define N1 20
#define N2 60
…………
…………
int ages [N1];
float prix [N2];
Initialisation d’un tableau
Il est possible d’initialiser les éléments d’un tableau lors de la
déclaration. Les valeurs des éléments sont données entre deux
accolades et séparées par des virgules. Les valeurs doivent évidemment
correspondre au type du tableau.
Exemple:
#define N 10
#define M 8
int tab1 [N] = {12, 10, 5, 18, 3, 8, 2, 14, 6, 20} ;
float tab2[M] = {0.5, 12.33, 1.25, -6.5, 45.02, 1.02e+12, 0.5e-5, 10} ;
Remarque
• Lors de l’initialisation d’un tableau, si le nombre de valeurs entre accolades
est inférieur au nombre d’éléments, les premiers éléments sont initialisés
aux valeurs données et le reste sera initialisé à la valeur 0 (zéro). Par
contre, si le nombre de valeurs est supérieur au nombre d’éléments il y
aura un dépassement de capacité du tableau (ce qui peut entrainer une
erreur grave).
• Chacune des valeurs doit être une constante ou une expression dont la
valeur peut être connue au moment de la compilation.
• On peut omettre la taille du tableau dans le cas d’une déclaration avec
initialisation comme dans l’exemple suivant :
int tab1 [] = {12, 10, 5, 18, 3, 8, 2, 14, 6, 20} ;
Dans ce cas le nombre d’éléments réservés en mémoire est égal au nombre
de valeurs dans l’initialisation.
Accès aux éléments d’un tableau
L’accès aux éléments d’un tableau se fait à travers l’opérateur « [] » et l’utilisation
d’un indice entier. Si un tableau est déclaré avec N éléments, le premier élément
correspond à l’indice 0 (zéro) et le dernier à l’indice (N-1).

Exemple 1 : Affichage des valeurs d’un tableau

#include <stdio.h>
#define N 8
int main () {
int i, ages [N] = { 12, 13, 14, 12, 16, 21, 18+8, 25};
for (i=0 ; i<N ; i++) {
printf ("%10d", ages[i]);
}
return 0;
}
Accès aux éléments d’un tableau
Exemple 2 : Affichage des valeurs d’un tableau ainsi que leurs indices

#include <stdio.h>
#define N 8
int main () {
int ages [N] = { 12, 13, 14, 12, 16, 21, 18+8, 25};
int i;
for (i=0 ; i<N ; i++) {
printf ("\n ages[%d] : %d", i, ages[i]);
}
return 0;
}
Lecture des éléments d’un tableau
L’élément « t[i] » d’un tableau « t » correspond à une variable simple.
Cette variable peut donc être lue exactement comme toute autre
variable en utilisant le format qui lui correspond.
Exemple 4 : Lecture d’un tableau
Exemple
#include <stdio.h>
#define TAILLE 20
int main () {
int tab [TAILLE] ,i n;
// lecture du nombre d'éléments
do {
printf ("\n Donner le nombre d'éléments (2<=n<=%d) : ", TAILLE);
scanf ("%d", &n);
} while (n < 2 || n > TAILLE);
// Lecture des éléments un par un
for (i=0 ; i<n ; i++) {
printf ("\n tab[%d] : ", i);
scanf ("%d", &tab[i]);
}
// Affichage du tableau
printf ("\n Voici le tableau lu : ");
for (i=0 ; i<n ; i++) printf ("\n tab[%d] = %d", i, tab[i]);
return 0;
}
Quelques exemples d’applications
 Somme et moyenne des éléments d’un tableau
#include <stdio.h>
#define TAILLE 20
int main () {
float notes [TAILLE], somme, moyenne; int i, n;
// lecture du nombre d'éléments
do {
printf ("\n Donner le nombre d'éléments (2<=n<=%d) : ", TAILLE);
scanf ("%d", &n);
} while (n<2 || n>TAILLE);
// Lecture des éléments un par un
for (i=0 ; i<n ; i++)
do { printf ("\n notes[%d] : (0<=note<=20)", i); scanf ("%f", &notes[i]);
} while (notes[i]<0 || notes[i]>20);
// Calcul de la somme et la moyenne
somme = 0.0;
for (i=0 ; i<n ; i++) somme += notes[i]; moyenne = somme / n;
// Affichage des résultats
printf ("\n Somme des éléments : %.2f", somme); printf ("\n Moyenne des éléments : %.2f", moyenne);
return 0;
}
 Trouver la valeur maximale dans un tableau
#include <stdio.h>
#define TAILLE 20
int main () {
int x [TAILLE]; int i, n, maximum;
// lecture du nombre d'éléments
do {
printf ("\n Donner le nombre d'éléments (2<=n<=%d) : ", TAILLE); scanf ("%d", &n);
} while (n<2 || n>TAILLE);
// Lecture des éléments un par un
for (i=0 ; i<n ; i++) {
printf ("\n x[%d] : ", i); scanf ("%d", &x[i]); }
// Recherche du maximum
maximum = x[0];
for (i=1 ; i<n ; i++) if (maximum < x[i]) maximum = x[i];
printf ("\n Le maximum est : %d", maximum);
return 0;
}
Recherche d’une valeur dans un tableau
#include <stdio.h>
#define N 20
int main () {
int t[N] = { 10, 21, 95, 5, 18, 12, 75, 46, 31, 28, 33, 47, 98, 54, 48, 82, 10, 3, 7, 102} , i, val;
// Lecture de la valeur recherchée
printf ("\n Valeur recherchee : ");
scanf ("%d", &val);
// Boucle de recherche de la valeur dans le tableau
i = 0;
while (i < N) {
if (val == t[i]) break;
i++; }
// Affichage du résultat
if (i<N) printf ("\n La valeur %d se trouve dans la position %d du tableau", val, i);
else printf ("\n La valeur %d ne se trouve pas dans le tableau", val);
return 0;
}
Tableaux à Deux dimensions
Tableaux à deux dimensions
Un tableau à deux dimensions est caractérisé par :
• Le nombre de lignes « N » ;
• Le nombre de colonnes « M » ;
• Le type du tableau, ou bien type de tous les éléments du tableau.
Le nombre total d’éléments dans le tableau est : NxM.
Chaque élément du tableau est identifié par deux indices « i » et « j »,
respectivement indice de ligne et indice de colonne.
Déclaration d’un tableau à deux dimensions
La déclaration d’un tableau à deux dimensions doit préciser :
a) Le type du tableau (type des éléments du tableau).
b) Le nom du tableau (identificateur de variable).
c) Le nombre maximum de lignes.
d) Le nombre maximum de colonnes.
Exemple
#define N 20
#define M 30
……………………………….
double a[N][M] ;

✓ « a » est un tableau à deux dimensions composé de « N » lignes et «

M » colonnes.
✓ L’indice de ligne varie entre « 0 » et « N-1 ».
✓ L’indice de colonne varie entre « 0 » et « M-1 ».
Initialisation des éléments d’un tableau
La déclaration d’un tableau à deux dimensions peut comporter des
initialisations. Dans ce cas, la syntaxe utilisée est comme suit :
#define L 10
#define C 20
………..
int mat[L][C] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

La déclaration ci-dessus initialise les 3 premiers éléments des 3

premières lignes. Le reste du tableau sera initialisé à 0 (zéro).
Lecture et affichage d’un tableau à deux
dimensions
Tout traitement sur un tableau à deux dimensions nécessite la
manipulation de deux indices. Cette manipulation se fait le plus
souvent à travers deux boucles imbriquées :
➢ La boucle externe permet de faire varier l’indice de ligne.
➢ La boucle interne permet de faire varier l’indice de colonne.
Il s’agit dans ce cas d’un traitement ligne par ligne. Il est possible
d’inverser les boucles et réaliser un traitement colonne par colonne.
Exemple
#include <stdio.h>
#define L 30
#define C 30
int main () {
int i, j, n, m; float mat[L][C];
// Lecture du nombre de lignes et du nombre de colonnes
do { printf ("\n Nombre de lignes : "); scanf ("%d", &n);
} while ( (1 > n) || (n > L));
do { printf ("\n Nombre de colonnes : "); scanf ("%d", &m);
} while ( (1 > m) || (m > C));
// Lecture du tableau ligne par ligne
for (i = 0 ; I < n ; i++) { printf ("\n Ligne %d", i);
for (j = 0 ; j < m ; j++) { scanf ("%f", &mat[i][j]); } }
// Affichage du tableau lu ligne par ligne
for (i = 0 ; i < n ; i++) { for (j = 0; j < m; j++) { printf ("%12.4f", mat[i][j]); printf ("\n"); } }
return 0;
}
Quelques exemples d’applications
Exemple : Somme de deux matrices
#include <stdio.h>
#define L 30
#define C 30
int main () {
int i, j, n, m; float a[L][C], b[L][C], d[L][C];
// Lecture du nombre de lignes et du nombre de colonnes
………………………………………………..
// Lecture de la matrice "a"
…………………………………………………
// Lecture de la matrice « b »
……………………………………………….
// Calcul de la matrice "d"
for (i = 0 ; i < n ; i++){ for (j = 0; j < m; j++){ d[i][j] = a[i][j] + b[i][j];}}
// Affichage de la matrice "d"
for (i = 0 ; i < n ; i++) { for (j = 0; j < m; j++){ printf ("%12.4f \n", d[i][j]); }
return 0;
}
Exemple : Recherche du maximum d’une matrice
#include <stdio.h>
#define L 30
#define C 30
int main () {
int i, j, n, m, p, r; float a[L][C];
// Lecture du nombre de lignes et du nombre de colonnes
…………………………………………………….
// Lecture de la matrice "a"
…………………………………………………….
// Recherche du Maximum, p et r sont les indices du maximum
p = 0; r = 0;
for (i = 0 ; i < n ; i++){ for (j = 0; j < m; j++){ if (a[p][r] < a[i][j]) { p = i; r = j; }}}
// Affichage du résultat
printf ("\n Le maximum est a[%d][%d] : %12.4f", p, r, a[p][r]);
return 0;
}