'<' versus '! =' als Bedingung in einer 'for'-Schleife?

Angenommen, Sie haben die folgende forSchleife *:

for (int i = 0; i < 10; ++i) {
    // ...
}

Das könnte man auch so schreiben:

for (int i = 0; i != 10; ++i) {
    // ...
}

Die Endergebnisse sind die gleichen. Gibt es also echte Argumente dafür, eins übereinander zu verwenden? Persönlich benutze ich die erstere, falls iaus irgendeinem Grund etwas schief geht und der Wert 10 übersprungen wird.

_{* Entschuldigen Sie die Verwendung von magischen Zahlen, aber es ist nur ein Beispiel.}

Der Grund, sich für das eine oder andere zu entscheiden, liegt in der Absicht und damit in der besseren Lesbarkeit .

Absicht: Die Schleife sollte so lange laufen, wie sie ikleiner als 10 ist, und nicht so lange, wie sie inicht gleich 10 ist. Auch wenn letzteres in diesem speziellen Fall gleich sein mag, ist es nicht das, was Sie meinen, und sollte es auch nicht so geschrieben werden.

Lesbarkeit: Wenn Sie aufschreiben, was Sie meinen, ist es auch einfacher zu verstehen. Wenn Sie zum Beispiel verwenden i != 10, könnte sich jemand fragen, ob in der Schleife ein Weg igrößer als 10 werden könnte und ob die Schleife fortgesetzt werden sollte die for-Anweisung, aber das bedeutet nicht, dass die Leute es nicht tun und als Ergebnis erwarten die Betreuer es).

Das <Muster ist im Allgemeinen verwendbar, auch wenn das Inkrement nicht genau 1 ist.

Auf diese Weise können Schleifen unabhängig von ihrer tatsächlichen Ausführung auf eine einzige übliche Weise ausgeführt werden.

In C ++ lautet die Empfehlung von Scott Myers in „Effektiveres C ++“ (Punkt 6), immer die zweite zu verwenden, es sei denn, Sie haben einen Grund, dies nicht zu tun, da dies bedeutet, dass Sie für Iterator- und Ganzzahlindizes dieselbe Syntax verwenden, sodass Sie nahtlos zwischen intIterator und Iterator wechseln können ohne Änderung der Syntax.

In anderen Sprachen trifft dies nicht zu, weshalb ich <es wahrscheinlich vorziehen würde, weil Thorbjørn Ravn Andersen das so meint.

By the way, neulich war ich Rücksprache mit einem anderen Entwickler und er sagte , der Grund zu bevorzugen <über !=, weil inicht versehentlich um mehr als eins erhöhen, und das könnte die Abbruchbedingung verursacht nicht erfüllt werden; Das ist meiner Meinung nach eine Menge Unsinn.

Die Verwendung von (i <10) ist meiner Meinung nach sicherer. Es wird die maximale Anzahl möglicher Beendigungsfälle abgefangen - alles, was größer oder gleich 10 ist. Vergleichen Sie dies mit dem anderen Fall (i! = 10); es fängt nur einen möglichen Abbruchfall auf - wenn ich genau 10 bin.

Ein Nebenprodukt davon ist, dass es die Lesbarkeit verbessert. Sollte das Inkrement etwas anderes 1 sein, kann dies außerdem dazu beitragen, die Wahrscheinlichkeit eines Problems zu minimieren, falls wir beim Schreiben des Beendigungsfalls einen Fehler machen.

Erwägen:

1) for (i = 1; i < 14; i+=2)

2) for (i = 1; i != 14; i+=2)

Obwohl beide Fälle wahrscheinlich fehlerhaft / falsch sind, ist der zweite wahrscheinlich MEHR falsch, da er nicht beendet wird. Der erste Fall wird beendet und es besteht eine höhere Wahrscheinlichkeit, dass er an der richtigen Stelle beendet wird, obwohl 14 wahrscheinlich die falsche Zahl ist (15 wäre wahrscheinlich besser).

Hier ist eine weitere Antwort, die noch niemand gefunden zu haben scheint. forSchleifen sollten verwendet werden, wenn Sie eine Sequenz durchlaufen müssen . Verwenden !=ist die präziseste Methode, um die Abschlussbedingung für die Schleife anzugeben. Die Verwendung eines weniger restriktiven Operators ist jedoch eine sehr verbreitete Defensiv-Programmiersprache. Für ganze Zahlen spielt es keine Rolle - es ist nur eine persönliche Wahl ohne ein spezifischeres Beispiel. Durchlaufen Sie Sammlungen mit Iteratoren, die Sie !=aus den von anderen angegebenen Gründen verwenden möchten . Wenn Sie Sequenzen von floatoder berücksichtigen double, dann möchten Sie dies unbedingt vermeiden !=.

Was ich darauf hinweisen wollte, ist, dass fores verwendet wird, wenn Sie über eine Sequenz iterieren müssen. Die generierte Sequenz hat einen Startpunkt, ein Intervall und eine Abbruchbedingung. Diese sind in der forErklärung kurz angegeben. Wenn Sie feststellen, dass Sie entweder (1) den Step-Teil von foroder (2) so etwas wie truedie Guard-Bedingung nicht angeben, sollten Sie keine forSchleife verwenden!

