Quel est le terme pour boucle "while (true)" avec "break" à l'intérieur? [fermé]

Supposons que j'ai une boucle en C ++ ou C # qui va comme ceci:

while( true ) {
    doSomething();
    if( condition() ) {
        break;
    }
    doSomethingElse();
}

Ceci est communément appelé "boucle infinie". Pourtant, il n'est pas techniquement infini - il s'arrêtera une fois le contrôle passé break.

Quel est le terme pour une telle boucle - qui contient une instruction de contrôle de boucle "boucle pour toujours" et "pause" à l'intérieur?

En étudiant CS, ce professeur nous a enseigné qu'il existe des boucles de pré-vérification ( while(cond) {}), des boucles de post-vérification ( do {} while(cond);) et des boucles de vérification intermédiaire . (J'ai peut-être mal traduit cela en anglais, mais vous avez compris.)

C et C ++ n'ont pas ce dernier (ISTR Ada l'ayant, BICBW), donc votre construction est utilisée pour cela en C et C ++.

Le tout premier cours de CS à Stanford ( méthodologie de programmation de Mehran Sahami ) y fait référence en tant que boucle et demie . Et ce n'est pas nécessairement une mauvaise pratique de programmation. Considérez cet exemple sur la collecte des entrées utilisateur (tiré de The Art and Science of Java par Eric Roberts , où Roberts l'appelle également une boucle et demie ):

prompt user and read in the first value
while (value != sentinel) {
    process the data value
    prompt user and read in a new value
}

Et puis la même chose a résolu en utilisant la boucle et une demi- idée pour éviter le code en double:

while (true) {
    prompt user and read in a value
    if (value == sentinel) break;
    process the data value
}

En l'absence d'un nom officiel, je l'appellerais la boucle brisée . L'ambiguïté de ce terme est voulue, car une rupture au milieu d'une boucle est un peu impure, presque comme un goto.

Il n'y a pas de nom définitif. La boucle infinie est, je pense, le terme approprié. Aucune boucle n'est vraiment infinie, mais cela a le potentiel d'être effectivement infini car il est possible que la branche qui contient la rupture ne se produise jamais.

Si vous dites à quelqu'un de "créer une boucle infinie et d'utiliser une pause pour la condition X", il saura ce que vous voulez dire. Si quelqu'un examine votre code et ne dit rien de plus que "Je n'aime pas la boucle infinie que vous avez écrite", vous saurez de quoi ils parlent (sauf si vous en avez plus d'un, bien sûr).

C'est une boucle do-while avec le conditionnel au mauvais endroit.

Je voterais pour "boucle inconditionnelle" , similaire à "saut inconditionnel". Il illustre exactement ce qui se passe (le code boucle inconditionnellement), sans mentir (contrairement à "boucle infinie").

Quel est le terme pour une telle boucle - qui contient une instruction de contrôle de boucle "boucle pour toujours" et "pause" à l'intérieur?

C'est une boucle infinie avec une condition de rupture.

Je serais d'accord avec ammilind en ce que si vous vouliez lui donner un nom spécial, vous pourriez l'appeler une boucle partielle infinie

Sur Rosetta Code, ce modèle particulier est décrit comme une boucle «N plus un demi» . Bien que ce ne soit pas mon terme préféré, ce n'est pas terrible et c'est clairement un modèle qui est utile pour certains types de boucles. (Les alternatives consistent à dupliquer le code avant la condition - potentiellement délicat dans les programmes réels - ou à augmenter la profondeur d'imbrication du code après la condition tout en ajoutant une variable de condition de boucle; ni n'améliore la maintenabilité ou la compréhensibilité du code . La seule raison de rejeter de telles constructions est que si l'on insiste pour que les boucles soient breaklibres.)

Il n'y a pas de terme standard, mais je dirais que c'est une boucle partielle .

Cette boucle est utilisée lorsque vous souhaitez rompre uniquement après avoir exécuté une partie de la boucle une dernière fois (c'est-à-dire une exécution partielle). Il est utilisé lorsque vous ne trouvez pas de situation appropriée où vous voudrez peut-être rompre la boucle entière .

Dans ce cas, vous souhaitez rompre la boucle après au moins doSomething()une dernière exécution .

Je dois être d'accord avec sbi ici - j'aime le terme de boucle de vérification intermédiaire . Ce type de construction était plus populaire lorsque la programmation structurée a commencé à rouler et que de nombreux langages avaient un support syntaxique pour eux.

Cela dit, il est désormais largement connu que les whileboucles sont généralement plus faciles à maintenir, car il est plus facile de raisonner sur les invariants et ils gèrent souvent mieux le cas vide délicat.

Dans votre cas particulier, votre boucle est juste équivalente à

for(; doSomething(), !condition(); doSomethingElse()){}

donc je n'utiliserais la breakversion que si l'une doSomethingou l' autre doSomethingElseimpliquait plusieurs instructions et je préfère ne pas les ranger dans des fonctions séparées comme vous l'avez fait.

Cela dit, si votre boucle est plus compliquée qu'une itération (démarrer, vérifier, incrémenter), vous devriez envisager de la refactoriser en quelque chose de plus simple.

Je suppose que si nous allons essayer de trouver un terme pour cela, peut-être:

Boucle échappable

Je l'appelle ce que c'est, une "boucle tout en vrai".

Voir aussi est tout (vrai) mauvaise pratique de programmation?

Ce n'est pas si mal dans tous les cas. Je me retrouve à écrire ce type de boucles avec certains types d'API. Disons, par exemple, que vous avez un objet boucle et que vous devez vérifier une condition assez profonde, comme ceci:

while (loop
    .getAExecutionModelFactory()
    .getActiveXexecutor()
    .getYCancelModelHandler()
    .getCurrentHandler()
    .isCancelled()) {
        // ... do something with the current Handler ....
        loop = ..... // prepare for next loop
}

Supposons maintenant que chaque méthode getXXX puisse potentiellement retourner null. Il serait alors toujours possible d'écrire une expression booléenne, bien qu'elle soit assez compliquée et illisible. Et puis nous devons refaire presque la même chose pour obtenir l'objet gestionnaire actuel. Dans de tels cas, je trouve plus facile d'écrire une while (true)boucle avec pause et de continuer.