What is the best way to do the reverse "for" loop with an unsigned index?

Question

My first reverse attempt for a loop that does something n times was something like:

for ( unsigned int i = n-1; i >= 0; i-- ) { ... } 

This fails because in unsigned arithmetic i always guaranteed to be greater than or equal to zero, so the loop condition will always be true. Fortunately, the gcc compiler warned me of a "pointless comparison" before I had to wonder why the loop was running endlessly.

---

I am looking for an elegant way to solve this problem, bearing in mind that:

• It should be a reverse cycle.
• The loop index must be unsigned.
• n is a constant constant.
• It should not be based on the "obscure" ring arithmetic of unsigned integers.

Any ideas? Thank:)

Answer 1

What about:

 for (unsigned i = n ; i-- > 0 ; ) { // do stuff with i } 

Answer 2

 for ( unsigned int loopIndex = n; loopIndex > 0; --loopIndex ) { unsigned int i = loopIndex - 1; ... } 

or

 for ( unsigned int loopIndex = 0; loopIndex < n; ++loopIndex ) { unsigned int i = n - loopIndex - 1; ... } 

Answer 3

 for ( unsigned int i = n; i != 0; i-- ) { // do something with i - 1 ... } 

Note that if you use C ++ as well as C, using! = Is a good habit when you switch to using iterators, where <=, etc. may not be available.

Answer 4

 for ( unsigned int i = n; i > 0; i-- ) { ... i-1 //wherever you've been using i } 

Answer 5

I would use

  for ( unsigned int i = n; i > 0; ) { --i; ... } 

it's almost the same as skizz 'answer (it skips the final unnecessary decrement, but the compiler needs to optimize it), and in fact the code review will go through. Each coding standard that I had to work with did not have a mutation in the conditional rule.

Answer 6

Why not just:

 unsigned int i = n; while(i--) { // use i } 

This meets all the requirements listed in the body of the question. It does not use anything that could lead to a failure of code verification or a violation of the encoding standard. The only objection I could see was that the OP really insisted on a for loop, and not on a simple way to generate i = (n-1) .. 0.

Answer 7

Maybe so? IMHO it is clear and understandable. You can omit if (n> = 1) if it is implicitly known somehow.

 if(n>=1) { // Start the loop at last index unsigned int i = n-1; do { // a plus: you can use i, not i-1 here } while( i-- != 0 ); } 

Another version:

 if(n>=1) { unsigned int i = n; do { i--; } while( i != 0 ); } 

The first code without an if statement will look like this:

 unsigned int i = n-1; do { } while( i-- != 0 ); 

Answer 8

Or you can rely on unsigned int shell behavior if you need to index from n-1 to 0

 for(unsigned int i = n-1; i < n; i--) { ... } 

Answer 9

 for ( unsigned int i = n; i > 0; i-- ) { unsigned int x = i - 1; // do whatever you want with x } 

Of course, not elegant, but it works.

Answer 10

 for (unsigned int i = n-1; i<(unsigned int)-1; i--) 

OK, its "fuzzy ring arithmetic."

Answer 11

The only reason I mention this option is because I did not see it on the list.

 for ( unsigned int i = n-1; i < n; i-- ) { ... } 

Totally against intuition, but it works. the reason it works is because subtracting 1 from 0 gives the largest number that can be represented by an unsigned integer.

In general, I do not think that it is a good idea to work with integers without recharging, as well as when subtracting.

Answer 12

Just, just stop at -1:

 for( unsigned int i = n; i != -1; --i ) { /* do stuff with i */ } 

edit: don't know why this is happening. it works, and it is simpler and more obvious than any of the above.

Answer 13

 for ( unsigned int i = n; i > 0; i-- ) { ... } 

It should work fine. If you need to use the i variable as an index in an array, do the following:

 array[i-1]; 

Answer 14

Hm. Here are your options:

• Use i=0 as an interrupt condition. The loop will not execute when I reach 0, so do the 1st iteration of the contents of the loop for i=0 after the loop exits.

 for ( unsigned int i = n-1; i > 0; i-- ) { doStuff(i); } doStuff(0); 

2. In a loop, check i=0 and break . Not recommended, because now you check the value i twice in a loop. Also, using a break in a loop is usually considered bad practice.

 for ( unsigned int i = n-1; i >= 0; i-- ) { doStuff(i); if (i=0) break; } 

Answer 15

 unsigned index; for (unsigned i=0; i<n; i++) { index = n-1 - i; // {i == 0..n-1} => {index == n-1..0} } 

Answer 16

Since this is not a standard for a loop, I would most likely use a while loop, for example:

 unsigned int i = n - 1; while (1) { /* do stuff with i */ if (i == 0) { break; } i--; } 

Answer 17

This is not verified, but you can do the following:

 for (unsigned int i, j = 0; j < n; i = (n - ++j)) { /* do stuff with i */ } 

Answer 18

Use two variables: one for counting and one for array index:

 unsigned int Index = MAX - 1; unsigned int Counter; for(Counter = 0; Counter < MAX; Counter++) { // Use Index Index--; } 

Answer 19

 for ( unsigned int i = n-1; (ni) >= 0; i-- ) { // ni will be negative when the loop should stop. ... } 

Answer 20

ez:

 #define unsigned signed for ( unsigned int i = n-1; i >= 0; i-- ) { ... }