Boucle de 0x0000 à 0xFFFF

Question

Je voudrais une boucle qui utilise un UInt16 (ushort) pour parcourir toutes ses valeurs. Cependant, cela ne le fait pas:

for( ushort i = 0; i < UInt16.MaxValue; i++ )
{
    // do something
}

Le problème est que la boucle se fermera quand i == 0xFFFF et non pas & "faire quelque chose &"; Si je change l'instruction 'for' en & Quot; for (ushort i = 0; i & Lt; = UInt16.MaxValue; i ++) & ";,,, alors cela devient une boucle infinie car je ne reçois jamais en 0x10000 car les ushorts vont seulement en 0xFFFF.

Je pouvais faire 'i' un int et le lancer ou l'assigner à une variable ushort dans la boucle.

Des suggestions?

Answer 1

Utiliser une do...while boucle

ushort i = 0;
do
{
    // do something
} while(i++ < UInt16.MaxValue);

Il existe une discussion intéressante sur les boucles de test en haut et en bas ici .

Answer 2

UInt16.MaxValue est évalué à 0xffff , pas 0x10000. Je pense que vous pouvez le faire avec une boucle do / while, comme variante de la réponse de burkhard1979.

ushort i = 0;
do {
   ...
} while (++i != 0);

Answer 3

Vous pouvez simplement remplacer le pour par une boucle do-while.

ushort i = 0;
do
{
i++;
...
} while(i!=UInt16.MaxValue);

Answer 4

cela doit-il être court? pourquoi pas juste

for(int i = 0;i<=0xFFFF;i++)
{
  //do whatever
}

Answer 5

En supposant que votre code soit entaché d'une erreur (le code actuel s'interrompt juste avant que la valeur finale ne soit évaluée. Ce qui suit pourrait vous répondre.

Très simple, comme votre compteur est un entier non signé 16 bits, il ne peut pas avoir de valeur supérieure à 0xffff, cette valeur étant toujours valide, vous devez disposer d’une valeur qui dépasse celle de gardien. Cependant, l'ajout de 1 à 0 en 16 bits ne fait que renvoyer à <=>. Comme suggéré, utilisez une boucle do while (qui n'a pas besoin de valeur de garde) ou utilisez une valeur plus grande pour contenir votre compteur.

ps. L'utilisation de variables 16 bits sur des machines modernes est en réalité moins efficace que l'utilisation de variables 32 bits, car aucun code de dépassement de capacité ne doit être généré.