Pourquoi utiliser une boucle infinie?

Une autre affiche a demandé à propos de syntaxe préférée pour les boucles infinies.

Une question de suivi: Pourquoi utilisez-vous des boucles infinies dans votre code? En général, je vois une construction comme ceci:

for (;;) {
  int scoped_variable = getSomeValue();
  if (scoped_variable == some_value) {
    break;
  }
}

Qui vous permet de contourner de ne pas être en mesure de voir la valeur de scoped_variable dans le for ou while clause. Quelles sont les autres utilisations pour "infini" boucles?

Question connexe: stackoverflow.com/questions/224138/infinite-loops-top-or-bottom

OriginalL'auteur Moishe Lettvin | 2008-10-22

  1. 27

    Une boucle comme:

    while (true)
{
    //do something
    if (something else) break;
    //do more
}

    vous permet de sortir de la boucle dans le milieu, plutôt qu'au début (alors que/pour) ou fin (do-while).

    Si vous avez un problème complexe, vous pouvez également utiliser ce style pour rendre le code plus clair.

    FWIW, je préfère aussi "while(true)" ou "while(1)", "for (;;)". Plus facile à lire, de l'OMI.
    Bon exemple d'une construction qui nécessiterait autrement duplication: A; while(autre chose) { B; A; }

    OriginalL'auteur Tony Meyer

  2. 11

    J'utilise une boucle infinie pour le corps de mon contrôle incorporés dans le code, car il est conçu pour fonctionner à jamais une fois qu'il est démarré.

    OriginalL'auteur AShelly

  3. 8

    Des machines à états finis. Ils ne sont pas censés se terminer jusqu'à ce que vous atteindre un état final, à quel point vous break ou return.

    Je ne comprends pas cette. Pourquoi ne pas simplement écrire quelque chose comme, "while (!de la machine.etat == fini) {machine.nextState();}
    Il ne serait pas aussi évident, surtout si vous voulais tester le machine.state variable à un point particulier dans la boucle.

    OriginalL'auteur Ignacio Vazquez-Abrams

  4. 8
    while( 1 )
{
    game->update();
    game->render();
}

    Edit: Qui est, mon application est fondamentalement basée autour d'une boucle infinie, et je ne peux pas être pris la peine de revoir tout juste d'avoir la pureté esthétique de toujours se terminant par une chute de la fin de main().

    Alors, comment voulez-vous quitter?
    Je fais une charge de cleanp et ensuite appeler " exit()'. J'avais besoin de cette énergie propre fonction de fermeture, de toute façon (pour exemple. assert()), et pourquoi avoir deux différentes trajectoires de sortie?

    OriginalL'auteur Menkboy

  5. 4

    C'est un exemple incomplète, car il peut être remaniée avec une fin de test en boucle fermée, sans perte de clarté, la fonction ou la performance.

    int scoped_variable;
