Cours de Turbo Pascal 7


précédentsommairesuivant

Chapitre 25 - Ensembles

Les ensembles en Pascal sont les mêmes que ceux que vous connaissez en maths. Ils sont donc régis par les mêmes lois et nécessitent les mêmes opérateurs d'inclusion...

Déclarations

Un ensemble est une variable qui contient un nombre fini d'éléments de même type. Ce type doit être de type scalaire et ne pas avoir une taille supérieure à 1 octet. La déclaration d'une telle variable se fait par l'utilisation de la syntaxe Set of.

Syntaxe :

 
Sélectionnez

Type tId = Set of type_de_l_ensemble;
Var Identificateur : tId;
Var id1, id2, id3 : tId;

Exemples :

 
Sélectionnez

Type Aleatoires = Set of Byte;
Var Hasard : Aleatoires;

Ici, la variable Hasard est un ensemble de nombres entiers dont les valeurs possibles sont dans l'intervalle 0..255.

 
Sélectionnez

Type Binaires = Set of 0..1;
Var NbBin : Binaires;

Ici, la variable NbBin est un ensemble de 0 et de 1.

Comme pour tout autre type de variable, on peut déclarer en un seul bloc plusieurs variables "ensemble" du même type.

En général, on cherchera à utiliser des ensembles dont le type sera défini par le programmeur lui-même, c'est-à-dire différent des types de base du Pascal. C'est le cas des types énumérés.

Syntaxe :

 
Sélectionnez

Type MonType = (Element1, Element2, Element3...);
     Ensemble = Set of MonType;

Ou forme plus compacte :

 
Sélectionnez

Type Ensemble = Set of (Element1, Element2, Element3...);

Le type se résume à une liste d'éléments séparés par des virgules à l'intérieur d'une parenthèse comme le montre la syntaxe ci-dessus.

Exemple :

 
Sélectionnez

Type Prenom = (Boris, Hugo, Aurore);
     Club : Set of Prenom;

Ou bien :

 
Sélectionnez

Type Club = Set of (Boris, Hugo, Aurore);

Dans cet exemple, le type Club est un ensemble de type Prenom, c'est-à-dire que cet ensemble nommé Club ne peut contenir que les éléments déclarés dans le type Prenom. Donc une variable de type Club pourra contenir une combinaison de ces trois éléments.

Les ensembles ne sont pas ordonnés. Donc il n'existe pas d'ordre d'apparition des éléments dans une variable ensemble. On est seulement être capable de comparer le contenu de deux ensembles de même type, et de déterminer si un élément est inclus ou non dans un ensemble. De plus, un même élément n'apparaît qu'une seule fois dans un ensemble. Et il n'existe pas de fonction qui renvoie le nombre d'éléments d'un ensemble.

Affectations et opérations

Après avoir vu l'aspect déclaratif des ensembles, on va apprendre à les utiliser dans un programme. L'ensemble, quel que soit son type, peut être un ensemble vide. Pour donner une valeur à un ensemble, c'est-à-dire, spécifier le ou les élément(s) que devra contenir l'ensemble, on utilise l'opérateur habituel d'affectation :=. Ce qu'il y a de nouveau, c'est que le ou les élément(s) doivent être séparés par des virgules (comme dans la déclaration du type) et être entre crochets (contrairement à la déclaration).

Syntaxes :

 
Sélectionnez

Ensemble := [ ]; { ensemble nul }
Ensemble := [ Element ]; { ensemble constitué de l'élément élément }
Ensemble := [ Element5, Element1 ]; { ensemble constitué des éléments Element5 et Element1 }

Rappel : L'ordre des éléments dans une affection ou une comparaison n'a aucune espèce d'importance puisque les ensembles ne sont pas ordonnés.

Une affectation à un ensemble en supprime les éléments qu'il contenait avant l'affectation.

Si, en cours de programme, on souhaite ajouter ou supprimer un ou des élément(s) à l'ensemble, on doit utiliser les opérateurs additif + et soustractif - traditionnels.

Syntaxes :

 
Sélectionnez

Ensemble := Ensemble + [ ];
   { inutile car n'ajoute rien ! }

Ensemble := Ensemble + [ Element4 ];
   { rajoute l'élément Element4 à l'ensemble }
   
Ensemble := Ensemble + [ Element3, Element2 ];
   { rajoute les éléments Elément3 et Elément2}

Ensemble := Ensemble + [ Element1 ] - [ Element7, Element3 ];
   { rajoute l'élément Element1 et supprime les éléments Element7 et Element3 }

Pour être exact, les éléments entre crochets représentent des ensembles à part entière. Ces ensembles sont de même type que la variable ensemble auquel on ajoute ou supprime des sous-ensembles. Cela s'explique par le fait que l'on ne peut additionner que des variables de même type : on ne peut pas additionner éléments et ensemble, mais par contre on peut additionner entre eux des ensembles. Ainsi, un élément entre crochets est un ensemble et plusieurs éléments séparés par des virgules et entre crochets est aussi un ensemble.

Pour employer le vocabulaire mathématique approprié, + est l'opérateur d'union, - est l'opérateur de complément et on peut en rajouter un troisième : * est l'opérateur d'intersection.

Comparaisons

Le seul moyen de connaître le contenu d'un ensemble est de le comparer à d'autres du même type. Ainsi, les tests booléens par l'intermédiaire des opérateurs relationnels (voir chapitre 2) permettent de savoir si tel ou tel élément se trouve dans un ensemble, ou bien si tel ensemble est inclus dans un autre.

Les opérateurs relationnels stricts sont incompatibles avec les ensembles; ainsi, seuls ceux du tableau ci-dessous sont à utiliser avec les ensembles :

Opérateurs relationnels applicables aux ensembles
Symbole Description
= égale
<> différent
<= inclus
>= contient


L'opérateur In permet de connaître la présence ou non d'un élément dans un ensemble sans avoir à passer par l'utilisation des crochets.

Exemples :

 
Sélectionnez

if [Element2] <= Ensemble then ...
   { si l'ensemble constitué de l'élément Element2 est inclus dans l'ensemble Ensemble alors...}

if Element2 in Ensemble then ...
   { si l'élément Element2 appartient à l'ensemble Ensemble alors... }

if Ensemble = [ ] then ...
   { si l'ensemble Ensemble est vide, alors... }

Test := not([Element7, Element4] <= Ensemble);
   { le booléen Test prend la valeur True si l'ensemble constitué des éléments Element7 
     et Element4 n'est pas inclus dans l'ensemble Ensemble et False dans l'autre cas }

if (Ensemble1 * Ensemble2) = [ ] then ...
   { si l'intersection des ensembles Ensemble1 et Ensemble2 est vide, alors... 
     c'est qu'ils n'ont aucun élément en commun malgré qu'ils soient de même type }

if (Ensemble1 - Ensemble2) = [ ] then ...
   { si le complément des ensembles Ensemble1 et Ensemble2 est vide, alors... 
     c'est que Ensemble1 est contenu dans Ensemble2 }

Il est impossible d'utiliser les procédures Write(Ln) et Read(Ln) avec les variables de type ensemble.


précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2001-2013 Hugo Etievant. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.