Sollte man <oder <= in einer for-Schleife verwenden [geschlossen]

124

Wenn Sie eine Schleife sieben Mal durchlaufen müssten, würden Sie Folgendes verwenden:

for (int i = 0; i < 7; i++)

oder:

for (int i = 0; i <= 6; i++)

Es gibt zwei Überlegungen:

  • Performance
  • Lesbarkeit

Für die Leistung gehe ich von Java oder C # aus. Ist es wichtig, ob "kleiner als" oder "kleiner als oder gleich" verwendet wird? Wenn Sie Einblick in eine andere Sprache haben, geben Sie bitte an, welche.

Zur besseren Lesbarkeit gehe ich von 0-basierten Arrays aus.

UPD: Meine Erwähnung von 0-basierten Arrays hat die Dinge möglicherweise verwirrt. Ich spreche nicht über das Durchlaufen von Array-Elementen. Nur eine allgemeine Schleife.

Es gibt unten einen guten Punkt über die Verwendung einer Konstante, die erklären würde, was diese magische Zahl ist. Wenn ich also " int NUMBER_OF_THINGS = 7" dann " i <= NUMBER_OF_THINGS - 1" hätte, würde es komisch aussehen, nicht wahr?

Eugene Katz
quelle
Ich würde sagen: Wenn Sie durch das gesamte Array laufen, subtrahieren oder addieren Sie niemals eine Zahl auf der linken Seite.
Letterman

Antworten:

287

Der erste ist idiomatischer . Insbesondere gibt es (in einem 0-basierten Sinne) die Anzahl der Iterationen an. Wenn ich etwas 1-basiertes (z. B. JDBC, IIRC) verwende, könnte ich versucht sein, <= zu verwenden. So:

for (int i=0; i < count; i++) // For 0-based APIs

for (int i=1; i <= count; i++) // For 1-based APIs

Ich würde erwarten, dass der Leistungsunterschied im realen Code unbedeutend gering ist.

Jon Skeet
quelle
30
Sie sind fast garantiert, dass es keinen Leistungsunterschied gibt. Viele Architekturen, wie x86, haben Anweisungen zum Springen auf weniger als oder gleich im letzten Vergleich. Die wahrscheinlichste Art, wie Sie einen Leistungsunterschied feststellen würden, wäre eine interpretierte Sprache, die schlecht implementiert wurde.
Wedge
3
Würden Sie stattdessen! = Verwenden? Ich würde sagen, dass dies i am deutlichsten als Schleifenzähler und sonst nichts etabliert.
Yungchin
21
Ich würde normalerweise nicht. Es ist einfach zu ungewohnt. Es besteht auch die Gefahr, in eine sehr, sehr lange Schleife zu geraten, wenn jemand während der Schleife versehentlich i erhöht.
Jon Skeet
5
Generische Programmierung mit STL-Iteratoren erfordert die Verwendung von! =. Es (versehentliches doppeltes Inkrementieren) war für mich kein Problem. Ich stimme zu, dass für Indizes <(oder> für absteigend) klarer und konventioneller sind.
Jonathan Graehl
2
Denken Sie daran, wenn Sie die Länge eines Arrays mit <durchlaufen, optimiert die JIT den Array-Zugriff (entfernt gebundene Prüfungen). Es sollte also schneller sein als mit <=. Ich habe es aber nicht überprüft
Konfigurator
72

Beide Schleifen werden sieben Mal wiederholt. Ich würde sagen, der eine mit einer 7 ist besser lesbar / klarer, es sei denn, Sie haben einen wirklich guten Grund für den anderen.

Steve Losh
quelle
Ich erinnere mich, als ich anfing, Java zu lernen. Ich hasste das Konzept eines 0-basierten Index, weil ich immer 1-basierte Indizes verwendet habe. Ich würde also immer die Variante <= 6 verwenden (wie in der Frage gezeigt). Zu meinem eigenen Nachteil, weil es mich irgendwann mehr verwirren würde, wenn die for-Schleife tatsächlich beendet wird. Es ist einfacher, nur die <
James Haug
55

