0 dans l'instruction while

Question

J'ai une question et s'il vous plaît me.I d'aide ont lu la page Web Somthing à propos de faire while, différente est que, alors qu'il est écrit 0, non condition booléenne

do{
   // do some instruction
}while(condition );

est clairement compréhensible, mais celui-ci

 do
  {
    //again some instruction
  }while(0);

Je ne peux pas deviner ce fait-il est-il d'équivalence à ceci:? Faire quelque chose en (faux) ou est peut-être la boucle de l'infini s'il vous plaît aidez-moi

Answer 1

Il fait quelque chose qu'une seule fois. Il est largement utilisé dans les macros aux déclarations du groupe et rendre l'utilisation plus naturelle (c.-à la fin nécessitent virgule).

Tout vaut compilateur son sel doit ignorer le faire .. tout tout à fait et il suffit d'exécuter les instructions ci-jointes.

Answer 2

Bien que cette « boucle » est exécutée juste une fois, on peut l'utiliser de cette façon:

do
{
  // declare some local variables only visible here
  // do something

  if(TestSomeConditions())
      break;

  // do something more
  // destructors of local variables run here automatically
}while(0);

à mon humble avis, dans la plupart des cas, il est préférable de réécrire cela d'une manière plus structurée, soit cette façon

  // do something
  if(!TestSomeConditions())
  {
      // do something more
  }

ou en introduisant une fonction distincte, ce qui reflète la portée d'origine:

  void MyFunction()
  {
      // declare some local variables only visible here
      // do something

      if(TestSomeConditions())
          return;

      // do something more
  }

Answer 3

Il traitera 0 comme faux et une boucle de temps va exécuter et briser le plus tôt atteint pour while (compilateur g ++ testé).

Answer 4

Le faire en boucle exécute toutes les instructions contenues dans le corps de la boucle première et vérifie ensuite l'état. Par conséquent, cette boucle qu'exécuter les instructions du corps de la boucle une fois.

do
{
    //my instructions
}while(0)

est équivalent à l'écriture

{
    //my instructions
}

Les compilateurs modernes sont assez intelligents pour optimiser ces choses!

Answer 5

Sur le plan technique, il fait courir une fois, comme il vérifie (et ne le chèque) après avoir exécuté une fois.

En dehors de cela, il est utilisé dans des macros. Par exemple:

#define blah(a) \
        something(1); \
        something(2)

if(a)
    blah(4);
else
    blah(19);

conduirait à ceci:

...
if(a)
    something(1); something(2);
else
    something(1); something(2);

qui n'est pas une syntaxe valide, comme d'autre ne fait pas partie de l'instruction if plus. Qu'est-ce que vous pouvez faire est:

 define blah(a) \
    do {
       something(1); something(2);
    } while(0)

    ...

qui se traduirait par une déclaration unique dans le bloc si:

if(a)
    do { something(1); something(2); } while(0);
else
    ...