Langage de programmation - Pascal - Types structurés en général

Types structurés en général - Le tableau en particulier

Les types scalaires et sous-intervalle sont des types non structurés. Les autres types en Pascal sont des types structurés. Les déclarations structurées étaient des compositions d'autres déclarations. les types structurés sont des compositions d'autres types. Ce sont les types de composants et, plus important encore, la méthode de structuration générant un type structuré.

Une option disponible pour chacune des méthodes de structuration est une indication de la représentation interne des données préférée. Une définition de type préfixée par le symbole empaqueté signale au compilateur d'économiser les besoins d'entreposage, même au prix d'un temps d'exécution supplémentaire et d'une éventuelle extension du code, en raison des opérations d'emballage et de déballage nécessaires. Il est de la responsabilité de l'utilisateur de se rendre compte s'il souhaite cet échange d'efficacité contre de l'espace. (Les effets réels sur l'efficacité et les économies d'espace d'entreposage dépendent de la mise en oeuvre et peuvent, en fait, être nuls.)

Le type de tableau

Un type de tableau se compose d'un nombre fixe de composantes (définis lors de l'introduction du tableau) où tous sont du même type, appelé composante ou type de base. Chaque composante peut être explicitement désigné et directement adressé par le nom de la variable du tableau suivi de l'index dit entre crochets. Les index sont calculables : leur type est appelé type d'index. En outre, le temps nécessaire pour sélectionner (accéder) une composante ne dépend pas de la valeur du sélecteur (index) ; alors le tableau est appelé une structure à accès aléatoire.

La définition d'un tableau spécifie à la fois le type de composante et le type d'index. La forme générale est :

type A = array[T1] of T2;

où A est un nouvel identifiant de type ; T1 est le type d'index et est un type scellé (où les types entier et réel ne sont pas des types d'index autorisés) ; et T2 est de n'importe quel type.

Exemples de déclarations de variables - et - exemples d'affectations :



memory : array[0..max] of integer            memory[i+j] := x

sick : array[days] of Boolean                sick[mon] := true

(Bien entendu, ces exemples supposent la définition des identifiants auxiliaires.)




{ trouver le plus grand et le plus petit nombre dans une liste donnée }

 
program minmax(input, output);

const n = 20;

var i,u,v,min,max : integer;

    a : array[1..n] of integer;

