Enuméré et ensemble

Bonjour,
J'ai défini un type:
TypeTruc = (machin1, machin2, machin3, machin4);
et une étendue
Truc = Set of TypeTruc;

Je voudrais faire une méthode qui, à partir d'un entier, me renvoie le Truc rempli correctement (en gros pour que Truc corresponde à un énuméré de type Flags C#). Ma méthode fonctionne mais actuellement je suis obligé de renseigner en dur le nombre de valeur possible de mon TypeTruc (ici 4).
J'aimerais savoir comment faire pour connaitre le nombre de valeur possible de mon TypeTruc???

Merci d'avance

Il suffit de transtyper en byte à l'écriture et en Truc à la lecture:

Code:

---

1 2 3 4 5

v1 :Truc; v2 :byte;   v2 := byte(v1); v1 := truc(v2);

---

la fonction Ord est plus "propre" que le transtypage en Byte mais c'est équivalent !

Et, pour la forme, on appelle ça un type ensemble. Pas un type étendue. Un type étendue c'est ça :

Code:

---

1 2	type TSomeInterval = machin2..machin3;

---

Du coup j'ai changé le titre ;)

Citation:

---

Envoyé par ShaiLeTroll

la fonction Ord est plus "propre" que le transtypage en Byte mais c'est équivalent !

---

Non, ce n'est pas équivalent ;).

ord renvoi l'indice d'un élément TypeTruc mais n'est pas applicable sur l'ensemble Truc qui en contient plusieurs.

petite précision, il faut transtyper truc en

• Byte si TypeTruc contient <= 8 éléments
• Word si TypeTruc contient <= 16 éléments
• Cardinal si TypeTruc contient <= 32 éléments

Citation:

---

Envoyé par Andnotor

Non, ce n'est pas équivalent ;).

ord renvoi l'indice d'un élément TypeTruc mais n'est pas applicable sur l'ensemble Truc qui en contient plusieurs.

---

Oui, j'ai confondu Truc et TypeTruc ... Ord c'est uniquement pour TypeTruc !

Sinon, voir ce sujet Récupérer le 1° élément d'un SET OF
la taille d'un ensemble peut monter à 32 Octets !

tu peux écrire ceci

Code:

---

1 2 3 4 5

Truc: record case Integer of 0: (Flags: set of TypeTruc); 1: (Bin: Byte); end;

---

Pour savoir le nombre de combinaison, rien de plus facile, c'est 2 puissance n
n étant le nombre de valeur dans l'énumération ...
1 = 2
2 = 4
3 = 8
4 = 16
... normalement, tout informaticien connait !

Merci pour vos réponse mais je ne sais pas si j'ai été très clair, en gros je voudrais un moyen de connaitre le nombre de valeurs possible d'un énuméré.

Ah ! On avait pas compris que ta question effectivement était si simple, ben oui, comment pourrait-on penser que tu poses une question sans avoir lu l'aide de Delphi

Citation:

---

Envoyé par Aide

L'étendue d'un type ensemble est l'ensemble puissance d'un type scalaire particulier, appelé le type de base ; c'est à dire que les valeurs possibles du type ensemble sont tous les sous-ensembles du type de base, y compris l'ensemble vide. Le type de base ne peut avoir plus de 256 valeurs possibles et leur rang doit être compris entre 0 et 255.

---

Un Type Enuméré peut avoir autant de valeur que possible (4 milliards ?)
Un Type Enuméré utilisé dans un Ensemble ne peut avoir que 256 valeurs
Un Type Enuméré est un Type Scalaire, tu peux donc utiliser Ord, Succ, Pred, Low et High dessus ! Voir l'aide !

vu que la taille maximale d'un set c'est 32 octets donc 256 bit donc 256 valeurs !

Je pense que tu aurais eu la réponse plus vite en testant, tu aurais créer un type énuméré avec Excel pour incrémenter, en 30 secondes tu aurais trouver la réponse ! Moi c'est ce que j'ai fait quand j'ai voulu tester ma fonction SizeOfSetShai !

Code:

---

1 2 3 4 5

type TValeur = (Valeur1, Valeur2, Valeur3, ..., Valeur280, Valeur281); // Une Enum peut dépassé les 256 éléments;   TValeurs = set of TValeur; // Les ensembles SET ont au plus 256 éléments;

---

Tient une FAQ aussi

Citation:

---

Envoyé par ludogoal

J'aimerais savoir comment faire pour connaitre le nombre de valeur possible de mon TypeTruc???

---

Tu peux avoir la plus grande valeur avec High(TypeTruc). Plus qu'à transtyper, avec Ord(), et +1, et tu as le nombre de valeurs :

Code:

---

Ord(High(TypeTruc))+1

---