Ich erinnere mich an meine Tage, als wir 8086 Assembly am College machten, war es performanter:

for (int i = 6; i > -1; i--)

da es eine JNS- Operation gab, die Jump if No Sign bedeutet. Dies bedeutete, dass nach jedem Zyklus keine Speichersuche durchgeführt wurde, um den Vergleichswert zu erhalten, und auch kein Vergleich. Heutzutage optimieren die meisten Compiler die Registernutzung, sodass die Speichersache nicht mehr wichtig ist, Sie aber dennoch einen nicht benötigten Vergleich erhalten.

Übrigens führt das Einfügen von 7 oder 6 in Ihre Schleife eine " magische Zahl " ein. Zur besseren Lesbarkeit sollten Sie eine Konstante mit einem absichtlichen Namen verwenden. So was:

const int NUMBER_OF_CARS = 7;
for (int i = 0; i < NUMBER_OF_CARS; i++)

EDIT: Die Leute bekommen die Montagesache nicht, daher ist offensichtlich ein vollständigeres Beispiel erforderlich:

Wenn wir für (i = 0; i <= 10; i ++) tun, müssen Sie dies tun:

    mov esi, 0
loopStartLabel:
                ; Do some stuff
    inc esi
                ; Note cmp command on next line
    cmp esi, 10
    jle exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

Wenn wir für (int i = 10; i> -1; i--) tun, können Sie damit durchkommen:

    mov esi, 10
loopStartLabel:
                ; Do some stuff
    dec esi
                ; Note no cmp command on next line
    jns exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

Ich habe es gerade überprüft und der C ++ - Compiler von Microsoft führt diese Optimierung nicht durch, aber wenn Sie Folgendes tun:

for (int i = 10; i >= 0; i--) 

Die Moral lautet also: Wenn Sie Microsoft C ++ † verwenden und das Auf- oder Absteigen keinen Unterschied macht, sollten Sie Folgendes verwenden, um eine schnelle Schleife zu erhalten:

for (int i = 10; i >= 0; i--)

eher als eines von diesen:

for (int i = 10; i > -1; i--)
for (int i = 0; i <= 10; i++)

Offen gesagt ist es jedoch weitaus wichtiger, die Lesbarkeit von "for (int i = 0; i <= 10; i ++)" zu erhalten, als einen Prozessorbefehl zu verpassen.

† Andere Compiler können andere Dinge tun.

Martin Brown
quelle
4
Der Fall "magische Zahl" zeigt deutlich, warum es normalerweise besser ist, <als <= zu verwenden.
Rene Saarsoo
11
Eine andere Version ist "für (int i = 10; i--;)". Einige Leute benutzen "für (int i = 10; i -> 0;)" und tun so, als ob die Kombination -> Mittel zu geht.
Zayenz
2
+1 für den Assembler-Code
Neuro
1
Wenn es jedoch an der Zeit ist, den Schleifenzähler tatsächlich zu verwenden, z. B. für die Array-Indizierung, müssen Sie 7-ialle Optimierungen überfluten, die Sie durch das Rückwärtszählen erhalten.
Lie Ryan
@Lie, dies gilt nur, wenn Sie die Artikel in Vorwärtsreihenfolge bearbeiten müssen. Bei den meisten Operationen in dieser Art von Schleifen können Sie sie in beliebiger Reihenfolge auf die Elemente in der Schleife anwenden. Wenn Sie beispielsweise nach einem Wert suchen, spielt es keine Rolle, ob Sie am Ende der Liste beginnen und nach oben oder am Anfang der Liste arbeiten und nach unten arbeiten (vorausgesetzt, Sie können nicht vorhersagen, welches Ende der Liste Ihr Element ist gerne sein und Speicher-Caching ist kein Problem).
Martin Brown
27

Ich verwende immer <array.length, weil es einfacher zu lesen ist als <= array.length-1.

