Qual è la condizione preferita nel loop?

StackOverflow https://stackoverflow.com/questions/477468

  •  20-08-2019
  •  | 
  •  

Domanda 

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 è preferito?

Questo è stato un esempio di "C ++ accelerato:Programmazione pratica per esempio / Andrew Koenig, Barbara E.Moo. "Volevo solo sapere perché l'autore preferisce il primo

È stato utile?

Soluzione

Il secondo. Per due motivi

  1. Il minore di (o talvolta < =) è il solito modo in cui la maggior parte dei programmatori li scrive, ed è meglio attenersi alla convenzione, se possibile: il! = probabilmente farà sembrare la maggior parte dei programmatori due volte a controlla se c'è qualcosa di strano nel loop mentre < sarà immediatamente compreso.

  2. Il! = dipende da una condizione esatta. Se l'interno del loop viene modificato durante la manutenzione e ho accidentalmente incrementato all'interno del loop, si finirebbe con un loop infinito. Generalmente è sempre meglio rendere le condizioni di terminazione il più ampie possibile - è semplicemente più robusto.

2 è ovviamente il motivo per cui 1.

Altri suggerimenti

Direi < in quanto cattura un insieme più ampio di condizioni. Supponiamo che n non fosse costante ma tornasse da una funzione che in rare occasioni restituiva -1. In tal caso, avresti un ciclo molto più lungo (fino a quando int non passa a un valore -ve!) Con la versione! = Del ciclo.

L'uso di condition < è molto meglio perché riduce la possibilità di scavalcare il valore della sentinella e cadere in un ciclo infinito.

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 leggermente più sicura.Se, ad esempio, potessi aumentare di più di uno, potrebbe superare 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 individuati tempestivamente.Lo stile difensivo può nascondere piccoli problemi del genere.Tuttavia, se vuoi individuare tutti i bug, potresti 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, ancora meglio, utilizzare un linguaggio che supporti la sintassi per specificare pre e post-condizioni e invarianti di loop in modo nativo.)

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

Di solito faccio il secondo modo usando < ;. Ma pensare di usare! = Poiché gli stl iteratori in c ++ funzionano in questo modo.

Il secondo. Si completerà sempre ad un certo punto (supponendo che tu non stia facendo nulla di divertente come giocare con il valore del contatore all'interno del loop).

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

<n è il più usato (la mia opinione)

Preferirei usare < , dato che guardando solo il codice si può dire che è un ciclo crescente, si fa il backup del fatto che si sta utilizzando i ++.

Se stai usando i ++ e < e per qualche ragione (altro programmatore, errore di battitura, errore umano) il tuo codice cambia l'incremento in i-- sapresti immediatamente che il ciclo non viene valutato, come con! = funzionerà in entrambi i modi rendendolo meno banale debug.

Non riesco a capire che sia importante, non ci sono cose più importanti di cui preoccuparsi?

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

Qualcuno è sicuro di spararmi sopra però ....

" i < & N quot; è meglio. Perché se usi & Quot; i! = N & Quot; e in alcuni casi la tua i iniziale è maggiore di n, entrerai in un ciclo infinito.

Credo che questa sia un'alternativa migliore se stai ottimizzando Velocità: 

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

Il motivo è che il confronto con 0 è più veloce.

Dico che dipende dal tipo di variabile iteratore.Se sai che è un numero intero, userei il secondo, perché puoi dirlo

Ciclo continuo, finché sono più piccolo di n

Che penso sia più facile da leggere per la maggior parte dei programmatori, me compreso.Se non conosci il tipo della variabile iteratore, dovresti fare il minor numero possibile di ipotesi sulle sue capacità.IL operator< potrebbe non essere disponibile per i:Se si tratta di un iteratore diverso da un iteratore ad accesso casuale, operator< non è garantita la disponibilità.In questo caso utilizzerei operator!=.

Eviterei di preferire l'opzione < solo perché potresti accidentalmente "scavalcare" il valore finale.Penso che l'argomentazione sia errata.Perché se accidentalmente passi oltre, allora si tratta di un bug e dovrebbe essere notato il prima possibile (Fallisci velocemente).

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top