Si tu veux faire une boucle sur toutes les valeurs possibles, tu peux faire :

Code:

---

1 2 3 4 5

var Truc: TypeTruc;   for Truc := Low(TypeTruc) to High(TypeTruc) do // ici tu utilises Truc

---

Citation:

---

Envoyé par sjrd

Tu peux avoir la plus grande valeur avec High(TypeTruc). Plus qu'à transtyper, avec Ord(), et +1, et tu as le nombre de valeurs

---

Pour autant que les indices se suivent !

Ceci TypeTruc = (machin1, machin2=10, machin3) donne 12 alors qu'il n'y a que 3 éléments ;).

Citation:

---

Envoyé par sjrd

Tu peux avoir la plus grande valeur avec High(TypeTruc). Plus qu'à transtyper, avec Ord(), et +1, et tu as le nombre de valeurs :

Code:

---

Ord(High(TypeTruc))+1

---

Si tu veux faire une boucle sur toutes les valeurs possibles, tu peux faire :

Code:

---

1 2 3 4 5

var Truc: TypeTruc;   for Truc := Low(TypeTruc) to High(TypeTruc) do // ici tu utilises Truc

---

---

Merci, ça marche parfaitement!!!
Pour les 256 éléments, je préfère ne rien dire...

Citation:

---

Envoyé par Andnotor

Pour autant que les indices se suivent !

Ceci TypeTruc = (machin1, machin2=10, machin3) donne 12 alors qu'il n'y a que 3 éléments ;).

---

Certes, mais combien de fois n'ai-je pas dit qu'il ne fallait surtout pas utiliser cette construction du langage ? ;)

Elle est pourtant bien pratique lorsqu'on veut sauver l'ensemble dans un fichier tout en permettant l'ajout d'éléments en concervant un ordre logique d'écriture ;).

S'il n'y a pas de sauvegarde/chargement, elle n'a en effet aucun intérêt :ccool:.

Qoi,

Citation:

---

Envoyé par Andnotor

Elle est pourtant bien pratique lorsqu'on veut sauver l'ensemble dans un fichier tout en permettant l'ajout d'éléments en concervant un ordre logique d'écriture

---

Peut-être, mais c'est aussi un piège dans lequel il est aisé de tomber.

Pour prendre l'exemple déjà cité :

Code:

---

TypeTruc = (machin1, machin2=10, machin3);

---

Tu pourras utiliser une valeur qui n'existe pas, disons 4, sans que le programme te jette pour utilisation d'une valeur non déclarée, car elle entre dans la gamme des valeurs considérées comme valides, soit 0 à 11 pour cet exemple.
C'est carrément casse gueule, et est donc à éviter, ce qui rejoint ce que dit sjrd. :)

Citation:

---

Envoyé par droggo

...C'est carrément casse gueule, et est donc à éviter, ce qui rejoint ce que dit sjrd. :)

---

Dans ton code, tu feras toujours un test sur Machin1 et non sur TypeTruc(1). C'est casse-gueule uniquement dans le cas de boucle comme cité précédemment ;). Et encore, des tests case ou in n'y verront que du feu !

ps: Je n'ai d'ailleurs pas bien compris la finalité de déterminer le nombre d'éléments utilisables sans savoir ce qu'ils représentent et donc comment ils sont interprétés :roll:.

Citation:

---

Envoyé par sjrd

Certes, mais combien de fois n'ai-je pas dit qu'il ne fallait surtout pas utiliser cette construction du langage ? ;)

---

ça dépend l'utilisation.

c'est comme faire de l'assembleur inline, peu conseillé ... sauf si on sais ce que l'on fait.

c'est utile par exemple pour les flags ou les paramètres que l'on ne veux surtout pas en constante (bien qu'a partir de D2009 on puisse definir des groupes de constantes ce qui est mieux et plus souple).

exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

{$X+} {$ALIGN ON} {$MINENUMSIZE 4} type TFlag = ( fRGB1x = $00, fRGB4x = $01, fRGB8x = $02, fRGB16x = $08, fARGB1x = $20, fARGB4x = $21, fARGB8x = $22, fARGB16x = $28, );   function DropColor(P:Pointer; Flag: TFlag); stdcall;   // appel   DropColor(@B, fARGB16x);

---

et ce je prefere :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

type TFlag = type LongWord;   TFlags = packed record public const RGB1x : TFlag = $00; const RGB4x : TFlag = $01; const RGB8x : TFlag = $02; const RGB16x : TFlag = $08; const ARGB1x : TFlag = $20; const ARGB4x : TFlag = $21; const ARGB8x : TFlag = $22; const ARGB16x : TFlag = $28; end;   function DropColor(p: pointer; Flag: TFlag); stdcall;   // appel DropColor(@B, TFlags.ARGB16x);

---