Les tableaux

Un tableau est un ensemble d'éléments de même type, constituant une seule variable, donc désignés par un seul identificateur. Les éléments sont stockés en mémoire à des adresses contiguës. Ces adresses correspondent aux positions respectives des éléments dans le tableau. Pour désigner un élément précis, on utilisera sa position dans le tableau appelée « indice ». Cet indice varie de la première position (le numéro zéro), à la dernière position (nombre d'éléments -1).

**Déclaration d'un tableau unidimensionnel

type nom_du_tableau [nombre_éléments];

où :

  • type est un type connu (int, float, char, etc. ),

  • nom_du_tableau est l'identificateur désignant le tableau,

  • nombre_éléments représente le nombre d'éléments du tableau. Il est donné par une constante entière non signée et non nulle ou par une expression dont la valeur peut être évaluée à la déclaration du tableau.

**Accès aux éléments d'un tableau unidimensionnel

Afin de pouvoir accéder aux éléments d'un tableau, on utilise un indice (variable entière positive) dont la valeur varie entre 0 et nombre_d'éléments-1. La syntaxe est la suivante « nom_du_tableau[indice] ».

Exemple

Déclaration d'un tableau :

int tableau[20] ;      /* Un tableau de 20 entiers*/

Accès aux éléments d'un tableau :

  int i ; /* indice utilisé pour parcourir les éléments du tableau */

  int tableau[20] ;    /* déclare un tableau de 20 entiers */

  for (i = 0 ; i < 20 ; i++)   /* boucle pour le parcours d'un tableau */

  {  

    tableau[i] = i ;   /* chaque élément du tableau reçoit son indice comme valeur */

  }

On rencontre parfois des déclarations d'une variable tableau dans laquelle l'information de la taille n'est pas précisée entre les []. C'est le cas dans l'exemple ci-dessous :

int Tint[]={2, 34, 36, 12, 4, 11};

Ici, la taille est déterminée par l'initialisation, car il y a 6 entiers entre les accolades {}.

Il est possible d'initialiser un tableau avec la valeur 0 :

int Tint[6]={0};

Cette initialisation n'est possible qu'avec cette valeur !

Remarque

Le compilateur GCC propose une syntaxe offrant plus de possibilités d'initialisation :

int Tint[10]={[0...5]=2,[5...9]=3};

Attention ! Ce code n'est pas portable !

**Déclaration d'un tableau multidimensionnel

type nom_du_tableau [nombre_éléments1] [nombre_éléments2]...[nombre_élémentsn];

où :

  • type est un type de base (int, float, char, etc),

  • nom_du_tableau permet d'identifier le tableau,

  • nombre_élémentsi représente le nombre d'éléments pour chacune des dimensions i du tableau (de 1 à n dimensions).

De la déclaration nous déduisons que :

  • Le type de la dimension n est type,

  • Le type des éléments de la dimension n-1 est un tableau unidirectionnel type[nombre_élémentsn],

  • Le type des éléments de la dimension n-i est un tableau multidirectionnel type[nombre_élémentsn-i]...[nombre_élémentsn].

**Accès aux données d'un tableau multidimensionnel

De même que pour un tableau unidimensionnel, l'accès à un tableau multidimensionnel se fait en utilisant des indices. Les indices successifs permettent d'accéder successivement à des tableaux de dimensions réduites. Pour obtenir un élément de base (type), le nombre d'indices utilisés devra être égal au nombre de dimensions du tableau.

Exemple

int tableau[10][20] ; /* Déclare un tableau d'entiers de 10 éléments pour la dimensions 1 et de 20 éléments pour la dimension 2 */

/* Accès aux éléments d'un tableau à deux dimensions : */

int i ;        /*indice utilisé pour parcourir les lignes du tableau*/

int j ;        /* indice utilisé pour calculer les colonnes du tableau*/

int tableau[10][20] ;     /* déclare un tableau de 10 lignes et 20 colonnes*/

...

for (i = 0 ; i < 10 ; i++)   /* boucle pour le parcours des lignes du tableau*/

for (j=0 ; j<20 ; j++)   /*boucle pour le parcours des colonnes du tableau*/

{

  tableau[i][j] = 0 ;    /* chaque case du tableau reçoit la valeur 0 */

}

/* tableau[i] désigne un tableau de 20 entiers */

Remarque

Un tableau peut être :

  • Statique : sa taille est déterminée à la déclaration,

  • Dynamique : sa taille est déterminée lors de l'exécution du programme.

On parle respectivement pour le premier ou le second cas, d'allocation statique ou d'allocation dynamique du tableau. L'utilisation de cette dernière suppose l'emploi des pointeurs.