web-dev-qa-db-fra.com

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

Supposons que j'ai une boucle en C++ ou C # qui ressemble à 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 que le contrôle passera par 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?

terminology
25
sharptooth

En étudiant CS, ce professeur nous a appris qu'il y a boucles de pré-vérification (while(cond) {}), - boucles de post-vérification (do {} while(cond);), et 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++.

24
sbi

Le tout premier cours de CS à Stanford ( Programming Methodology by Mehran Sahami ) se réfère à cela comme une 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 by 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 été résolue en utilisant la boucle et demi pour éviter la duplication de code:

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

Sans nom officiel, je l'appellerais Broken Loop. L'ambiguïté de ce terme est voulue, car une coupure au milieu d'une boucle est un peu impure, presque comme un goto.

10
user281377

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).

8
Bryan Oakley

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

8
Malfist

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

6
tdammers

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 suis d'accord avec ammilind en ce que si vous vouliez lui donner un nom spécial, vous pourriez l'appeler Infinite Partial Loop

5
Ramhound

Sur Rosetta Code, ce modèle particulier est décrit comme une boucle "N plus une moitié". 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; aucune n'améliore la maintenabilité ou la compréhensibilité du code . La seule raison de rejeter de telles constructions est si l'on insiste pour que les boucles soient écrites break- libres.)

5
Donal Fellows

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

Cette boucle est utilisée lorsque vous souhaitez rompre uniquement après exécution d'une partie de la boucle une dernière fois (c'est-à-dire 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 avoir exécuté au moins doSomething() une dernière fois.

4
iammilind

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

Cela dit, il est désormais largement connu que les boucles while 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 version break que si doSomething ou doSomethingElse impliquait plusieurs instructions et je préférais 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.

2
hugomg

Je suppose que si nous essayons de trouver un terme à cela, peut-être:

Boucle échappable

1
LarsTech

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

Voir aussi est-ce que la (vraie) mauvaise pratique de programmation?

0
Bratch

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 boucle while (true) avec break et continue.

0
Ingo