Discussion :

[ludogoal]

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

[Andnotor]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
v1 :Truc;
v2 :byte;
 
v2 := byte(v1);
v1 := truc(v2);

[ShaiLeTroll]

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

[sjrd]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
type
  TSomeInterval = machin2..machin3;

Du coup j'ai changé le titre

[Andnotor]

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.

[guillemouze]

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

[ShaiLeTroll]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

[ludogoal]

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

[ShaiLeTroll]

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[sjrd]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

Ord(High(TypeTruc))+1

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
var
  Truc: TypeTruc;
 
for Truc := Low(TypeTruc) to High(TypeTruc) do
  // ici tu utilises Truc

[Andnotor]

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 .

[ludogoal]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

Ord(High(TypeTruc))+1

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[sjrd]

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 ?

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

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

[droggo]

Qoi,

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Andnotor]

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

[Dr.Who]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);