begin

   {supposons qu'à ce stade du programme. le tableau a contient les valeurs : 35 68 94 7 88 -5 -3 12 35 9 -6 3 0 -2 74 88 52 43 5 4}

 

   min := a[1]; max := min; i := 2;

   while i < n do

   begin u := a[i]; v := a[i+1];

      if u>v then

      begin  if u>max then max := u;

	         if v<min then min := v

      end else

      begin  if v>max then max := v;

             if v<min then min := u

      end;

      i := i + 2

   end; 

   if i=n then

      if a[n]>max then max := a[n]

      else if a[n]<min then min := a[n];

   writeln (max,min)

end.

on obtiendra le résultat suivant :

94 -6

Étendre le programme précédent pour afficher l'axe des x :



{ étendre le programme précédent pour afficher l'axe des x }

 
program graph2(output);

const d = 0.0625;  {1/16, 16 lignes pour l'intervalle [x,x+1]}

      s = 32;      {32 largeurs de caractères pour l'intervalle [y,y+1]}

      h1 = 34;     {position du caractère sur l'axe des x}

      h2 = 68;     {largeur de ligne}

      c = 6.28318; {2*pi} lim = 32;

var i,j,k,n: integer; x,y: real;

    a : array[1..h2] of char;

begin for j := 1 to h2 do a[j] := ' '; 

   for i := 0 to lim do

   begin x := d*i; y := exp(-x)*sin(c*x);

       a[h1] := ':'; n := round(s*y) + h1; a[n] := '*';

       if n < h1 then k := h1 else k := n;

       for j := 1 to k do write(a[j]);

       writeln; a[n] := ' '

   end

end.

on obtiendra le résultat suivant :

* : * : * : * : * : * : * : * * * : * : * : * : * : * : * : * : * : * : * : * : * : * : * * * : * : * : * : * : * : * : *

(Considérez comment on pourrait étendre le programme précédent pour afficher plus d'une fonction, avec et sans l'utilisation d'un tableau.)

Étant donné que T2 peut être de n'importe quel type, les composants des tableaux peuvent être structurés. En particulier, si T2 est à nouveau un tableau. alors le tableau original A est dit multidimensionnel. Ainsi, la déclaration d'un tableau multidimensionnel M peut être formulée comme ceci :



var M : array[a..b]	 of array[c..d] of T;



M[i][j]

désigne alors la jième composante (de type T) de la ième composante de M.

Pour les tableaux multidimensionnels, il est d'usage de faire les abréviations qui conviennent :



var M : array[a..b,c..d] of T;



M[i,j]

Nous pouvons considérer M comme une matrice et dire que M[i,j] est la jème composante (dans la jème colonne) du ième composante de M (de la ième ligne de M).

Ceci ne se limite pas à deux dimensions, car T peut à nouveau être un type structuré. En général : la forme (abrégée) est :

type <identifiant de type> =
array[<type d'index> {, <type d'index>}] of <type de composante> ;

Si n types d'index sont spécifiés, le tableau est dit n-dimensionnel et un composant est désigné par n expressions d'index.



{ multiplication matricielle }

 
program matrixmul(input, output);

 
const m = 4; p = 3; n = 2;

var i : 1..m ; j : 1..n; k : 1..p;

    s : integer;

    a : array[1..m,1..p] of integer;

    b : array[1..p,1..n] of integer;

    c : array[1..m,1..n] of integer;

begin {attribuer des valeurs initiales à a et b}

   for i := 1 to m do

   begin   for k := 1 to P do

      begin read(s); write(s); a[i,k] := s

      end;

      writeln

   end;

   writeln;

   for k := 1 to p do

   begin for j := 1 to n do

      begin read(s); write(s); b[k,j] := s

      end;

      writeln

   end;

   writeln;

   {multiplier a * b}

   for i := 1 to m do

   begin  for j := 1 to n do

          begin s := 0;

             for k := 1 to p do s := s + a[i,k] * b[k,j];

             c[i,j] := s; write(s)

          end;

          writeln

    end;

	writeln

end.

on obtiendra le résultat suivant :

1 2 3 -2 0 2 1 0 1 -1 2 -3 -1 3 -2 2 2 1 1 10 6 -4 1 4 -9 -2

Les chaînes étaient définies auparavant comme des séquences de caractères entourées entre guillemets simples (Notation et vocabulaire). Les chaînes constituées d'un seul caractère sont les constantes du type standard char (Le concept de données) : celles de n caractères (n>1), sont définies comme des constantes du type défini par :



packed array[1..n] of char

L'affectation (:=) est possible entre des groupes de types de tableaux identiques. Les opérateurs relationnels <>, <, >, <= et >= sont applicables sur les opérandes de tableaux de caractères condensés identiques, où le jeu de caractères sous-jacent détermine l'ordre.

L'accès aux composants individuels des baies emballées est souvent coûteux. et il est conseillé au programmeur de compresser ou de décompresser un tableau compressé en une seule opération. Ceci est possible grâce aux procédures standard d'emballage et de déballage. Soit A une variable de tableau de type :



array[m..n] of T

et Z soit une variable de type :



packed array[u..v] of T

où (n-m) >= (v-u), alors :

pack (A,i,Z) moyens for j := u to v do Z[j] := A[j-u+i] et
unpack (Z,A,i) moyens for j := u to v do A[j-u+i] := Z[j]

où j désigne une variable auxiliaire n'apparaissant pas ailleurs dans le programme.

Dernière mise à jour : Mardi, le 12 Mars 2024

Section courante

A propos

Section administrative du site

Types structurés en général - Le tableau en particulier

Le type de tableau