do {
    scoped_variable = getSomeValue();
} while (scoped_variable != some_value);

    Les boucles infinies sont le plus souvent utilisés lorsque l'instance de boucle n'est pas ont la résiliation de test dans le haut ou le bas, dans le cas le plus simple. Ceci tend à se produire lorsqu'il y a deux parties de la boucle: le code qui doit s'exécuter à chaque fois, et le code qui doit exécuter uniquement entre chaque itération. Ceci tend à se produire dans des langages tels que C quand vous faites des choses comme la lecture à partir d'un fichier ou du traitement d'une base de données resultset où beaucoup doit être fait de manière explicite. La plupart des langues avec les nouveaux paradigmes de la structure d'un tel code dans le test.

    Êtes-vous sûr que cette variable est toujours dans la portée à l'extérieur du bloc?
    Et pourquoi pas: for (int scoped_variable; (scoped_variable = getSomeValue()) != some_value; ) ; (vide corps de boucle). Qui fonctionne à la fois comme un C99 et un programme en C++ avec GCC/G++ 4.3.1 sur Solaris.
    Édité le fragment de code pour résoudre un problème de délimitation de l'étendue. Que pour(...) la boucle est également légitime, mais qui est un peu inhabituel de(...) et beaucoup de programmeurs serait timide loin de ce que pour cette raison.

    OriginalL'auteur staticsan

  6. 3

    Presque toutes les applications utilisent un infini boucle Principale. 😉

    OriginalL'auteur Gary Willoughby

  7. 3

    Je voudrais envisager d'utiliser une boucle infinie pour programmer le système de guidage d'un missile. 

    while ( true ) { go2Target ( ) ; }

    Du point de vue du guidage des missiles ordinateur, la boucle une fois commencé ne répétez jusqu'à la fin des temps.

    Peut-être les puristes faveur

    while ( ! blown2Bits ( ) ) { go2Target ( ) ; }

    mais alors comment mettre en œuvre la blow2Bits méthode? que faudrait-il dire si blow2Bits renvoyé true?

    OriginalL'auteur emory

  8. 2

    Un exemple est un message de la pompe type de scénario, lorsque vous souhaitez faire une boucle pour toujours traitement des messages qui viennent jusqu'dit d'arrêter. Un autre est que si vous voulez prendre une action périodique, alors vous pourriez écrire une boucle infinie avec un sommeil en elle (même s'il peut être préférable d'utiliser une certaine forme de minuterie pour cela).

    Il peut y avoir quelques autres endroits où la boucle doit effectuer une certaine quantité de travail pour déterminer s'il doit quitter, et il peut être plus propre qu'à utiliser break si cette condition est vraie, plutôt que de définir certaines externe drapeau pour indiquer que la boucle de sortie.

    En général, cependant je pense qu'il est préférable de mettre votre sortie de la condition dans la boucle de déclaration, si possible, plutôt que de la faire à l'infini et de sortie de la boucle à l'aide d'un break déclaration, parce que la sortie de la condition de la boucle est de plus en plus évidents.

    OriginalL'auteur Greg Beech

  9. 1

    Il y a d'autres questions relatives à la si/quand il est ok pour utiliser break dans une boucle. Supposons que nous sommes d'accord qu'il est parfois ok. Dans ces conditions, (heureusement rare) je voudrais utiliser une boucle infinie si il y a un certain nombre de conditions de fin et pas identifiables "primaire" condition d'arrêt.

    Il évite une longue série de disjonctions (ou) et attire également l'attention du lecteur sur le fait qu'il peut (presque certainement), être de ruptures dans la boucle.

    En fin de compte c'est une question de goût.

    OriginalL'auteur Draemon

  10. 1

    Je les utilise pour écrire Linux démons ou des services en boucle jusqu'à tuer /autres résiliation signaux sont reçus.

    OriginalL'auteur Chris Kloberdanz

  11. 1

    Les boucles infinies sont utiles surtout dans le démon/service de processus ou de la boucle principale du jeu. Vous pouvez même obtenir mignon avec eux, par exemple:

    const bool heatDeathOfTheUniverse = false;
do 
{
     //stuff
} while(!heatDeathOfTheUniverse);

    Ils devraient pas être utilisé pour "attendre" pour des choses comme les fils comme il a été suggéré par Fry. Vous pouvez utiliser la méthode Join un objet thread pour ça.

    Toutefois, si vous êtes dans une situation où votre tech lead dit, "les boucles infinies sont verboten & sont multiples méthode/fonction renvoie & pauses", vous pouvez aussi faire des trucs comme ça:

    bool done = false;
while(!done) 
{
    if(done = AreWeDone()) continue; //continue jumps back to start of the loop   
}

    Bien sûr, si vous tech responsable est de vous forcer à faire des choses que vous devriez commencer à chercher un nouvel emploi.

    Pour plus de détails sur le mot-clé voir cette MSDN article.

    OriginalL'auteur orj

  12. 1

    Des serveurs utiliser une boucle while infinie:

    while(true)
{
    //Do something like respond to requests
}

    Ils n'ont pas de fin, sauf si vous fermez votre serveur d'application.

    OriginalL'auteur

  13. 0

    J'ai utilisé pour les utiliser lors de l'attente pour plusieurs threads pour terminer en c#, mais maintenant j'utilise la classe ThreadPool.

    OriginalL'auteur Fry

  14. 0

    Autres que les systèmes embarqués situations les boucles infinies toujours sont vraiment: des

    Repeat
   Something
Until Exit_Condition;

    Mais parfois Exit_Condition n'est pas quelque chose qui peut être évalué à la fin de la boucle. Vous pouvez toujours définir un indicateur, utilisez le drapeau à ignorer le reste de la boucle, puis tester à la fin, mais cela signifie que vous sont le tester au moins deux fois (le code est un peu plus lent) et personnellement je le trouve moins clair.

    Il y a des moments lors de la négociation de la clarté pour la vitesse de sens, mais quelque chose qui ne donne ni la clarté ni la vitesse juste pour être techniquement correct? Sonne comme une mauvaise idée de moi. Tout programmeur compétent sait que while (true) cessation condition est quelque part à l'intérieur de la boucle.

    OriginalL'auteur Loren Pechtel