Die whileSchleife wird verwendet, um die Verarbeitung fortzusetzen, solange eine bestimmte Bedingung erfüllt ist. Wenn Sie keine Sequenz verarbeiten, möchten Sie wahrscheinlich whilestattdessen eine Schleife. Die Argumente für die Schutzbedingung sind hier ähnlich, aber die Entscheidung zwischen a whileund einer forSchleife sollte sehr bewusst sein. Die whileSchleife wird in C ++ - Kreisen IMO unterschätzt.

Wenn Sie eine Sammlung von Elementen verarbeiten (eine sehr häufige forVerwendung von Schleifen), sollten Sie wirklich eine spezialisiertere Methode verwenden. Leider std::for_eachist in C ++ aus mehreren Gründen ziemlich schmerzhaft. In vielen Fällen führt das Trennen des Körpers einer forSchleife in einer freistehenden Funktion (obwohl dies etwas schmerzhaft ist) zu einer viel saubereren Lösung. Wenn sie mit Sammlungen arbeiten, betrachten std::for_each, std::transformoder std::accumulate. Die Implementierung vieler Algorithmen wird auf diese Weise präzise und kristallklar. Ganz zu schweigen davon, dass Sie sich beim Isolieren des Schleifenkörpers in eine separate Funktion / Methode auf den Algorithmus, seine Eingabeanforderungen und Ergebnisse konzentrieren müssen.

Wenn Sie Java, Python, Ruby oder sogar C ++ 0x verwenden , sollten Sie eine geeignete Auflistung für jede Schleife verwenden. Wenn C ++ - Compiler diese Funktion implementieren, forverschwinden eine Reihe von Schleifen sowie diese Art von Diskussionen.

Wenn Sie "weniger als" verwenden, ist dies (normalerweise) semantisch korrekt. Sie meinen also, dass Sie bis zu i10 zählen müssen, damit "weniger als" Ihre Absichten klar zum Ausdruck bringt. Die Verwendung von "ungleich" funktioniert offensichtlich in Fällen virtueller Anrufe, vermittelt jedoch eine etwas andere Bedeutung. In einigen Fällen ist dies vielleicht das, was Sie brauchen, aber meiner Erfahrung nach war dies nie der Fall. Wenn Sie wirklich einen Fall igehabt hätten, in dem möglicherweise mehr oder weniger als 10 vorliegen, Sie aber eine Schleife ausführen möchten, bis der Wert 10 erreicht ist, müsste dieser Code wirklich sehr deutlich kommentiert werden und könnte wahrscheinlich besser mit einem anderen Konstrukt wie z als whileSchleife vielleicht.

Ein Grund, warum ich a less thangegenüber a favorisieren würde, not equalsist, als Wache zu fungieren. Unter bestimmten Umständen (schlechte Programmierung oder Desinfektion) kann das not equalsübersprungen werden, obwohl less thanes immer noch gültig ist .

Hier ist ein Beispiel, in dem das Fehlen einer Desinfektionsprüfung zu merkwürdigen Ergebnissen geführt hat: http://www.michaeleisen.org/blog/?p=358

Hier ist ein Grund, warum Sie vielleicht lieber verwenden <als !=. Wenn Sie eine Sprache mit globalem Variablenumfang verwenden, was passiert, wenn anderer Code geändert wird i? Wenn Sie verwenden , <anstatt !=, passiert das Schlimmste, ist , dass die Iteration beendet schneller: vielleicht einige andere Code - Schritten idurch Zufall, und Sie ein paar Iterationen in der for - Schleife überspringen. Aber was passiert, wenn Sie eine Schleife von 0 bis 10 durchführen und die Schleife auf 9 wechselt und einige falsch geschriebene Thread-Inkremente iaus irgendeinem seltsamen Grund. Dann beendet Ihre Schleife diese Iteration und erhöht sie, iso dass der Wert jetzt 11 ist. Da die Schleife die Ausgangsbedingung ( inie gleich 10) übersprungen hat , wird sie nun eine Endlosschleife ausführen.

Es muss nicht unbedingt eine besonders ausgeflippte Logik vom Typ Threading und globale Variablen sein, die dies verursacht. Möglicherweise schreiben Sie gerade eine Schleife, die zurückverfolgt werden muss. Wenn Sie iinnerhalb der Schleife mutieren und Ihre Logik durcheinander bringen, !=ist es weniger wahrscheinlich, dass Sie sich in einer Endlosschleife befinden , wenn Sie eine Obergrenze anstelle von a haben .

In der Embedded-Welt, insbesondere in lauten Umgebungen, können Sie sich nicht darauf verlassen, dass der Arbeitsspeicher ordnungsgemäß funktioniert. In einer Bedingung (für, während, wenn), in der Sie mit '==' oder '! =' Vergleichen, laufen Sie immer Gefahr, dass Ihre Variablen den entscheidenden Wert überspringen, der die Schleife beendet - dies kann katastrophale Folgen haben - Mars Lander Level Konsequenzen. Die Verwendung von "<" oder ">" in der Bedingung bietet eine zusätzliche Sicherheitsstufe, um die "unbekannten Unbekannten" abzufangen.

Im ursprünglichen Beispiel iwürde der Vergleich '<' den Fehler sofort abfangen und die Schleife verlassen , wenn er aus unerklärlichen Gründen auf einen Wert größer als 10 katapultiert würde, aber '! =' Würde weiter hochzählen, bis er ium die 0 herum und zurück gewickelt ist bis 10.