Informatique
Accueil
 

CHAPITRE XXI : Tableaux

Par Hugo ETIEVANT

Il est courant d'utiliser des tableaux afin d'y stocker temporairement des données. Ainsi, une donnée peut être en relation avec 1, 2 ou 3 (ou plus) entrées. L'intérêt du tableau est de pouvoir stocker en mémoire des données que l'on pourra retouver grace à d'autres valeurs à l'aide de boucles, de formules, d'algorythmes. On peut utiliser un tableau afin de représenter l'état d'un échiquier, le résultat d'une fonction mathématique... Il est possible d'introduire des variables de presque tous les types au sein d'un tableau : Char, Integer, Real, String, Byte, Record, etc.

Un tableau, tout comme une variable quelconque doit être déclaré dans la partie déclarative du programme. On doit toujours spécifier le type des variables qui seront introduites dans le tableau.
Syntaxe :

Var nom_du_tableau : Array[MinDim..MaxDim] Of type ;

Note : les valeurs MinDim et MaxDim doivent être des Integer ou des Char (c'est-à-dire de type énuméré). Avec MinDim inférieur à MaxDim. L'un ou les deux peuvent êtres négatifs. Le type des variables qui seront mises dans le tableau devra être celui là : type.
Remarque : il ne peut y avoir qu'un seul type de variable au sein d'un tableau.
Exemples :

Var tab1 : Array[0..10] Of Byte ;

Var tab2 : Array[1..100] Of Integer ;

Var tab3 : Array[-10..10] Of Real ;

Var tab4 : Array[50..60] Of String ;

Var tab5 : Array['A'..'S'] Of Char ;

Var tab6 : Array['a'..'z'] Of Extended ; Remarque : que les bornes d'un tableau soient déclarées par des valeurs de type caractère (Char) n'interdit pas pour autant de remplir le tableau de nombres à virgules (voir le tab6 ci-dessus). Car en effet, le type des bornes d'un tableau n'influe aucunement sur le type des variables contenues dans le tableau. Et réciproquement, le type des variables d'un tableau de renseigne en rien sur le type des bornes ayant servi à sa déclaration.

Un tableau peut avoir plusieurs dimensions. Si toutefois, vous imposez trop de dimensions ou des index trop importants, une erreur lors de la compilation vous dira : Error 22: Structure too large.
Syntaxes :

Var nom_du_tableau : Array[MinDim1..MaxDim1, MinDim2..MaxDim2] Of type ;

Var nom_du_tableau : Array[MinDim1..MaxDim1, MinDim2..MaxDim2, MinDim3..MaxDim3] Of type ;

Exemples :

Var tab1 : Array[0..10, 0..10] Of Byte ;

Var tab2 : Array[0..10, 0..100] Of Integer ;

Var tab3 : Array[-10..10, -10..10] Of Real ;

Var tab4 : Array[5..7, 20..22] Of String ;

Var tab5 : Array[1..10, 1..10, 1..10, 0..2] Of Char ;

La technique pour introduire des valeurs dans un tableau est relativement simple. Il suffit de procéder comme pour une variable normale, sauf qu'il ne faut pas oublier de spécifier la position indexqui indique la place de la valeur dans la dimension du tableau.
Syntaxes :

nom_du_tableau[index] := valeur ;

nom_du_tableau[index1, index2] := valeur ;

Note : la variable index doit nécessairement être du même type énuméré que celui utilisé pour la déclaration du tableau.

On peut introduire dans un tableau les valeurs d'un autre tableau. Mais pour cela, il faut que les deux tableaux en question soient du même type (ou de types compatibles), qu'ils aient le même nombre de dimension(s) et le même nombre d'éléments.
Syntaxe :

nom_du_premier_tableau:= nom_du_deuxième_tableau ;

Program exemple26 ;
Var tab : Array[1..10] Of Integer ;
    i : Integer ;
BEGIN
 For i:=1 To 10 Do
 Begin
 tab[i]:=i ;
WriteLn(sqrt(tab[i])*5+3) ;
 End; END.

Ce programme exemple26 utilise un tableau à une seule dimension dont les valeurs seront des variables de type integer. Les "cases" du tableau vont de 1 à 10. Ici, le programme donne à chaque case la valeur de l'index à l'aide d'une boucle. Et ensuite, il affiche les valeurs contenues dans le tableau.

Il existe une autre manière de déclarer un tableau de dimensions multiples en crééant un tableau de tableau. Mais cette technique n'est pas la plus jolie, pas la pratique, pas la plus appréciée aux examens... Donc à ne pas utiliser !
Syntaxe :

Var nom_du_tableau : Array[MinDim1..MaxDim1] Of Array[MinDim2..MaxDim2] Of type ; { syntaxe désuette }

Mais une autre manière d'introduire des valeurs accompagne ce type de déclaration.
Syntaxe :

nom_du_tableau[index1][index2] := valeur ;

Le passage d'un tableau (type complexe) en paramètre à une procédure pose problème si on ne prend pas des précautions. C'est-à-dire qu'il faut déclarer un type précis de tableau (qui sera un type simple).
Syntaxe :

Type nom_du_nouveau_type_tableau = Array[DimMin..DimMax] Of Type ;
Var nom_du_tableau : nom_du_nouveau_type_tableau ;
Procedure nom_de_la_procedure(Var nom_du_tableau : nom_du_nouveau_type_tableau) ;

Program exemple27 ;
Uses crt ;
Type tableau = Array[1..10] Of Integer ;
Procedure saisie(Var tab:Tableau) ;
Var i:Integer ;
Begin
 For i:=1 to 10 Do
Begin
 Write('Entrez la valeur de la case n°',i,'/10 : ') ;
ReadLn(tab[i]) ;
 End ;
 End ;
Procedure tri(Var tab:Tableau) ;
Var i,j,x:Integer ;
Begin
 For i:=1 To 10 Do
Begin
For j:=i To 10 Do
Begin
if tab[i]>tab[j] Then
Begin
 x:=tab[i] ;
tab[i]:=tab[j] ;
tab[j]:=x ;
 End ;
 End ;
 End ;
 End ;
Procedure affiche(tab:Tableau) ;
Var i:Integer ;
Begin
 For i:=1 To 10 Do Write(tab[i],' ') ;
WriteLn ;
 End ;
Var tab1,tab2:Tableau ;
i:Integer ;
 BEGIN
 ClrScr ;
saisie(tab1) ;
tab2:=tab1 ;
tri(tab2) ;
WriteLn('Série saisie :') ;
affiche(tab1) ;
WriteLn('Série triée :') ;
affiche(tab2) ;
 END.

Ce programme exemple27 a pour but de trier les éléments d'un tableau d'entiers dans l'ordre croissant. Pour cela, il déclare un nouveau type de tableau grace à la syntaxe Type. Ce nouveau type est un tableau à une dimension, de 10 éléments de type integer. Une première procédure saisie charge l'utilisateur d'initialiser le tableau tab1. Le programme principal copie le contenu de ce tableau vers un autre appelé tab2. Une procédure tri range les éléments de tab2dans l'ordre. Et une procédure affiche affiche à l'écran le tableau tab1 qui contient les élements dans introduits par l'utilisateur et le tableau tab2 qui contient les mêmes éléments mais rangés dans l'ordre croissant.

Il est également possible d'introduire dans un tableau des données complexes, c'est-à-dire de déclarer un tableau en type complexe (Record).
Syntaxe :

Var tab : Array[1..10] Of Record
nom : String[20] ;
age : Byte ;
End ;

Introduire des valeurs dans un tel tableau nécessite d'utliser en même temps la syntaxe des tableaux et des types complexes.
Syntaxe :

tab[5].nom := 'CyberZoïde' ;

La déclaration de tableau en tant que constante nécessite de forcer le type (le type tableau bien sûr) à la déclaration. (voir Chap XXVI Constantes)
Syntaxe :

Const a : Array[0..3] Of Byte = (103, 8, 20, 14) ;
b : Array[-3..3] Of Char = ('e', '5', '&', 'Z', 'z', ' ', #80) ;
c : Array[1..3, 1..3] Of Integer = ((200, 23, 107), (1234, 0, 5), (1, 2, 3)) ;
d : Array[1..26] Of Char = 'abcdefghijklmnopqrstuvwxyz';

Atention : cette forme parenthèsée est réservée aux constantes car elle ne permet pas de passer un tableau en paramètre à une procédure ou d'initialiser un tableau.

Vos questions techniques : forum d'entraide Pascal - Publiez vos articles, tutoriels et cours
et rejoignez-nous dans l'équipe de rédaction du club d'entraide des développeurs francophones
Nous contacter - Hébergement - Participez - Copyright © 2000-2009 www.developpez.com - Legal informations.