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 :

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

Exemples :

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.

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 :

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

Ou forme plus compacte :

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 :

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

Ou bien :

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.

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 :

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 :

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.

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 :

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 :

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.