Unsigned int odwraca iterację za pomocą pętli for

Następująca robi to, co chcesz:

for (unsigned i = 10; i != static_cast<unsigned>(-1); --i)
{
    // ...
}

To jest doskonale zdefiniowane i faktycznie działa. Arytmetyka na typach podpisanych jest dokładnie określona przez standard. Rzeczywiście:

Od 4.7/2 (w odniesieniu do odlewania do typu niepodpisanego):

Jeśli typ docelowy jest niepodpisany, wartość wynikowa jest najmniejszą niepodpisaną liczbą całkowitą zgodną ze źródłową liczbą całkowitą (modulo 2^n, gdzie n jest liczbą bitów używanych do reprezentowania niepodpisanej typ)

Oraz 3.9.1/4

Niepodpisane liczby całkowite, zadeklarowane niepodpisane, spełniają prawa arytmetyki modulo 2^n, gdzie n jest liczbą bitów w reprezentacji wartości tego konkretnego rozmiaru liczby całkowitej

Mój wzór na to jest zazwyczaj...

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

Czy naprawdę iterujesz z jakiejś liczby większej niż std::numeric_limits<int>::max()? Jeśli nie, sugerowałbym użycie zwykłej int jako zmiennej pętli i static_cast do unsigned w miejscach w kodzie, które oczekują, że będzie niepodpisana. W ten sposób możesz użyć intuicyjnego warunku >= 0 lub > -1 i ogólnie spodziewałbym się, że będzie on bardziej czytelny niż jakakolwiek z niepodpisanych alternatyw.

static_cast byłoby po prostu powiedzieć kompilatorowi jak operować na zmiennej i nie mieć wydajności implikacje w ogóle.

Myślę, że dwie opcje są albo rzucone lub pojedyncze liczby (można to zrobić domyślnie porównując do -1, na przykład) lub użyć warunku pętli, aby sprawdzić przepełnienie w ten sposób:

for(unsigned i=10;i>i-1;--i){ } // i = 10, 9, ... , 1
for(unsigned i=10;i+1>i;--i){ } // i = 10, 9, ... , 1,0

Ta pętla będzie kontynuowana, dopóki nie przepełnię się (co oznacza, że osiągnął zero). Zauważ, że ważne jest, aby i iterował przez 1, lub możesz skończyć z nieskończoną pętlą.

Unikanie niedociągnięć

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

Użyłbym dwóch zmiennych:

unsigned int start = 10;
for (unsigned int j = 0, i = start; j <= start; ++ j, -- i) {
    // ...
}

Możesz również użyć pętli while:

unsigned int start = 10;
unsigned int i = start + 1;
while (i --) {
    // ...
}

for(unsigned i = x ; i != 0 ; i--){ ...

I jeśli chcesz wykonać ciało pętli, Gdy i = = 0 i zatrzymać po tym. Zacznij od i = x+1;

BTW, dlaczego muszę być niepodpisany ?

Możesz spróbować zdefiniować następujące makro:

#define for_range(_type, _param, _A1, _B1) \
    for (_type _param = _A1, _finish = _B1,\
    _step = static_cast<_type>(2*(((int)_finish)>(int)_param)-1),\
    _stop = static_cast<_type>(((int)_finish)+(int)_step); _param != _stop; \
_param = static_cast<_type>(((int)_param)+(int)_step))

Teraz możesz go użyć:

for_range (unsigned, i, 10,0)
{
    cout << "backwards i: " << i << endl;
}

for_range (char, c, 'z','a')
{
    cout << c << endl;
}

enum Count { zero, one, two, three }; 

for_range (Count, c, zero, three)
{
    cout << "forward: " << c << endl;
}

Pomimo niezręcznej definicji jest bardzo dobrze zoptymalizowany. Patrzyłem na disassembler w VC++. Kod jest niezwykle wydajny. Nie zniechęcaj się, ale trzy instrukcje for: kompilator wytworzy tylko jedną pętlę po optymalizacji! Można nawet zdefiniować zamknięte pętle:

unsigned p[4][5];

for_range (Count, i, zero,three)
    for_range(unsigned int, j, 4, 0)
    {   
        p[i][j] = static_cast<unsigned>(i)+j;
    }

Oczywiście nie można iterować przez typy wyliczone z lukami.

Jestem nowy w c++, moja odpowiedź może być naprawdę głupia, ale robię to dla tego rodzaju pętli odwrotnych;

size_t count = 3;
size_t newCount = 0;
if (count > 0)
    for (size_t i = count - 1; i >= newCount; i--)
    {
        //do your work here

        //and at the end
        if (i == 0)
            break;
    }

Oto prosty trik na przepełnienie jajowodu, jeśli i powtarza się przez 1:

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

If you want i to iterate for more than 1:

unsigned int d = 2;
for(unsigned int i = n-1; i+d >= d; i-=d) {;}

for (unsigned int i = 10; i <= 10; --i)

Nie chcę ci dać odpowiedzi na twoje dziesięcioletnie pytanie, ale próba uniknięcia niedopełnienia spowoduje zaciemnienie tego, co próbujesz ostatecznie zrobić.

Unsigned integer jest dobrze zdefiniowanym zachowaniem, na którym można polegać i oczekiwać, że inni programiści zrozumieją. Wszelkie obejście sprawi, że zakres, na którym próbujesz działać, będzie trudniejszy do przeanalizowania i prawdopodobnie będzie tak samo mylący dla początkującego, przekazując nie jest to dobry przykład, jeśli powinni go odebrać jako" lekcję " w odwrotnej kolejności dla pętli

Po Prostu:

int start = 10;
for(unsigned int iPlus1 = start + 1 ; iPlus1 > 0 ; iPlus1--) {
  // use iPlus1 - 1 if you need (say) an array index
  a[iPlus1 - 1] = 123; // ...
}

Jeszcze jedna droga:

for(unsigned i = n-1; i < n ; --i) 
{       
    // Iterates from n-1 to 0
}

Simillarly for size_t (unsigned integer type) użyj tej samej sztuczki

for(std::size_t i = n-1; i < n ; --i) 
{       
    // Iterates from n-1 to 0
}