Wenn Sie auch <7 haben und wissen, dass es mit einem 0-Index beginnt, sollte es intuitiv sein, dass die Anzahl die Anzahl der Iterationen ist.

Omar Kooheji
quelle
Sie sollten immer darauf achten, die Kosten für Längenfunktionen zu überprüfen, wenn Sie diese in einer Schleife verwenden. Wenn Sie beispielsweise strlen in C / C ++ verwenden, erhöhen Sie die Zeit für den Vergleich massiv. Dies liegt daran, dass strlen den gesamten String iterieren muss, um seine Antwort zu finden. Dies möchten Sie wahrscheinlich nur einmal und nicht für jede Iteration Ihrer Schleife tun.
Martin Brown
2
@ Martin Brown: In Java (und ich glaube C #) sind String.length und Array.length konstant, da String unveränderlich ist und Array eine unveränderliche Länge hat. Und da String.length und Array.length ein Feld sind (anstelle eines Funktionsaufrufs), können Sie sicher sein, dass sie O (1) sein müssen. Warum zum Teufel verwenden Sie im Fall von C ++ überhaupt C-String?
Lie Ryan
18

Unter optimierenden Gesichtspunkten spielt es keine Rolle.

Aus der Sicht des Codestils bevorzuge ich <. Grund:

for ( int i = 0; i < array.size(); i++ )

ist so viel lesbarer als

for ( int i = 0; i <= array.size() -1; i++ )

Außerdem gibt <Ihnen sofort die Anzahl der Iterationen an.

Eine weitere Abstimmung für <ist, dass Sie möglicherweise viele versehentliche Fehler nacheinander verhindern.

erlando
quelle
10

@Chris, Ihre Aussage, dass .Length in .NET teuer ist, ist eigentlich falsch und bei einfachen Typen genau das Gegenteil.

int len = somearray.Length;
for(i = 0; i < len; i++)
{
  somearray[i].something();
}

ist eigentlich langsamer als

for(i = 0; i < somearray.Length; i++)
{
  somearray[i].something();
}

Letzteres ist ein Fall, der durch die Laufzeit optimiert wird. Da die Laufzeit garantieren kann, dass i ein gültiger Index für das Array ist, werden keine Grenzüberprüfungen durchgeführt. Im ersteren Fall kann die Laufzeit nicht garantieren, dass ich vor der Schleife nicht geändert wurde, und erzwingt bei jeder Indexsuche Grenzprüfungen für das Array.

Jeff Mc
quelle
In Java kann .Length in einigen Fällen teuer sein. stackoverflow.com/questions/6093537/for-loop-optimization b'coz ruft es zu .lenghtOR auf .size. Ich bin mir nicht sicher, aber nicht sicher, aber ich möchte nur sicher gehen.
Ravi Parekh
6

Es macht keinen effektiven Unterschied, wenn es um Leistung geht. Daher würde ich verwenden, was im Kontext des von Ihnen gelösten Problems leichter zu verstehen ist.

Phil Wright
quelle
5

Ich bevorzuge:

for (int i = 0; i < 7; i++)

Ich denke, das lässt sich leichter in "7-maliges Durchlaufen einer Schleife" übersetzen.

Ich bin mir nicht sicher über die Auswirkungen auf die Leistung - ich vermute, dass Unterschiede weg kompiliert werden.

Dominic Rodger
quelle
4

In Java 1.5 können Sie dies einfach tun

for (int i: myArray) {
    ...
}

Für den Array-Fall brauchen Sie sich also keine Sorgen zu machen.

JesperE
quelle
4

Ich glaube nicht, dass es einen Leistungsunterschied gibt. Die zweite Form ist definitiv besser lesbar. Sie müssen keine mental subtrahieren, um die letzte Iterationsnummer zu finden.

EDIT: Ich sehe andere nicht einverstanden. Für mich persönlich möchte ich die tatsächlichen Indexnummern in der Schleifenstruktur sehen. Vielleicht liegt es daran, dass es eher an Perls 0..6Syntax erinnert, von der ich weiß, dass sie gleichbedeutend ist (0,1,2,3,4,5,6). Wenn ich eine 7 sehe, muss ich den Operator daneben überprüfen, um festzustellen, dass der Index 7 tatsächlich nie erreicht wird.

Adam Bellaire
quelle
Es hängt davon ab, ob Sie der Meinung sind, dass "letzte Iterationsnummer" wichtiger ist als "Anzahl der Iterationen". Mit einer 0-basierten API unterscheiden sie sich immer um 1 ...
Jon Skeet
4

Ich würde sagen, verwenden Sie die "<7" -Version, da dies die Mehrheit der Leute liest. Wenn also Leute Ihren Code überfliegen, interpretieren sie ihn möglicherweise falsch.

Ich würde mir keine Sorgen machen, ob "<" schneller als "<=" ist, sondern nur die Lesbarkeit verbessern.

Wenn Sie eine Geschwindigkeitssteigerung anstreben, sollten Sie Folgendes berücksichtigen:

for (int i = 0; i < this->GetCount(); i++)
{
  // Do something
}

Um die Leistung zu steigern, können Sie sie leicht neu anordnen auf:

const int count = this->GetCount();
for (int i = 0; i < count; ++i)
{
  // Do something
}

Beachten Sie das Entfernen von GetCount () aus der Schleife (da dies in jeder Schleife abgefragt wird) und die Änderung von "i ++" in "++ i".

Mark Ingram
quelle
Ich mag das zweite besser, weil es einfacher zu lesen ist, aber berechnet es das this-> GetCount () wirklich jedes Mal neu? Ich bin davon überrascht worden, als ich das geändert habe, und die Anzahl bleibt gleich, was mich dazu zwingt, ein Do zu machen ... während dies-> GetCount ()
osp70
GetCount () wird im ersten Beispiel bei jeder Iteration aufgerufen. Im zweiten Beispiel würde es nur einmal aufgerufen. Wenn Sie benötigen GetCount () , um es aufgerufen wird jedes Mal dann in der Schleife, wenn Sie es nicht versuchen , außerhalb zu halten.
Mark Ingram
Ja, ich habe es ausprobiert und Sie haben Recht, ich entschuldige mich.
osp70
Welchen Unterschied macht es, ++ i gegenüber i ++ zu verwenden?
Rene Saarsoo
Eine geringfügige Geschwindigkeitssteigerung bei Verwendung von Ints, aber die Erhöhung könnte größer sein, wenn Sie Ihre eigenen Klassen erhöhen. Grundsätzlich erhöht ++ i den tatsächlichen Wert und gibt dann den tatsächlichen Wert zurück. i ++ erstellt eine temporäre Variable, erhöht die echte Variable und gibt dann die temporäre Variable zurück. Mit ++ i ist keine var-Erstellung erforderlich.
Mark Ingram
4

In C ++ bevorzuge ich die Verwendung !=, die mit allen STL-Containern verwendet werden kann. Nicht alle STL-Container-Iteratoren sind weniger als vergleichbar.

verrückt
quelle
Dies macht mir ein wenig Angst, nur weil es eine sehr geringe äußere Wahrscheinlichkeit gibt, dass etwas den Zähler über meinen beabsichtigten Wert iteriert, was dies dann zu einer Endlosschleife macht. Die Chancen sind gering und leicht zu erkennen - aber das < fühlt sich sicherer an.
Rob Allen
2
Wenn es einen solchen Fehler in Ihrem Code gibt, ist es wahrscheinlich besser, abzustürzen und zu brennen, als still weiterzumachen :-)
Dies ist die richtige Antwort: Es stellt weniger Anforderungen an Ihren Iterator und es ist wahrscheinlicher, dass er angezeigt wird, wenn ein Fehler in Ihrem Code vorliegt. Das Argument für <ist kurzsichtig. Vielleicht wäre eine Endlosschleife in den 70ern schlecht gewesen, als Sie für die CPU-Zeit bezahlt haben. '! =' ist weniger wahrscheinlich, einen Fehler zu verbergen.
David Nehme
1
Das Schleifen über Iteratoren ist ein völlig anderer Fall als das Schleifen mit einem Zähler. ! = ist für Iteratoren unerlässlich.
DJClayworth
4

