Est « } while (0); » toujours égal à « break;} while (1); »?

Question

J'ai comparé la sortie assembleur de gcc

do{ 

//some code 

}while(0);

avec

do{

//some code

 break; 
}while(1);

La sortie est égale, avec ou sans optimisation, mais ..

Il est toujours de cette façon?

Aucune expérience ne peut prouver les théories, ils ne peuvent montrer qu'ils ont tort

Answer 1

Il y a une légère différence:

do {
  // code
  if ( condition )
    continue;
  // code
  break;
} while(1);

redémarre la boucle quand condition est vrai, alors que dans la version } while(0);, le continue sera équivalent à break.

Si aucun continue est présent, alors ils devraient produire exactement le même code.

Answer 2

Les formes ne sont pas équivalents. Ceci est une boucle infinie:

do {
    continue;
    break;
} while (1);

Ce n'est pas:

do {
    continue;
} while (0);

Answer 3

Modifier Après avoir lu divers commentaires à ce sujet, je dois admettre que cette réponse est fausse. Désolé.

Au lieu de:

do{ 

//some code 

}while(0);

ou

do{

//some code

 break; 
}while(1);

Je voudrais simplement utiliser:

//some code

Je ne suis pas sûr à 100% si vous pouvez le faire en C ++, mais si vous voulez limiter la portée des variables, et qui est la raison pour laquelle vous faites cela, il suffit d'utiliser des accolades par eux-mêmes:

{

 // Some Code

}

Answer 4

Commentaire de Markus m'a fait cette réponse: la différence est lors de l'utilisation de mot-clé continue

.

Dans ce cas:

int _tmain(int argc, _TCHAR* argv[])
{
    int i = 0;
    do {
        ++i;
        _tprintf(_T("Iteration %d\n"), i);
        if (i < 30) continue;
    } while(0);

    return 0;
}

vous obtenez une seule itération, alors que dans ce cas:

int _tmain(int argc, _TCHAR* argv[])
{
    int i = 0;
    do {
        ++i;
        _tprintf(_T("Iteration %d\n"), i);
        if (i < 30) continue;
        break;
    } while(1);

    return 0;
}

vous obtenez 30 itérations . Testé sous VS2008.

Answer 5

Le faire en clauses sont logiquement équivalentes. Si elles sont converties au même code d'octets dépend du compilateur à portée de main. Je suppose que la plupart des compilateurs modernes les traiteront également.

Answer 6

EDIT en fonction de votre commentaire que vous utilisez un certain temps avec breaks afin de pouvoir sortir de la « boucle » lorsque certaines conditions sont remplies.

Si c'est ce que vous essayez d'accomplir:

do
{ 
  // processing step 1
  if( some_condition )
    break;
  // processing step 2
  if( some_condition )
    break;
  // etcetera..
} while(0)

... puis juste briser le code que vous avez dans votre boucle while vers une fonction autonome avec plusieurs retours:

void processing()
{

  // processing step 1
  if( some_condition )
    return;
  // processing step 2
  if( some_condition )
    return;
  // etcetera..
}

int main()
{
  // ...
  processing();
  return 0;
}