CODEWITHSUNDEEP
cfor-loop
Auron
Auron

Reputation: 14246

What's the best way to do a reverse 'for' loop with an unsigned index?

My first attempt of reverse for 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 is guaranteed to be always greater or equal than zero, hence the loop condition will always be true. Fortunately, gcc compiler warned me about a 'pointless comparison' before I had to wonder why the loop was executing infinitely.

I'm looking for an elegant way of resolving this issue keeping in mind that:

  1. It should be a backwards for loop.
  2. The loop index should be unsigned.
  3. n is unsigned constant.
  4. It should not be based on the 'obscure' ring arithmetics of unsigned integers.

Any ideas? Thanks :)

Upvotes: 69

Views: 56522

Answers (20)

Skizz
Skizz

Reputation: 71070

How about:

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

Upvotes: 118

Puqqa
Puqqa

Reputation:

e.z:

#define unsigned signed

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

Upvotes: -6

idz
idz

Reputation: 12988

Why not simply:

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

This meets all the requirement enumerated in the body of the question. It doesn't use anything likely to fail code review or violate a coding standard. The only objection I could see to it is if the OP really insisted on a for loop and not a straightforward way of generating i = (n-1) .. 0.

Upvotes: 13

starblue
starblue

Reputation: 56782

Since this is not a standard for loop I would probably use a while loop instead, e.g.:

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

     if (i == 0)
    {
        break;
    }
    i--;
}

Upvotes: 0

Dave
Dave

Reputation:

Easy, just stop at -1:

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

edit: not sure why this is getting downvoted. it works and it's simpler and more obvious than any of the above.

Upvotes: 2

Steve Melnikoff
Steve Melnikoff

Reputation: 2670

Use two variables, one to count up, and the other for the array index:

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

Upvotes: 0

user80452
user80452

Reputation: 23

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

Upvotes: 1

Pete Kirkham
Pete Kirkham

Reputation: 49321

I'd tend to use

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

it's almost the same as skizz' answer, (it misses out a final unnecessary decrement, but the compiler should optimise that away), and actually will pass code review. Every coding standard I've had to work with has had a no-mutation in conditional rule.

Upvotes: 10

Renze de Waal
Renze de Waal

Reputation: 533

The only reason I mention this option is because I did not see it in 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 yields the largest number that can be represented by an unsigned integer.

In general I do not think it is a good idea to work with unsigned integers and arthmetic, especially when subtracting.

Upvotes: 3

peje
peje

Reputation: 370

Or you could rely on the wrapping behaviour of unsigned int if you need indexing from n-1 to 0 

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

Upvotes: 5

anon
anon

Reputation:

Maybe this way? IMHO its clear and readable. You can omit the 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 if statement would look like:

unsigned int i = n-1;
do {

} while( i-- != 0 );

Upvotes: 5

Eric Bainville
Eric Bainville

Reputation: 9896

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

OK, its "obscure ring arithmetic".

Upvotes: 4

SpoonMeiser
SpoonMeiser

Reputation: 20427

This is untested, but could you do the following:

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

Upvotes: 0

Tim
Tim

Reputation: 402

Hm. Here are your options:

  1. Use i=0 as your break condition - Loop will not execute when i reaches 0, so execute 1 iteration of the loop contents for i=0 after the loop has exited. 
for ( unsigned int i = n-1; i > 0; i-- ) {
    doStuff(i);
}
doStuff(0);
  1. In the loop, test for i=0 and break out. Not recommended because now you're testing the value of i twice in the loop. Also using break within a loop is generally regarding as bad practice.
for ( unsigned int i = n-1; i >= 0; i-- ) {
    doStuff(i);
    if (i=0) break;
}

Upvotes: 1

anon
anon

Reputation: 

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 to get into for when you switch to using iterators, where <= etc. may not be available.

Upvotes: 11

Paulo Guedes
Paulo Guedes

Reputation: 7259

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

Upvotes: -1

itsmatt
itsmatt

Reputation: 31416

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

Certainly not elegant, but it works.

Upvotes: 3

arul
arul

Reputation: 14084

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

Should work fine. If you need to use the i variable as an index into an array do it like this:

array[i-1];

Upvotes: 1

Lou Franco
Lou Franco

Reputation: 89192

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;
    ...
}

Upvotes: 15

vartec
vartec

Reputation: 134611

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

Upvotes: 8

Related Questions