Si dovrebbe usare <o <= in un ciclo for [chiuso]

Se dovessi scorrere 7 volte un ciclo, useresti:

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

o:

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

Vi sono due considerazioni:

• prestazione
• leggibilità

Per prestazioni sto assumendo Java o C #. Importa se si utilizza "minore di" o "minore di o uguale a"? Se hai informazioni dettagliate su un'altra lingua, indica quale.

Per leggibilità sto assumendo array basati su 0.

UPD: La mia menzione di array basati su 0 potrebbe avere cose confuse. Non sto parlando di iterare attraverso gli elementi dell'array. Solo un ciclo generale.

Di seguito è riportato un buon punto sull'uso di una costante che spiegherebbe cos'è questo numero magico. Quindi se avessi " int NUMBER_OF_THINGS = 7" allora " i <= NUMBER_OF_THINGS - 1" sembrerebbe strano, no.

Il primo è più idiomatico . In particolare, indica (in senso 0) il numero di iterazioni. Quando uso qualcosa basato su 1 (es. JDBC, IIRC) potrei essere tentato di usare <=. Così:

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

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

Mi aspetto che la differenza di prestazioni sia insignificantemente piccola nel codice del mondo reale.

Entrambi questi loop ripetono 7 volte. Direi che quello con un 7 è più leggibile / più chiaro, a meno che tu non abbia una buona ragione per l'altro.

Ricordo dai miei giorni quando facevamo l'Assemblea 8086 al college, era più performante fare:

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

poiché c'era un'operazione JNS che significa Salta se nessun segno. L'uso di questo significava che dopo ogni ciclo non vi era alcuna ricerca di memoria per ottenere il valore di confronto e neppure un confronto. Oggigiorno la maggior parte dei compilatori ottimizza l'utilizzo dei registri, quindi la memoria non è più importante, ma si ottiene comunque un confronto non necessario.

A proposito, mettere 7 o 6 nel tuo ciclo sta introducendo un " numero magico ". Per una migliore leggibilità dovresti usare una costante con un Nome rivelatore di intenti. Come questo:

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

EDIT: le persone non ottengono il montaggio, quindi è ovviamente necessario un esempio più completo:

Se lo facciamo per (i = 0; i <= 10; i ++) devi farlo:

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

Se lo facciamo per (int i = 10; i> -1; i--) allora puoi cavartela con questo:

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

Ho appena controllato e il compilatore C ++ di Microsoft non esegue questa ottimizzazione, ma lo fa se lo fai:

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

Quindi la morale è se stai usando Microsoft C ++ †, e crescente o decrescente non fa alcuna differenza, per ottenere un ciclo rapido dovresti usare:

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

piuttosto che uno di questi:

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

Ma ottenere francamente la leggibilità di "for (int i = 0; i <= 10; i ++)" è normalmente molto più importante della mancanza di un comando del processore.

† Altri compilatori possono fare cose diverse.

Uso sempre <array.length perché è più facile da leggere di <= array.length-1.

anche avendo <7 e dato che sai che inizia con un indice 0, dovrebbe essere intuitivo che il numero sia il numero di iterazioni.

Visto da un punto di vista ottimizzante, non importa.

Visto da un punto di vista in stile codice preferisco <. Motivo:

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

è molto più leggibile di

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

anche <ti dà il numero di iterazioni immediatamente.

Un altro voto per <è che potresti prevenire molti errori accidentali off-by-one.

@ Chris, la tua affermazione sul fatto che .Lunghezza sia costosa in .NET è in realtà falsa e nel caso di tipi semplici l'esatto contrario.

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

è in realtà più lento di

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

Il successivo è un caso ottimizzato dal runtime. Poiché il runtime può garantire che i sia un indice valido nell'array, non viene eseguito alcun controllo dei limiti. Nel primo, il runtime non può garantire che non sia stato modificato prima del ciclo e forza i controlli dei limiti sull'array per ogni ricerca dell'indice.

Non fa alcuna differenza per quanto riguarda le prestazioni. Pertanto vorrei usare qualunque sia più facile da capire nel contesto del problema che si sta risolvendo.

Preferisco:

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

Penso che ciò si traduca più facilmente in "iterare attraverso un ciclo 7 volte".

Non sono sicuro delle implicazioni sulle prestazioni - sospetto che eventuali differenze vengano eliminate.

