Discussion :

[sapin]

Bonjour,
j'ai remarqué que si je crée le type

Code :

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

1
2
3
4
5
6
7
8
 TValeurPossible=(E0=$00000000
          E1=$00000001,
          E2=$00000002,
          E8=$00000008,
          E64=$00000040,
          E128=$00000080);
 
TValeurs = set of TValeurPossible;

et que je lance la boucle suivante en mode debug

Code :

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

1
2
3
4
5
6
7
8
9
10
  function TCan.WaitForState(EtatsVoulu:TValeurs):TValeurs;
  var
    LocalState:LongWord;
    MesEtatsVoulu: TValeurPossible;
    begin
    for MesEtatsVoulu in EtatVoulu do
    begin
      LocalState:=LocalState or ord(MesEtatsVoulu);
    end;
    blablabla

je parcoure 129fois ma boucle avant de la quitter.
Est ce que une boucle for in n'est pas censé parcourir uniquement mes etats possible (E0,E1,E2,E8,E64 et E128) ?
Lorsque je lance mon debug j'obtient ceci

E0
E1
E2
Horslimite (3)
...
Horslimite(7)
E8
Horslimite(9)
...
Horslimite(63)
E64
Horslimite(65)
...
Horslimite(127)
E128
Je quitte ma boucle.

En d'autre terme, est ce que tous les phases horslimite sont vraiment parcouru par l'ordinateur ? Est ce que je gagne en temps à utilisé cette boucle ?
Merci

[Aka Guymelef]

Euh désolé mais je ne vois pas la corrélation entre ton énumération TValeurPossible et le paramètre EtatsVoulu qui est de type TEtat.

[sapin]

Oui, je me suis trompé en traduisant mon code
Premier post édité.

[Aka Guymelef]

Et quelles valeurs contient la variable EtatsVoulu du coup ?

[sapin]

EtatVoulu doit contenir un ensemble composé d'EtatPossible.
Par exemple EtatVoulu := [E0;E8];

Je sais que ce code fonctionne, mais c'est son excecution qui me surprend.
Je ne suis pas sur du fonctionnement de la boucle for in
Si j'avais ajouté un etat E2000 := 2000 dans EtatPossible, est ce qu'il aurai parcouru 2000 fois la boucle ?

[sjrd]

Cela me paraît assez normal, mais il faut partir du début pour comprendre.
TValeurPossible est une "énumération" avec valeurs, donc en fait c'est un bête entier de type Byte, avec quelques constantes.
Par voie de conséquence, TValeurs est un ensemble de Byte, stocké sur 32 octets, dans lesquels le xème bit vaut 1 ssi la valeur x est dans l'ensemble.

Une boucle for..in sur un ensemble ne peut pas faire mieux que boucler sur toutes les valeurs possibles, et tester à chaque fois si la valeur x est dans l'ensemble. Or, comme c'est un Byte, il doit tester 256 possibilités (en fait seulement 129 puisqu'il sait quand même que la borne supérieure est $80 = 128). Bien entendu, celles qui ne font pas partie du type énuméré seront toujours faux (sauf valeur invalide de l'ensemble).

En ce qui me concerne - mais je sais pertinemment que tous ne sont pas d'accord avec moi -, je déconseille toujours l'utilisation des énumérations avec valeur. Ce ne sont pas de vraies énumérations, d'ailleurs. Utilise plutôt des vraies énumérations et un tableau de correspondance enum -> valeur du flag.

Code :

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

1
2
3
4
5
6
7
8
type
  TValeurPossible = (E0, E1, E2, E8, E64, E128);
  TValuers = set of TValeurPossible;
 
const
  ValeurPossibleToFlag: array[TValeurPossible] of Byte = (
    $00, $01, $02, $08, $40, $80
  );

Et pour ta boucle :

Code :

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

1
2
3
4
for MesEtatsVoulu in EtatVoulu do
begin
  LocalState := LocalState or ValeurPossibleToFlag[MesEtatsVoulu];
end;

PS : utilise les balises [code] et non [quote] pour tes morceaux de code : celles-ci conservent l'indentation et mettent la syntaxe en évidence.

[sapin]

@ sjrd
Merci pour cette réponse, ca confirme ce que je pensé.
Je vais appliquer ta méthode pour gagner en temps de calcul.
J'utiliserai Code à partir de maintenant

@Aka Guymelef
En utilisant le mode debug et en regardant le contenu de ma variable.

[Aka Guymelef]

Merci pour l'info

[sapin]

de rien