Что лучший способ состоит в том, чтобы сделать реверс 'для' цикла с неподписанным индексом?

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

Так как это не стандарт для цикла, я, вероятно, использовал бы некоторое время цикл вместо этого, например:

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

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

Используйте две переменные, одну к количеству , и другой для индекса массива:

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

Это не тестируется, но могли Вы делать следующее:

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

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

Гм. Вот Ваши опции:

1. Использование i=0 как Ваше условие повреждения - Цикл не выполнится, когда я достигну 0, поэтому выполните 1 повторение содержания цикла для i=0 после того, как цикл вышел.

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

2. В цикле, протестируйте на i=0 и break. Не рекомендуемый, потому что теперь Вы тестируете значение меня дважды в цикле. Также использование повреждения в цикле обычно рассматривает как плохую практику.

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

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

Должен хорошо работать. Если необходимо использовать i переменная, поскольку индекс в массив делает это как это:

array[i-1];

Единственная причина я упоминаю эту опцию, состоит в том, потому что я не видел его в списке.

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

Полностью против интуиции, но это работает. причина это работает, состоит в том, потому что вычитание 1 от 0 урожаев наибольшее число, которое может быть представлено целым числом без знака.

В целом я не думаю, что это - хорошая идея работать с целыми числами без знака и arthmetic, особенно при вычитании.

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

, Конечно, не изящный, но это работает.

Или Вы могли полагаться на переносящееся поведение unsigned int при необходимости в индексации от n-1 до 0

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

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

хорошо, его "неясная кольцевая арифметика".

Возможно, этот путь? По моему скромному мнению, его ясное и читаемое. Можно опустить, если (n> =1), если это неявно известно так или иначе.

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

Другая версия:

if(n>=1) {
    unsigned int i = n;
    do {
       i--;

    } while( i != 0 );
}

первый код без того, если оператор был бы похож:

unsigned int i = n-1;
do {

} while( i-- != 0 );

Я был бы склонен использовать

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

, это - почти то же как skizz' ответ, (это пропускает заключительный ненужный декремент, но компилятор должен оптимизировать это далеко), и на самом деле передаст обзор кода. Каждый стандарт кодирования, с которым я должен был работать, имел без мутаций в условном правиле.

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

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

Примечание это, если Вы используете C++, а также C, с помощью! = хорошая привычка войти для того, когда Вы переключаетесь на использование итераторов, где < = и т.д. может не быть доступным.

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

или

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

ez:

#define unsigned signed

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

Легко, просто остановитесь на -1:

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

редактировать: не уверен, почему за это голосуют против. это работает, и это проще и очевиднее, чем любое из вышеперечисленных.