Structuration des Données Informatiques

7.3. Utilisation

7.3.1. Parcours

Il est assez courant de devoir appliquer un certain traitement T() à l'ensemble des éléments d'une chaîne (par exemple impression). Cela peut se faire très simplement de la manière suivante :

  var p, Debut: VersElement;
  ...
  p := Debut;
  while p <> nil do begin
    T(p^);
    p := p^.Suivant;
    end; { while }

7.3.2. Recherche d'un élément

La recherche d'un élément ayant une valeur particulière semblerait, au premier abord, ne pas poser plus de problèmes que le simple parcours. Toutefois, si l'on écrit l'algorithme suivant :

  var p, Debut: VersElement;
  ...
  p := Debut;
  while (p <> nil) and (p^.Info <> ValeurRecherchee) do
    p := p^.Suivant;
  if p <> nil then { trouvé } ...

la condition logique de la boucle "while" n'est pas toujours définie. En effet, si p=nil, la structure p^ n'existe pas ! (ce qui est différent d'une variable dont le contenu est indéfini). Dans un tel cas, l'algorithme est en erreur. Pour remédier à cet inconvénient, on peut envisager plusieurs solutions :

utilisation d'un débranchement explicite "GoTo" qui interrompt la répétition

  while p <> nil do
    if p^.Info = ValeurRecherchee then GoTo Trouve
    else p := p^.Suivant;
  { on arrive ici si la valeur cherchée n'a
    pas été trouvée }
  . . .
  Trouve: { on arrive ici si la valeur a
            été trouvée }

Cette solution n'est pas très élégante et peut nécessiter l'utilisation de plusieurs débranchements.

variable booléenne ("flag") enregistrant le fait que la valeur cherchée a été trouvée

  var PasTrouve: boolean;

  PasTrouve := true;
  while (p <> nil) and PasTrouve do
    if p^.Info = ValeurRecherchee then PasTrouve := false
    else p := p^.Suivant;
  if not PasTrouve then . . .

certaines implantations du Pascal assurent explicitement l'évaluation de gauche à droite des expressions logiques et admettent des pragmas permettant d'inhiber les contrôles de validité. Dans de tels cas on peut alors écrire l'algorithme de la manière suivante :
```
  while (p <> nil) and
        {$R-} (p^.Info <> ValeurRecherchee)
        {$R^} do
    p := p^.Suivant;
  if p <> nil then { trouvé } . . .
```
où le pragma {$R-} indique au compilateur de ne pas générer de code pour contrôler la validité des opérations qui suivent et le pragma {$R^} indique au compilateur d'annuler l'effet du pragma {$R-}.

7.4. Anneaux, chaînes bidirectionnelles

Table des matières.