Un tableau permet de m´emoriser plusieurs donn´ees du mˆeme type. Contrairement aux va-riables, les tableaux permettent de stocker des donn´ees nombreuses en m´emoire. Dans ce chapitre nous allons ´etudier :
— La d´efinition d’un tableau `a une dimension
— La d´eclaration, l’initialisation et l’acc´es `a aux ´el´ements d’un tableau
— Les tableaux `a deux dimensions
4.1 Les tableaux ` a une dimension
Un tableau `a une dimension est une suite d’´el´ements simples de mˆeme type et de mˆeme taille, situ´ees dans un espace contigu (voisin) en m´emoire.
4.1.1 D´ eclaration
On d´eclare un tableau par
typeElements nomTableau[NOMBRE ELEMENTS] ;
o`u typeElements est le type des ´el´ements du tableau, nomTableau est le nom du tableau, et NOMBRE ELEMENTS est une constante indiquant le nombre d’´el´ements du tableau.
Par exemple, pour d´eclarer un tableau de 100 entiers appel´e tab : int tab[100] ;
Pour d´eclarer un tableau de 150 caract`eres appel´e chaine ; char chaine[150] ;
Dans une telle d´eclaration, le nombre d’´el´ements du tableau doit ˆetre obligatoirement une constante. Le nombre d’´el´ements du tableau peut ˆetre d´efini dans une directive #define ce qui augmente la souplesse du programme (on peut alors changer le nombre d’´el´ements en changeant au niveau du #define).
4.1.2 Initialisation
Comme les autres types de variables, les ´el´ements du tableau peuvent ˆetre initialis´es lors de la d´eclaration du tableau. On met pour cel`a les valeurs des ´el´ements entre accolades {} s´epar´es par des virgules. La syntaxe :
typeElements nomTableau[NOMBRE ELEMENTS]={C1,C2,. . .,Cn}
O`u C1,C2,. . .,Cn sont des constantes dont le nombre ne doit pas d´epasser le nombre d’´el´ements du tableau (NOMBRE ELEMENTS).
— Si la liste de constantes ne contient pas assez de valeurs pour tous les ´el´ements, les ´el´ements restantes sont initialis´ees `a z´ero.
— Il est ´egalement possible de ne pas indiquer le nombre d’´el´ements et dans ce cas, le com-pilateur r´eserve automatiquement la m´emoire n´ecessaires.
Exemples :
int A[5] = {10, 20, 30, 40, 50};
float B[4] = {-1.05, 3.33, 87e-5, -12.3E4}; int C[10] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1};
int A[] ={10, 20, 30, 40, 50}; /* Si la dimension n’est pas indiqu´ee explicitement lors de l’initia-lisation, alors l’ordinateur r´eserve automatiquement le nombre d’octets (m´emoire) n´ecessaires.*/
4.1.3 Acc` es aux ´ el´ ements d’un tableau
Les ´el´ements d’un tableau sont comme des cases rang´ees successivement dans la m´emoire centrale. Les ´el´ements d’un tableau sont num´erot´es par des indices. Par exemple la d´eclaration et l’initialisation suivante :
short A[5] ={1200, 2300, 3400, 4500, 5600}; comporte 5 ´el´ements ayant des indices 0,1,. . .,4 :
A[0] A[1] A[2] A[3] A[4]
1200 2300 3400 4500 5600
Pour acc´eder `a un ´el´ement du tableau, il suffit donc de donner le nom du tableau, suivi de l’indice de l’´el´ement entre crochets :
nomTableau[indice]
— Un indice est toujours positif
— L’indice du premier ´el´ement du tableau est 0.
— L’indice du dernier ´el´ement du tableau est ´egal au nombre d’´el´ements -1 Par exemple, on acc`ede au 5i`eme ´el´ement du tableau en ´ecrivant : nomTableau[4].
L’indice peut ˆetre une valeur, une variable ou une expression arithm´etique donnant finalement lieu `aun entier.
Exemple : int i=3 ; tab[i]=2 ; tab[i*2-1]=7 ;
Attention : Les indices des ´el´ements d’un tableau commencent `a 0 et non pas `a 1. Par cons´ e-quent, les ´el´ements d’un tableau `a N ´el´ements ont leurs indices allant de 0 `a N -1. L’acc`es `a un
´el´ement d’indice sup´erieur ou ´egal `a N provoquera syst´ematiquement un r´esultat faux, et g´en´ era-lement une erreur m´emoire (erreur de segmentation). On parle de d´epassement de tableaux.
Remarques
— Un ´el´ement du tableau peut ˆetre manipul´e exactement comme une variable, on peut donc effectuer des op´erations sur des ´el´ements de tableau.
D´efinissons un tableau de 10 entiers : int Tab[10] ;
Pour affecter la valeur 6 au huiti`eme ´el´ement, on va ´ecrire : Tab[7]=6 ;
Pour affecter au 10`eme ´el´ement le r´esultat de l’addition des ´el´ements 1 et 2, on est : Tab[9]=Tab[0]+Tab[1] ;
— Il est donc possible d’utiliser une boucle qui va permettre d’initialiser successivement cha-cun des ´el´ements grˆace `a un compteur qui servira d’indice.
int Tab[10] ; int Indice ;
for (Indice=0 ; Indice <=9 ; Indice++) {
Tab[Indice]=0 ; }
— Pour initialiser un tableau Tab1 par les ´el´ements d’un autre tableau Tab2, on peut par exemple ´ecrire :
for(i=0 ;i<=taille tableau ;i++) Tab1[i]=Tab2[i] ;
— Il est possible d’utiliser une boucle for pour afficher et saisir les valeurs d’un tableau.
#include<stdio.h>
main() { int i ;
int Tab[4]={1,4,5,8}; for(i=0 ;i<4 ;i++)
printf(”Tab[%d]=%d\n”,i,Tab[i]) ;
/*Le contenu de Tab[i] sera affich´e sur ´ecran*/
}
4.2 Les tableaux ` a deux dimensions
Un tableau `a plusieurs dimensions poss`ede plusieurs index. Un tableau `a deux dimensions en a deux, un tableau `a trois dimensions en a trois, etc. En langage C, il n’y a pas de limite au nombre de dimensions qu’un tableau peut avoir. On se contereras dans cette section aux tableaux `a deux dimension, aussi appeler matrice.
4.2.1 D´ eclaration
Avant de montrer la syntaxe d’un tableau `a deux dimensions, il nous semble essentiel d’en rappeler le principe. Deux dimensions signifient qu’on a deux entr´ees dans notre tableau, c’est-` a-dire des lignes et des colonnes. La syntaxe :
Type Nom du Tableau[Nombre ligne][Nombre colonne] ; Exemple
int T[3][4] ;
On peut repr´esenter un tel tableau de la mani`ere suivante :
T[0][0] T[0][1] T[0][2] T[0][3]
T[1][0] T[1][1] T[1][2] T[1][3]
T[2][0] T[2][1] T[2][2] T[2][3]
4.2.2 Initialisation
Lors de la d´eclaration d’un tableau, on peut initialiser les composantes du tableau, en indiquant la liste des valeurs respectives entre accolades. A l’int´erieur de la liste, les composantes de chaque ligne du tableau sont encore une fois comprises entre accolades. Pour am´eliorer la lisibilit´e des programmes, on peut indiquer les composantes dans plusieurs lignes.
Exemples
int A[3][10] = { { 0,10,20,30,40,50,60,70,80,90}, {10,11,12,13,14,15,16,17,18,19}, {1,12,23,34,45,56,67,78,89,90} }; float B[3][2] = { {-1.05, -1.10 },
{86e-5, 87e-5}, {-12.5E4, -12.3E4}};
Lors de l’initialisation, les valeurs sont affect´ees ligne par ligne en passant de gauche `a droite.
Nous ne devons pas n´ecessairement indiquer toutes les valeurs : Les valeurs manquantes seront initialis´ees par z´ero. Il est cependant interdit de d´epasser le nombre limite de colonnes ou de lignes r´es´erv´es pour un tableau.
Exemples
int C[4][4] = {{1},{1},{1},{1}}; =⇒ C :
Si le nombre de lignes L n’est pas indiqu´e explicitement lors de l’initialisation, l’ordinateur r´eserve automatiquement le nombre de lignes n´ecessaires.
Exemple
Attention : Consid´erons un tableau A de dimensions L et C.
— les indices du tableau varient de 0 `a L-1, respectivement de 0 `a C-1.
— la composante de la Ni`eme ligne et Mi`eme colonne est not´ee : A[N-1][M-1]
Lors du travail avec les tableaux `a deux dimmensions, nous utiliserons en g´en´eral deux indices (par exemple i et j), et la bouclefor pour parcourir les lignes et les colonnes des tableaux.
Exemple
#include<stdio.h>
main() {
short tab[3][2]={{1,2},{14,15}, {10,20}}; int i,j ;
On vient de d´efinir la matrice :
1 2
14 15 10 20