Edsger Dijkstra schrieb 1982 einen Artikel darüber, in dem er sich für das untere <= i <obere aussprach:

Es gibt eine kleinste natürliche Zahl. Der Ausschluss der Untergrenze - wie in b) und d) - erzwingt für eine Teilfolge beginnend mit der kleinsten natürlichen Zahl die Untergrenze, wie im Bereich der unnatürlichen Zahlen erwähnt. Das ist hässlich, deshalb bevorzugen wir für die Untergrenze die ≤ wie in a) und c). Betrachten Sie nun die Teilsequenzen, die bei der kleinsten natürlichen Zahl beginnen: Die Einbeziehung der Obergrenze würde diese dann zwingen, unnatürlich zu sein, wenn die Sequenz auf die leere geschrumpft ist. Das ist hässlich, also bevorzugen wir für die Obergrenze <wie in a) und d). Wir schließen daraus, dass Konvention a) vorzuziehen ist.

Martijn
quelle
3

Verwenden Sie zuerst nicht 6 oder 7.

Besser zu verwenden:

int numberOfDays = 7;
for (int day = 0; day < numberOfDays ; day++){

}

In diesem Fall ist es besser als zu verwenden

for (int day = 0; day <= numberOfDays  - 1; day++){

}

Noch besser (Java / C #):

for(int day = 0; day < dayArray.Length; i++){

}

Und noch besser (C #)

foreach (int day in days){// day : days in Java

}

Die Rückwärtsschleife ist zwar schneller, aber da sie schwerer zu lesen ist (wenn nicht von anderen Programmierern), ist es besser, sie zu vermeiden. Insbesondere in C #, Java ...

Carra
quelle
2

Ich stimme der Menge zu, die sagt, dass die 7 in diesem Fall sinnvoll ist, aber ich möchte hinzufügen, dass Sie in dem Fall, in dem die 6 wichtig ist, klarstellen möchten, dass Sie nur auf Objekte bis zum 6. Index und dann auf den 6. Index einwirken <= ist besser, da es die 6 leichter zu sehen macht.

tloach
quelle
Also, i <Größe im Vergleich zu i <= LAST_FILLED_ARRAY_SLOT
Chris Cudmore
2

Ich erinnere mich, dass diese beiden Operationen in der Rechenzeit auf der CPU ähnlich waren. Natürlich reden wir auf Montageebene.

Wenn Sie jedoch von C # oder Java sprechen, glaube ich wirklich nicht, dass einer die Geschwindigkeit gegenüber dem anderen steigern wird. Die wenigen Nanosekunden, die Sie gewinnen, sind höchstwahrscheinlich keine Verwirrung wert, die Sie einführen.

Persönlich würde ich den Code verfassen, der vom Standpunkt der Geschäftsimplementierung aus sinnvoll ist, und sicherstellen, dass er leicht zu lesen ist.

casademora
quelle
2

Dies fällt direkt unter die Kategorie "Falschen Code falsch aussehen lassen" .

In auf Null basierenden Indexierungssprachen wie Java oder C # sind Benutzer an Variationen der index < countBedingung gewöhnt . Die Nutzung dieser Defacto-Konvention würde also Fehler nacheinander offensichtlicher machen.

In Bezug auf die Leistung: Jeder gute Compiler, der seinen Speicherbedarf wert ist, sollte beispielsweise kein Problem darstellen.

Ryan Delucchi
quelle
2

Nebenbei bemerkt, wenn ich ein Array oder eine andere Sammlung in .Net durchlaufe, finde ich

foreach (string item in myarray)
{
    System.Console.WriteLine(item);
}

besser lesbar sein als die numerische for-Schleife. Dies setzt natürlich voraus, dass der tatsächliche Zähler Int selbst nicht im Schleifencode verwendet wird. Ich weiß nicht, ob es eine Leistungsänderung gibt.

Rob Allen
quelle
Dies erfordert auch, dass Sie die Sammlungsgröße während der Schleife nicht ändern.
Jeff B
So würde For (i = 0, i <myarray.count, i ++)
Rob Allen
1

Es gibt viele gute Gründe, i <7 zu schreiben. Es ist gut, die Nummer 7 in einer Schleife zu haben, die sieben Mal wiederholt wird. Die Leistung ist praktisch identisch. Fast jeder schreibt i <7. Wenn Sie aus Gründen der Lesbarkeit schreiben, verwenden Sie das Formular, das jeder sofort erkennt.

DJClayworth
quelle
1

Ich habe es immer vorgezogen:

for ( int count = 7 ; count > 0 ; -- count )
kenny
quelle
Was ist Ihre Begründung? Ich bin wirklich interessiert.
Chris Cudmore
Das ist vollkommen in Ordnung für Rückwärtsschleifen. Wenn Sie jemals so etwas brauchen
ShoeLace
1
Ein Grund dafür ist, dass auf uP-Ebene der Vergleich mit 0 schnell ist. Ein weiterer Grund ist, dass es mir gut vorliest und die Zählung mir einen einfachen Hinweis darauf gibt, wie oft noch übrig ist.
Kenny
1

Wenn Sie sich angewöhnen, <zu verwenden, wird dies sowohl für Sie als auch für den Leser konsistent, wenn Sie ein Array durchlaufen. Es wird für jeden einfacher sein, eine Standardkonvention zu haben. Und wenn Sie eine Sprache mit 0-basierten Arrays verwenden, ist <die Konvention.

Dies ist mit ziemlicher Sicherheit wichtiger als jeder Leistungsunterschied zwischen <und <=. Streben Sie zuerst nach Funktionalität und Lesbarkeit und optimieren Sie dann.

Ein weiterer Hinweis ist, dass es besser wäre, die Gewohnheit zu haben, ++ i zu machen, als i ++, da Abrufen und Inkrementieren ein temporäres und Inkrementieren und Abrufen nicht erfordert. Für Ganzzahlen optimiert Ihr Compiler wahrscheinlich die temporäre Abwesenheit, aber wenn Ihr iterierender Typ komplexer ist, kann er dies möglicherweise nicht.

JohnMcG
quelle
1

Verwenden Sie keine magischen Zahlen.

Warum ist es 7? (oder 6 für diese Angelegenheit).

Verwenden Sie das richtige Symbol für die Nummer, die Sie verwenden möchten ...

In diesem Fall denke ich, ist es besser zu verwenden

for ( int i = 0; i < array.size(); i++ )
Krakkos
quelle
1

Die Operatoren '<' und '<=' sind genau die gleichen Leistungskosten.

Der Operator '<' ist ein Standardoperator und in einer auf Null basierenden Schleife leichter zu lesen.

Die Verwendung von ++ i anstelle von i ++ verbessert die Leistung in C ++, jedoch nicht in C # - ich weiß nichts über Java.

Jeff B.
quelle
1

Wie die Leute beobachtet haben, gibt es keinen Unterschied zwischen den beiden von Ihnen genannten Alternativen. Um dies zu bestätigen, habe ich ein einfaches Benchmarking in JavaScript durchgeführt.

Sie können die Ergebnisse hier sehen . Was daraus nicht klar ist, ist, dass wenn ich die Position des 1. und 2. Tests tausche, die Ergebnisse für diese 2 Tests tauschen, dies eindeutig ein Speicherproblem ist. Der dritte Test, bei dem ich die Reihenfolge der Iteration umkehre, ist jedoch deutlich schneller.

David Wees
quelle
Warum fängst du im zweiten Fall mit i = 1 an?
Eugene Katz
Hrmm, wahrscheinlich ein dummer Fehler? Ich habe das ziemlich schnell ausgepeitscht, vielleicht 15 Minuten.
David Wees
1

Wie jeder sagt, ist es üblich, 0-indizierte Iteratoren auch für Dinge außerhalb von Arrays zu verwenden. Wenn alles bei beginnt 0und endet n-1und Untergrenzen immer <=und Obergrenzen immer <sind, müssen Sie beim Überprüfen des Codes viel weniger nachdenken.

kurzlebig
quelle
1

Gute Frage. Meine Antwort: Verwenden Sie Typ A ('<')

  • Sie sehen deutlich, wie viele Iterationen Sie haben (7).
  • Der Unterschied zwischen zwei Endpunkten ist die Breite des Bereichs
  • Weniger Zeichen machen es lesbarer
  • Sie haben häufiger die Gesamtzahl der Elemente i < strlen(s)als den Index des letzten Elements, daher ist die Einheitlichkeit wichtig.

Ein weiteres Problem ist mit diesem ganzen Konstrukt. ierscheint dreimal darin, so dass es falsch geschrieben werden kann. Das for-loop-Konstrukt sagt, wie zu tun ist, anstatt was zu tun ist . Ich schlage vor, dies zu übernehmen:

BOOST_FOREACH(i, IntegerInterval(0,7))

Dies ist klarer, kompiliert genau die gleichen Anweisungen usw. Fragen Sie mich nach dem Code von IntegerInterval, wenn Sie möchten.

Pavel Radzivilovsky
quelle
1

So viele Antworten ... aber ich glaube, ich habe etwas hinzuzufügen.

Ich bevorzuge, dass die Literalzahlen klar zeigen, welche Werte "i" in der Schleife annehmen . Im Fall der Iteration durch ein nullbasiertes Array:

for (int i = 0; i <= array.Length - 1; ++i)

Und wenn Sie nur eine Schleife ausführen und nicht durch ein Array iterieren, ist das Zählen von 1 bis 7 ziemlich intuitiv:

for (int i = 1; i <= 7; ++i)

Die Lesbarkeit übertrifft die Leistung, bis Sie sie profilieren, da Sie wahrscheinlich nicht wissen, was der Compiler oder die Laufzeit bis dahin mit Ihrem Code tun wird.

Nick Westgate
quelle
1

Sie können !=stattdessen auch verwenden . Auf diese Weise erhalten Sie eine Endlosschleife, wenn Sie einen Fehler bei der Initialisierung machen, wodurch der Fehler früher bemerkt wird und alle Probleme, die dadurch verursacht werden, darauf beschränkt sind, in der Schleife hängen zu bleiben (anstatt ein Problem viel später zu haben und nicht zu finden es).

Brian
quelle
0

Ich denke, beide sind in Ordnung, aber wenn Sie sich entschieden haben, bleiben Sie bei dem einen oder anderen. Wenn Sie es gewohnt sind, <= zu verwenden, versuchen Sie, <nicht zu verwenden und umgekehrt.

Ich bevorzuge <=, aber in Situationen, in denen Sie mit Indizes arbeiten, die bei Null beginnen, würde ich wahrscheinlich versuchen, <zu verwenden. Es ist jedoch alles persönliche Präferenz.

Seanyboy
quelle
0

Streng genommen muss man denken, dass < countdies effizienter wäre als <= countaus dem genauen Grund, aus dem <=auch die Gleichstellung geprüft wird.

Henry B.
quelle
Ich denke nicht, im Assembler läuft es auf cmp eax, 7 jl LOOP_START oder cmp eax hinaus, 6 jle LOOP_START benötigen beide die gleiche Anzahl von Zyklen.
Treb
<= kann implementiert werden als! (>)
JohnMcG
! (>) ist immer noch zwei Anweisungen, aber Treb hat Recht, dass JLE und JL beide dieselbe Anzahl von Taktzyklen verwenden, sodass <und <= dieselbe Zeit benötigen.
Jacob Krall