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 retrouver grâce à d'autres valeurs à l'aide de boucles, de formules, d'algorithmes. On peut utiliser un tableau afin de représenter l'état d'un échiquier, le résultat d'une fonction mathématique...

Un tableau est constitué d'un nombre fixe (donné à la définition) de composants du même type. Chaque composant peut être explicitement référencé par le nom du tableau suivi de son indice entre crochets. Les indices sont des valeurs calculables appartenant toutes au type d'indice. Le type d'indice est tout type pouvant être interprété comme un entier (Integer, byte, types énumérés, caractères...).
Il est possible d'introduire des variables de 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 :

Type Tableau = Array [MinDim..MaxDim] of type;
Var nom_du_tableau : Tableau;

MinDim doit être inférieur ou égal à MaxDim. L'un ou les deux peuvent êtres négatifs.

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;

Type
  jours_enum = (dimanche,lundi,mardi,mercredi,jeudi,vendredi,samedi);

  tableau_1 = Array [dimanche..samedi] of Integer;
  
  tableau_2 = Array [jours_enum] of Integer;
  
  tableau_3 = Array [mardi..vendredi] of Integer;

Remarque : le fait 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 réels (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 ne 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 index qui indique la place de la valeur dans la dimension du tableau.

Syntaxes :

nom_du_tableau[index] := valeur;

nom_du_tableau[index1,index2] := valeur;

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

On peut copier 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, 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;

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 plus pratique, pas la plus appréciée aux examens...

Syntaxe :

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

Voici également une autre manière d'introduire des valeurs.

Syntaxe :

nom_du_tableau [index1][index2] := valeur;

Exemple :

Const mt = 3;

Type
  Tab = Array [1..mt,1..mt] of Integer;

Var
  i, j : Integer;
  t : Tab;

BEGIN
  { forme habituelle }
  for i := 1 to mt do
    for j := 1 to mt do t[i,j] := i + j * 10;
  { autre forme }
  for i := 1 to mt do
    for j := 1 to mt do write(t[i][j]:3); 
END.

Le passage d'un tableau (type complexe) en paramètre à une procédure pose problème si on ne prend pas des précautions.

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);

Exemple :

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 (var 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 grâce à 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 Tab2 dans l'ordre. Et une procédure Affiche affiche à l'écran le tableau Tab1, qui contient les éléments 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 Enreg = Record
              Nom : String[20];
              Age : Byte;
            end;
Tab : Array [1..10] of Enreg;

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

Syntaxe :

Tab[5].Nom := 'CyberZoïde';

Il est possible de déclarer un tableau en tant que constante (voir chapitre 26 sur les 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';

Déclarées ainsi (variable : type = valeur), les constantes sont en fait des variables initialisées. Il est possible de modifier leur valeur au cours du programme.