In Java 1.5 puoi semplicemente farlo

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

quindi per il caso dell'array non devi preoccuparti.

Non penso che ci sia una differenza di prestazioni. Il secondo modulo è sicuramente più leggibile, tuttavia, non è necessario sottrarlo mentalmente per trovare l'ultimo numero di iterazione.

EDIT: vedo gli altri in disaccordo. Personalmente, mi piace vedere i numeri di indice effettivi nella struttura del ciclo. Forse è perché ricorda più la 0..6sintassi di Perl , a cui so equivale (0,1,2,3,4,5,6). Se vedo un 7, devo controllare l'operatore accanto per vedere che, di fatto, l'indice 7 non viene mai raggiunto.

Direi che usa la versione "<7" perché è quello che leggerà la maggior parte delle persone, quindi se le persone scremano leggendo il tuo codice, potrebbero interpretarlo in modo errato.

Non mi preoccuperei se "<" è più veloce di "<=", basta andare per leggibilità.

Se vuoi aumentare la velocità, considera quanto segue:

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

Per aumentare le prestazioni è possibile riorganizzarle leggermente in:

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

Notare la rimozione di GetCount () dal loop (perché verrà interrogato in ogni loop) e la modifica di "i ++" in "++ i".

In C ++, preferisco usare !=, che è utilizzabile con tutti i contenitori STL. Non tutti gli iteratori di contenitori STL sono meno che comparabili.

Edsger Dijkstra ha scritto un articolo su questo nel 1982 in cui sostiene il <= i <superiore:

C'è un numero naturale più piccolo. Esclusione del limite inferiore - come in b) ed) - forza per una sottosequenza a partire dal numero naturale più piccolo il limite inferiore come menzionato nel regno dei numeri innaturali. È brutto, quindi per il limite inferiore preferiamo ≤ come in a) ec). Considera ora le sottosequenze che iniziano con il numero naturale più piccolo: l'inclusione del limite superiore costringerebbe quest'ultimo a essere innaturale quando la sequenza si è ridotta a quella vuota. È brutto, quindi per il limite superiore preferiamo <come in a) ed). Concludiamo che la convenzione a) deve essere preferita.

Innanzitutto, non usare 6 o 7.

Meglio usare:

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

}

In questo caso è meglio dell'uso

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

}

Ancora meglio (Java / C #):

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

}

E ancora meglio (C #)

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

}

Il ciclo inverso è davvero più veloce ma poiché è più difficile da leggere (se non da te da altri programmatori), è meglio evitarlo. Soprattutto in C #, Java ...

Concordo con la folla dicendo che il 7 ha senso in questo caso, ma aggiungerei che nel caso in cui il 6 sia importante, dire che vuoi chiarire che stai agendo solo su oggetti fino al sesto indice, quindi il <= è migliore poiché rende i 6 più facili da vedere.

Già al college, ricordo qualcosa di simile a queste due operazioni in termini di tempo di calcolo sulla CPU. Certo, stiamo parlando a livello di assemblea.

Tuttavia, se stai parlando in C # o Java, non credo davvero che uno sarà un aumento di velocità rispetto all'altro, I pochi nanosecondi che guadagni molto probabilmente non meritano alcuna confusione che introduci.

Personalmente, vorrei creare il codice che ha senso dal punto di vista dell'implementazione aziendale e assicurarmi che sia di facile lettura.

Questo rientra direttamente nella categoria "Far sembrare sbagliato il codice sbagliato" .

Nei linguaggi di indicizzazione a base zero, come Java o C #, le persone sono abituate alle variazioni della index < countcondizione. Pertanto, sfruttare questa convenzione defacto renderebbe più ovvi gli errori off-by-one.

Per quanto riguarda le prestazioni: qualsiasi buon compilatore degno della sua impronta di memoria dovrebbe essere reso non problematico.

A parte questo, trovo in loop attraverso un array o altra raccolta in .Net

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

per essere più leggibile rispetto al ciclo numerico for. Questo ovviamente presuppone che il vero contatore Int stesso non sia usato nel codice del ciclo. Non so se c'è un cambiamento nelle prestazioni.

Ci sono molte buone ragioni per scrivere i <7. Avere il numero 7 in un ciclo che scorre 7 volte è buono. Le prestazioni sono effettivamente identiche. Quasi tutti scrivono i <7. Se stai scrivendo per leggibilità, usa il modulo che tutti riconosceranno all'istante.

