2009-01-25 13 views
7
int n = 5; 
for(int i = 0;i!=n;i++)//condition != 
{ 
//executing 5times 
} 

int n = 5; 
for(int i = 0;i<n;i++)//condition < 
{ 
//executing 5times 

} 

Quale preferisci?Qual è la condizione preferita nel ciclo?

Questo è stato ad esempio da "Accelerated C++ : programmazione pratico con l'esempio/ Andrew Koenig, Barbara E. Moo." Basta voleva sapere perché l'autore preferisce il primo

+0

downvoting duro! sembra una domanda perfettamente legittima! –

+0

Questo era un esempio di "C++ accelerato: programmazione pratica con l'esempio/Andrew Koenig, Barbara E. Moo." Volevo solo sapere perché l'Autore preferisce il primo – yesraaj

+0

@raj - Forse menzionare nella tua domanda dove hai trovato il problema e dire che stai cercando una spiegazione sul motivo per cui uno è migliore dell'altro. Potrebbe impedire una rapida riduzione del voto. – Dana

risposta

14

Il secondo. Per due motivi

  1. Il minore di (o, talvolta, < =) è il solito modo che la maggior parte coder scrivere questi, ed è meglio attenersi alle convenzioni, se possibile - l'= probabilmente farà la maggior parte dei programmatori guardare due volte per controlla se c'è qualcosa di strano nel ciclo mentre lo < sarà immediatamente compreso.

  2. Il! = Dipende da una condizione esatta. Se l'interno del loop viene modificato durante la manutenzione e ho accidentalmente incrementato l'interno del loop, si otterrebbe un loop infinito. In genere è sempre meglio rendere le condizioni di terminazione più ampie possibili: è semplicemente più robusto.

2 è naturalmente motivo 1.

1

<n è il più utilizzato (mio parere)

+0

benlumley, per favore rimuovilo, non era vuoto, era un bug. se scrivi karlis

+0

+1 per correggere l'ingiusto -1 –

0

non riesco a vedere che conta, non ci sono cose più importanti di cui preoccuparsi di?

Io uso sempre quest'ultimo, ed è quello che ho visto di più.

Qualcuno è sicuro di tirare giù su di esso anche se ....

+0

Esattamente, l'hai visto di più. Generalmente è sempre meglio programmare come altri programmatori si aspettano - semplifica la manutenzione ed è cortesia comune per i tuoi colleghi – Cruachan

3

direi < quanto cattura una serie più ampia di condizioni. Supponiamo che n non sia costante, ma restituito da una funzione che in rare occasioni ha restituito -1. In tal caso, avresti un ciclo molto più lungo (fino a quando l'int si arresta attorno al valore -ve!) Con la versione! = Del ciclo.

3

Uso condition < è molto meglio perché riduce la possibilità di scavalcando vostro valore sentinella e cadere in un ciclo infinito.

1

Di solito faccio il secondo modo utilizzando <. Ma pensando di usare! = Poiché gli iteratori di stl in C++ funzionano in questo modo.

1

Il secondo. A un certo punto verrà sempre completato (supponendo che non stai facendo nulla di divertente come giocare con il valore del contatore all'interno del ciclo).

Non ho mai visto il primo usato, almeno, non in questo modo.

2

Come indicato nella domanda, entrambi i cicli sono equivalenti. Nel codice reale, tuttavia, è tipico che le cose siano un po 'più complicate, e in tal caso, la condizione "i < n" tende ad essere un po' più sicura. Se, ad esempio, potessi aumentare di più di uno, potrebbe passare n e quindi la versione "i! = N" risulterebbe in un ciclo eterno.

Questo è un caso di programmazione difensiva.Non è universalmente accettato: alcune persone preferiscono assicurarsi che le cose falliscano nel modo più spettacolare possibile, in modo che i bug vengano scoperti presto. Lo stile difensivo può nascondere piccoli problemi del genere. Tuttavia, se si vuole prendere tutti i bug, si potrebbe anche andare fino in fondo:

int n = 5; 
int i = 0; 
while (i != n) { 
    int old_i = i; 
    // the real stuff of the loop here 
    ++i; 
    assert(i == old_i + 1); 
} 

(O, meglio ancora, utilizzare un langauge che supporta synxtax per specificare pre e post condizioni e invarianti di ciclo in modo nativo .)

Il libro "C Traps and Pitfalls" di Andrew Koenig (vedi http://en.wikipedia.org/wiki/C_Traps_and_Pitfalls per i principianti) è probabilmente interessante per te se ti piace riflettere su questo tipo di domande.

0

"i < n" è migliore. Perché se usi "i! = N" e in alcuni casi il tuo i iniziale è maggiore di n, entrerai in un ciclo infinito.

+0

Nessun ciclo infinito, ma un errore di ovrflow ;-) –

0

Credo che questa sia un'alternativa migliore se si sta ottimizzando per velocità:

int n = 5; 
for(int i = n;i > 0;i--) 
{ 
//executing 5times 
} 

La ragione di ciò è che il confronto con 0 è più veloce.

+1

No -1, ma probabilmente stai per accedere ad un array indicizzato da I all'interno di quel ciclo, e le CPU fanno un lavoro migliore di prefetching della memoria nella cache quando è in corso l'accesso in ordine crescente. Il 1ns che hai comprato confrontandolo con 0 sarà affogato da 70ns in attesa di RAM. –

+0

In realtà, sarebbe più veloce se usassi "i" invece di "i> 0" per la tua condizione di uscita, e "--i" invece di "i--" (anche se l'ultimo probabilmente sarà ottimizzato dal tuo compilatore). – strager

+1

@j_random_hacker, Un'alternativa migliore è: int i = n; while (i -> 0) {}. Uso questo idioma a volte in cui l'ordine di iterazione non è importante. (0 può essere qualsiasi numero a cui terminare.) – strager

1

Preferirei usare <, poiché osservando il codice si può dire che è un ciclo in aumento, esso conferma il fatto che si sta usando i ++.

Se si utilizza i ++ e < e per qualche motivo (altro codificatore, errore di battitura, errore umano) il codice cambia l'incremento in i-- si sa immediatamente che il ciclo non viene valutato, come con! = funzionerà in entrambi i modi, rendendo meno banale il debug.

+0

Buona osservazione; questo mi ha catturato un paio di volte, e fortunatamente stavo usando strager

0

Dico che dipende dal tipo di variabile iteratore. Se sai che è un numero intero, vorrei utilizzare il secondo, perché si può dire che

Loop, finché i è più piccolo di n

che credo sia più facile da leggere per la maggior parte programmatori, incluso me stesso. Se non conosci il tipo di variabile iteratore, dovresti fare quanto meno ipotesi sulle sue capacità possibili. operator< potrebbe non essere disponibile per i: se è un iteratore diverso da un iteratore di accesso casuale, non è garantita la disponibilità di operator<. In questo caso vorrei usare operator!=.

Eviterei di preferire l'opzione < solo perché potresti "scavalcare" accidentalmente il valore finale. Penso che l'argomento sia difettoso. Perché se hai fatto un passaggio accidentale, allora è un bug e dovrebbe essere notato il prima possibile (Fail-fast).

Problemi correlati