Intéret des tableaux



Je vais commencer pas montrer l'intéret des tableaux à travers un problème pratique.

Supposons qu'on ait le problème suivant : on voudrait écrire une procédure permettant de multiplier dix nombres entiers par trois.

Supposons que ces dix entiers soient des variables globales. Chacune de ces variables devraient être déclarée. Nommons les N0, N1, ..., N9. On aurait donc la déclaration suivante:

 int N0, N1, ..., N9 ;

Et la procédure de multiplication devrait comporter dix instructions :

void MultiplierPar3 () {

 N0 = N0 * 3;
 N1 = N1 * 3;
 .
 .
 N9 = N9 * 3;
}

Pour dix entiers cette manière de procéder est envisageable. Mais imaginez qu'on ait le même problème avec un millions d'entiers !

Ne croyez pas d'ailleurs que le traitement d'un million d'entiers soit un problème totalement irréaliste, car les ordinateurs ont souvent à traiter des millions de nombres en même temps. En informatique, ce type de problème est tout à fait courant.

Malheureusement, on ne peut pas utiliser de boucle pour faire ceci, car on a aucun moyen de faire varier le nom d'une variable !

Alors comment faire ?

La solution est d'utiliser un tableau.

Pour utiliser un tableau, il faut tout d'abord déclarer une variable de type tableau.

Avec l'exemple précédent ce serait par exemple (ne soyez pas troublé par la syntaxe assez rébarbative de cette déclaration, nous reviendrons la dessus) la variable N déclarée comme suit :

 int N [] = new int [10]

Cette écriture revient à déclarer dix entiers, mais elle est beaucoup plus concise. N est une variable unique qui désigne l'ensemble de ces entiers. C'est en quelque sorte une variable qui en contient dix !

D'autre part, il devient à présent possible d'accéder individuellement à chacun de ces entiers par une notation indicée: N[0] pour le premier, N[1] pour le deuxième, ... etc, N[9] pour le dixième. Le nombre entier qui figure entre les crochets est appelé l'indice de l'élément en question.

Comme l'indice ne fait pas partie du nom du tableau, il peut varier. Il devient donc à présent possible de multiplier les dix entiers par trois avec une boucle. Par exemple, comme ceci (voir le schéma pour un exemple de déroulement de cette boucle):

void MultiplierPar3 () {
  int i ;
  i = 0;
  while (i < 10) {
    N[i] = N[i] * 3;
    i++;
  }
}

Vous constaterez qu'avec un millions d'entiers, le code du programme n'est pas plus long:

void MultiplierPar3 () {
  int i ;
  i = 0;
  while (i < 1000000) {
    N[i] = N[i] * 3;
    i++;
  }
}