Ho sempre preferito:

for ( int count = 7 ; count > 0 ; -- count )

Prendere l'abitudine di usare <lo renderà coerente sia per te che per il lettore quando stai iterando attraverso un array. Sarà più semplice per tutti avere una convenzione standard. E se stai usando una lingua con array basati su 0, allora <è la convenzione.

Questo quasi sicuramente conta più di qualsiasi differenza di prestazioni tra <e <=. Cerca prima funzionalità e leggibilità, quindi ottimizza.

Un'altra nota è che sarebbe meglio avere l'abitudine di fare ++ i piuttosto che i ++, poiché il recupero e l'incremento richiedono un temporaneo e l'incremento e il recupero no. Per i numeri interi, il compilatore probabilmente ottimizzerà il temporaneo, ma se il tipo di iterazione è più complesso, potrebbe non essere possibile.

Non usare numeri magici.

Perché è 7? (o 6 del resto).

usa il simbolo corretto per il numero che vuoi usare ...

Nel qual caso penso sia meglio usarlo

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

Gli operatori '<' e '<=' hanno esattamente lo stesso costo prestazionale.

L'operatore '<' è uno standard e più facile da leggere in un ciclo a base zero.

L'uso di ++ i anziché i ++ migliora le prestazioni in C ++, ma non in C #: non conosco Java.

Come hanno osservato le persone, non vi è alcuna differenza in nessuna delle due alternative menzionate. Giusto per confermare, ho fatto alcuni semplici benchmarking in JavaScript.

Puoi vedere i risultati qui . Ciò che non è chiaro da ciò è che se cambio la posizione del 1 ° e del 2 ° test, i risultati per questi 2 test si scambiano, questo è chiaramente un problema di memoria. Tuttavia, il terzo test, quello in cui invertisco l'ordine dell'iterazione, è chiaramente più veloce.

Come dicono tutti, è consuetudine usare iteratori con indice 0 anche per cose al di fuori delle matrici. Se tutto inizia 0e finisce a n-1, e i limiti inferiori sono sempre <=e i limiti superiori sono sempre <, c'è molto meno da pensare quando si deve rivedere il codice.

Ottima domanda La mia risposta: usa il tipo A ('<')

• Vedi chiaramente quante iterazioni hai (7).
• La differenza tra due endpoint è la larghezza dell'intervallo
• Meno personaggi lo rendono più leggibile
• Più spesso hai il numero totale di elementi i < strlen(s)anziché l' indice dell'ultimo elemento, quindi l'uniformità è importante.

Un altro problema riguarda l'intero costrutto. iappare 3 volte in esso, quindi può essere errato. Il costrutto for-loop dice come fare invece di cosa fare . Suggerisco di adottare questo:

BOOST_FOREACH(i, IntegerInterval(0,7))

Questo è più chiaro, compila per eseguire esattamente le stesse istruzioni asm, ecc. Chiedimi il codice di IntegerInterval se vuoi.

Tante risposte ... ma credo di avere qualcosa da aggiungere.

La mia preferenza è che i numeri letterali mostrino chiaramente quali valori "i" prenderà nel ciclo . Quindi, nel caso di iterare attraverso un array a base zero:

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

E se stai solo eseguendo il ciclo, non iterando attraverso un array, contare da 1 a 7 è piuttosto intuitivo:

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

La leggibilità supera le prestazioni fino a quando non le si profila, poiché probabilmente non si sa che cosa farà il compilatore o il runtime fino a quel momento.

Puoi anche usare !=invece. In questo modo, otterrai un ciclo infinito se commetti un errore nell'inizializzazione, facendo in modo che l'errore venga notato in precedenza e tutti i problemi che causa vengono limitati a rimanere bloccati nel ciclo (piuttosto che avere un problema molto più tardi e non trovare esso).

Penso che sia OK, ma quando hai scelto, attenersi all'uno o all'altro. Se sei abituato a usare <=, prova a non usare <e viceversa.

Preferisco <=, ma nelle situazioni in cui stai lavorando con indici che iniziano da zero, probabilmente proverei ad usare <. Sono tutte preferenze personali però.

Dal punto di vista logico, devi pensare che < countsarebbe più efficiente che <= countper la ragione esatta che <=metterà alla prova anche l'uguaglianza.