Pratik olarak sonsuz gibi görünen bir 'for' döngüsü

Şu anda bazı kodlarda hata ayıklama yapıyorum ve şu satırla karşılaştım:

for (std::size_t j = M; j <= M; --j)

(Tatilde olan patronum tarafından yazılmıştır.)

Bana gerçekten tuhaf görünüyor.

Bu ne işe yarıyor? Bana göre sonsuz bir döngü gibi görünüyor.

std::size_tbir unsignedtür olması C ++ standardı tarafından garanti edilmektedir . Ve bir unsignedtürü 0'dan düşürürseniz , standart, bunu yapmanın sonucunun o tür için en büyük değer olduğunu garanti eder.

Çevreleyen bu değer her zaman 1'den büyük veya M^1'e eşittir, böylece döngü sona erer.

Bu nedenle j <= M, bir unsignedtüre uygulandığında "döngüyü sıfıra kadar çalıştır ve sonra durdur" demenin uygun bir yoludur.

jİstediğinizden daha büyük bir tane çalıştırmak ve hatta slayt operatörünü kullanmak gibi alternatifler for (std::size_t j = M + 1; j --> 0; ){mevcuttur, bunlar muhtemelen daha nettir, ancak daha fazla yazma gerektirir. Sanırım bir dezavantajı (ilk incelemede ürettiği şaşırtıcı etkiden başka), Java gibi işaretsiz türlerin olmadığı dillere iyi uyum sağlamamasıdır.

Ayrıca, patronunuzun seçtiği planın, unsignedkümeden olası bir değeri "ödünç aldığını" unutmayın : Bu durumda, olarak Mayarlanmış olması std::numeric_limits<std::size_t>::max()doğru davranışa sahip olmayacaktır. Aslında bu durumda döngü sonsuzdur . (Gözlemlediğiniz şey bu mu?) Koda bu etkiyle ilgili bir yorum eklemeniz ve hatta muhtemelen bu belirli koşul üzerinde iddiada bulunmanız gerekir.

Patronunuzun muhtemelen yapmaya çalıştığıM şey dahil olmak üzere sıfırdan geriye doğru saymak ve her sayı için bazı işlemler yapmaktı .

Ne yazık ki, bunun size gerçekten sonsuz bir döngü vereceği, sahip olabileceğiniz Mmaksimum size_tdeğerin olduğu bir uç durum var. Ve, işaretsiz bir değerin onu sıfırdan düşürdüğünüzde ne yapacağı iyi tanımlanmış olsa da, kodun kendisinin özensiz bir düşünce örneği olduğunu düşünüyorum, özellikle de patronlarınızın girişimlerinin eksiklikleri olmadan mükemmel bir şekilde uygulanabilir bir çözüm olduğu için.

Bu daha güvenli değişken (ve benim görüşüme göre, yine de sıkı bir kapsam sınırını korurken daha okunabilir olan) şöyle olacaktır:

{
    std::size_t j = M;
    do {
        doSomethingWith(j);
    } while (j-- != 0);
}

Örnek olarak, aşağıdaki koda bakın:

#include <iostream>
#include <cstdint>
#include <climits>
int main (void) {
    uint32_t quant = 0;
    unsigned short us = USHRT_MAX;
    std::cout << "Starting at " << us;
    do {
        quant++;
    } while (us-- != 0);
    std::cout << ", we would loop " << quant << " times.\n";
    return 0;
}

Bu, temelde bir ile aynı şeyi yapar unsigned shortve her bir değeri işlediğini görebilirsiniz :

Starting at 65535, we would loop 65536 times.

do..whileYukarıdaki koddaki döngüyü patronunuzun temelde yaptığı şeyle değiştirmek sonsuz bir döngü ile sonuçlanacaktır. Deneyin ve görün:

for (unsigned int us2 = us; us2 <= us; --us2) {
    quant++;
}