3.3. Structures cartésiennes complexes

3.3.1. Tableaux multidimensionnés

Déclaration :

type Matrices = array[Ligne] of
               array[Colonne] of To;
(ou : Matrices = array[Ligne,Colonne] of To)

Sélecteur :

var m : Matrices;
m[i][j] ou m[i, j]

Cardinalité :

card(m) =card(To)^{card(Ligne).card(Colonne)}

Déclaration :

type Esp3D:array[Profondeur] of Matrices;
(ou : array [Profondeur, Ligne, Colonne] of To).

Sélecteur :

var e : Espace3D;
e[p] [i] [j] ou e[p] [i, j] ou e[p,i],[j] ou e[p, i, j]

Cardinalité :

card(e)=card(To)^{card(Profondeur).card(Ligne).card(Colonne)}

Le nombre de dimensions d'un tableau n'est, dans la plupart des langages, pas limité !

3.3.2. Tableaux d'enregistrements

Déclaration :

type  Point = record
        X, Y: integer;
        end; { Point }

             Suite = array[1..Max] of Point;  
var S1, S2 : Suite;  

Sélecteur :

1. L'abscisse du premier point de la suite S1: S1[1].X
2. Ecrire tous les points de la deuxième suite dont l'ordonnée est su périeure à 10

   for i := 1 to Max do 
     if S2[i].Y > 10.0 then 
       writeln (S2[i].X, S2[i].Y); 

Cardinalité :

    card(S1) = card(integer)2.Max  

3.3.3. Enregistrement de tableaux

