Developpez.com - Pascal
X

Choisissez d'abord la catégorieensuite la rubrique :

 

CHAPITRE XXV : Ensembles

Par Hugo ETIEVANT

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...

Remarque : L'utilisation des ensembles n'a d'intérêt que pour la programmation des automatismes. Il est fortement probable que la plupart des internautes qui visitent cette page n'aient jamais en s'en servir !

  1. Déclarations
  2. Affectations et opérations
  3. Comparaisons


 

1. 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 ordinal c'est-à-dire qu'il ne doit être ni de type réel, ni de type chaîne de caractères, ni de type enregistrement, ni de type pointeur. Ce type doit être énuméré (voir Type énuméré) et ne doit pas excéder 256 combinaisons possibles. La déclaration d'une telle variable se fait par l'utilisation de la syntaxe Set Of.

Syntaxes :

Var identificateur : Set Of type-de-l'ensemble ;
Var id1, id2, id3 : Set Of type-de-l'ensemble ;

Exemples :

Var hasard : Set Of Byte ; Ici, la variable hasard est un ensemble de nombres entiers et dont les valeurs possibles sont dans l'intervalle 0..255.
Var binaire : Set Of 0..1 ; Ici, la variable binaire est un ensemble de 0 et de 1.

Note : 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. Ce sont des types énumérés.

Syntaxe :

Type type = (élément1, élément2, élément3...) ;
Var ensemble : Set Of type ;

Ou forme plus compacte :

Var ensemble : Set Of (élément1, élément2, élément3...) ;

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-haut.

Exemple :

Type prenom = (Boris, Hugo, Aurore) ;
Var club : Set Of prenom ;

Ou bien :

Var club : Set Of (Boris, Hugo, Aurore) ;

Dans cet exemple, la variable 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 la variable club pourra contenir une combinaison de ces trois éléments.

Ainsi déclaré, le type apparaît comme une constante dont ont peut peut connaître l'index des éléments avec la fonction Ord(). Ici, Ord(Boris)=0, Ord(Hugo)=1 et Ord(Aurore)=2. Le type fonctionne un peu comme la table ASCII... l'index du premier élément étant zéro.

Les ensembles de sont pas ordonnés. Donc il n'existe pas d'ordre d'apparition des éléments dans une variable ensemble. On peut tout juste être capable de comparer le contenu de deux ensembles de même type, et de déterminer si un élément est inclu 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 renvoit le nombre d'éléments d'un ensemble.


 

2. Affectations et opérations

Après avoir vu l'aspect déclaratif des ensembles, on va apprendre à utiliser dans un programme des variables "ensemble". L'ensemble, quelque soit son type peut être un ensemble nul. 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 :

ensemble := [ ] ; { ensemble nul }
ensemble := [ élément ] ; { ensemble constitué de l'élément élément }
ensemble := [ élément5, élément1 ] ; { ensemble constitué des éléments élément5 et élément1 }

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.

Note : Une affection à 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 :

ensemble := ensemble + [ ] ; { inutile car ne joute rien ! } ensemble := ensemble + [ élément4 ] ;
{ rajoute l'élément élément4 à l'ensemble }
ensemble := ensemble + [ élément3, élément2 ] ;
{ rajoute les éléments élément3 et élément2}
ensemble := ensemble + [ élément1 ] - [ élément7, élément3 ] ;
{ rajoute l'élément élément1 et supprime les éléments élément7 et élément3 }

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 crochet 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.


 

3. 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 Opérateurs), permettent de savoir si tel ou tel élément se trouve dans un ensemble, ou bien si tel ensemble est un inclu dans un autre.

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

Les opérateurs relationnels applicables aux ensembles
SymboleDesciption
=égale
<>différent
<=inclu
>=contenant

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.

Syntaxes :

If [élément2] <= ensemble Then ...
{ si l'ensemble constitué de l'élément élément2 est inclu dans l'ensemble ensemble alors... }
If élément2 In ensemble Then ...
{ si l'élément élément2 appartient à l'ensemble ensemble alors... }
If ensemble = [ ] Then ...
{ si l'ensemble ensemble est nul, alors... }
test := Not([élément7, élément4] <= ensemble) ;
{ le bouléen test prend la valeur True si l'ensemble constitué des éléments élément7 et élément4 n'est pas inclu dans l'ensemble ensemble et False dans l'autre cas}
If (ensemble1 * ensemble2) = [ ] Then ...
{ si l'intersection des ensembles ensemble1 et ensemble2 est nulle, alors... c'est qu'ils n'ont aucun élément en commun marlgré qu'ils soient de même type }
If (ensemble1 - ensemble2) = [ ] Then ...
{ si le complément des ensembles ensemble1 et ensemble2 est nul, alors... c'est que ensemble1 est contenu dans ensemble2}

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

Responsables bénévoles de la rubrique Pascal : Gilles Vasseur - Alcatîz -