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 !

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

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

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

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