Déclaration :

      const Max = . . . ; 
            AlfaLong = 15; 
      type Alfa = packed array[1..AlfaLong] 
                 of char; 
           Service = (Actif, Reserviste, 
                      Complementaire, Reforme); 
      { Il n'est pas dans les intentions des 
        auteurs d'être sexiste } 
       
      Adulte = record 
        Nom: Alfa; 
        Prenoms: array [1..3] of Alfa; 
        case Sexe:(Feminin,Masculin) of 
          Feminin:(NomDeJeuneFille: Alfa); 
          Masculin:(Incorporation:Service); 
        end; { Adulte } 
      var L1, L2: array[1..Max] of Adulte; 

Sélecteur :

le deuxième prénom de la première personne de la liste L1:

L1[1].Prenoms[2]

Cardinalité :

card(L1) = ( card(char)^4.15. (card(char)¹⁵ + card(Service)) )^Max

N.B. : la cardinalité d'un enregistrement avec variant est égale à :

card. des compos. avant variant . (card.de chaque variante)

On peut de la même manière construire des tableaux d'ensembles et des enregistrements contenant des ensembles.

3.3.4. Les chaînes de caractères

3.3.4.1. Chaînes de longueur fixe

Les chaînes de caractères telles qu'elles sont définies par N. Wirth dans son manuel du Pascal sont disponibles dans la quasi-totalité des implantations du Pascal. Leur déclaration se fait de la manière suivante :

Variable:packed array[intervalle] of char;

L'intervalle spécifié dans la déclaration ci-dessus est généralement de la forme 1..Longueur, mais cela n'est pas obligatoire; n'importe quel intervalle d'entiers est admissible.

Des chaînes constantes sont spécifiées de la manière suivante :

'suite de caractères'

Si l'on désire une apostrophe dans la suite de caractères, il faut en mettre deux qui se suivent, comme dans :

'c''est un exemple'.

Les primitives de manipulation de chaînes de caractères sont les suivantes :

• affectation : VariableChaîne1:= VariableChaîne2;
           VariableChaîne:= ChaîneConstante;

Les chaînes doivent être de même longueur. Certaines implantations admettent que la chaîne constante soit plus courte que la variable à laquelle elle est affectée. La chaîne constante est alors complétée par des blancs en fin de chaîne.

• lecture : elle n'est pas possible en tant qu'opération de base (sauf pour certaines variantes d'implantation). Il faut lire dans un tableau de caractères non compacté puis utiliser la procédure prédéfinie pack.

• écriture : write(VariableChaîne);
         write(ChaîneConstante);

• comparaison : <, >, =, <>. La comparaison se fait sur tous les caractères, entre chaînes de même longueur. Là aussi, si un des opérandes est une chaîne constante plus courte que l'autre opérande, certaines implantations complètent la chaîne par des blancs.

• construction et décomposition : pour pouvoir manipuler individuellement les caractères d'une chaîne, il faut utiliser les procédures prédéfinies pack et unpack. Ces procédures permettent de convertir un simple tableau de caractères en une chaîne de caractères et vice-versa.

3.3.4.2. Chaînes de longueur variable

Cette variante est propre à certaines implantations telles que Pascal UCSD et Turbo Pascal. Elle permet de disposer d'un jeu plus complet de primitives de manipulation et, surtout, de pouvoir faire varier la longueur effective de la chaîne durant l'exécution. La déclaration se fait de la manière suivante :

            string[NbCarMax];
                       ou string; { correspond à string[80] }

NbCarMax indiquant la longueur maximale que pourra avoir la chaîne.

Les chaînes constantes sont spécifiées de la même manière que des chaînes de longueur fixe.

Pour pouvoir déterminer quelle est la longueur effective d'une chaîne de caractères, un attribut de longueur est associé à chaque variable de ce type. De plus, les caractères composant la chaîne sont accessibles individuellement comme pour un tableau de caractères : si S est déclaré de type string, le premier caractère de la chaîne sera stocké en S[1]. Le nombre de caractères effectivement stockés est généralement indiqué par S[0]. L'attribut de longueur doit toujours appartenir à l'intervalle [CHR(0)..CHR(NbCarMax)].

Les primitives de manipulation sont les suivantes :

• affectation : S:=S2; ou S:='suite de caractères'; si la longueur de la chaîne à droite de l'affectation ne dépasse pas la longueur maximale de S. On peut aussi avoir C:=S[i]; ou S[i]:=C; si C est de type CHAR et i une expression donnant un résultat entier positif inférieur ou égal à la longueur réelle de S.
  
• lecture : read(S); on ne peut lire qu'une chaîne par ligne. Si le nombre de caractères disponibles sur la ligne courante est plus grand que la taille maximale de la chaîne, les caractères en trop sont perdus. S'il y a moins de caractères que la chaîne ne peut en contenir, l'attribut de longueur de la chaîne est ajusté en conséquence.
  
• écriture : write(S); ne sont écrits que les caractères correspondant à la longueur réelle de la chaîne.
  
• comparaison : <, >, =, <>. La comparaison tient compte de la longueur réelle des chaînes. Si les longueurs sont différentes, la plus courte est complétée par des blancs. La relation d'ordre correspond à l'ordre alphabétique.
  
• un ensemble de procédures et de fonctions prédéfinies:

  function length(S: string): integer;

  retourne l'ordinal de l'attribut de longueur de la chaîne.

  procedure insert(Insertion: string;
                 VAR Destination: string;
                 Position: integer);

  Insertion doit être un string non-vide; Position doit appartenir à l'intervalle [1..length(Destination)+1]. Après l'insertion, le premier caractère de Insertion se trouvera en Destination[Position].

  procedure delete(VAR S: string;

                 Position, Longueur: integer);

  Position et (Position+Longueur-1) doivent appartenir à l'intervalle [1..length(S)].

  function copy(S: string;

              Position, Longueur: integer): string;

  fournit, en sortie, la partie de S commençant en Position et ayant Longueur caractères. Les restrictions concernant les valeurs de Position et Longueur sont les mêmes que pour DELETE.

  function concat(S1,S2...:string): string;

  peut avoir un nombre variable de paramètres. Fournit, en sortie, la concaténation des différentes chaînes passées en paramètre.

  function pos(SousChaîne,Chaîne: string): integer;

  recherche la sous-chaîne à l'intérieur de la chaîne et indique en quelle position elle commence (0 = pas trouvé).

  procedure str(Valeur: integer; VAR Chaîne: string);

  convertit un entier en chaîne de caractères. La longueur de la chaîne correspondra au minimum nécessaire pour représenter la valeur en question.

Ce modèle de chaînes de caractères de longueur variable comporte certaines inconsistances. Il est en effet à noter que les fonctions COPY et CONCAT ne répondent pas à la syntaxe du Pascal, puisqu'une fonction de l'utilisateur ne peut pas fournir une valeur de retour de type string, ni avoir un nombre variable de paramètres. Tout programme devant être portable devra donc éviter d'utiliser ces deux primitives, puisqu'elles ne peuvent pas être facilement remplacées par des fonctions de l'utilisateur.

Ce modèle comporte aussi certains pièges. Chaque fois que l'on accède à un "string", l'attribut de longueur est contrôlé. Le principal problème que l'on peut rencontrer en utilisant des strings peut seposer si l'on passe un string par référence à une procédure. En effet, lors de la déclaration des paramètres formels, on est obligé de spécifier la longueur maximale du string; or cette longueur peut ne pas coïncider avec la longueur maximale du paramètre réel. D'où un contrôle erroné des indices qui déjoue les mécanismes de sécurité généralement associés au langage Pascal.

Exemple

      type ChaîneCourte = string; 
           ChaîneLongue = string[255]; 
       
      var Chaîne: ChaîneCourte; 
   
      procedure Remplis(VAR S: ChaîneLongue); 
      begin 
        ... 
        S := ...;{ expression fournissant une } 
                 { chaîne de plus de 80 car. } 
        ... 
      end; { Remplis } 

      begin { programme principal } 
        Remplis(Chaîne);{va "écraser" les} 
      end.              {positions mémoires} 
                        {qui sont après Chaîne} 


3.4. Structures paquetées 

Table des matières.

Site Hosting: Bronco