which is better “for(int i = 0; i != 5; ++i)” or “for(int i = 0; i <= 5; i++)”? [duplicate]

Answer 1

My teacher in the C++ language told me to use the canonical forms: for(int x=0; x != 5; ++i)

Thou the other works just fine but suppose you want to use the loop on a iterator. Then <= does not has to be properly defined and a postfix inc might make your program spend alot of time copying objects.

So he made us use the forms

for(int i=begin; x != end; ++i) and for(int i=begin; end != i--; )

Answer 2

which is better for(int i = 0; i != 5; ++i) or for(int i = 0; i <= 5; i++)?

the 2nd one since its a Bolian Operator, then this for(int i = _ ; i <= __ or etc ; i++ increment )? --> it's widely used as now a days even when are beginners in programming.

Answer 3

The condition != is simply faster than both < and (even more) <= otherwise it is just question of taste, though one needs to be careful of possible infinite loops.

Answer 4

You should use whichever of <, <=, != etc. best expresses your application logic, but if there's no reason to prefer any particular style, then be consistent. In informing that decision, the < and != operators have the advantage of allowing comparisons between 0-based indices and sizeof or STL-style size / length values, as in:

for (size_t i = 0; i < my_vector.size(); ++i)
    ...

The < and <= operators sometimes guard against incrementing past the terminating value (if you've got another condition inside the loop under which you increment/add-to i, or there's some floating point rounding/representation disparity). Not often actually significant, but saving an occasional bug is better than nothing.

Given '<' is the intersection of these two sets, it's a popular choice. To my mind, < also communicates the states under which the loop runs... a more positive assertion rather than the != style. In general, negative assertions are discouraged in programming (e.g. bool invalid is more complicated to get your head around reliably than bool valid, especially in complex boolean expression and when double-negatives are introduced).

This is of course for numeric types. Other types may imply other styles... for example, use of != sentinel. I prefer to have the choice of operator help document these usage implications of the type, though that's a personal choice and arguably redundant.

Otherwise, preincrement can be more efficient for complicated types than post- as it avoids a temporary.

Answer 5

There are at least two differences:

• the first one will iterate 5 times (from 0 to 4), while the second one will iterate 6 times (from 0 to 5).

  This is a logic difference, and it depends on what you need to do.

  If what you meant for the second example was i<=4 (versus i!=5) you shouldn't bother: any compiler will always be able to optimize such a trivial expression even with optimizations turned off.

• the second difference is the use of operator ++: in a case you use the prefix version, while in the other the postfix version.

  This doesn't make difference for native types, but could do some difference with user defined types (ie classes, structs, enums, ...), since the user could overload the operator, and the postfix one (var ++) could be a little slower sometimes.

Answer 6

Using "i < 5" would be the form most people would expect to see on a for loop based on common usage. There is nothing wrong of course with "i != 5" or "i <= 5" (expect they'll give different loop counts) but if I see either of those forms I have to stop and think because it's not the most common form.

So I would always write "i < 5" unless there was a strong reason to do otherwise