'<' versus '! =' bir 'for' döngüsünde koşul olarak?

Diyelim ki aşağıdaki fordöngü *:

for (int i = 0; i < 10; ++i) {
    // ...
}

yaygın olarak şu şekilde de yazılabilir:

for (int i = 0; i != 10; ++i) {
    // ...
}

Nihai sonuçlar aynıdır, yani birini üst üste kullanmanın gerçek argümanları var mı? Şahsen ben eski kullanırım inedense haywire gider ve 10 değerini atlar.

_{* Sihirli sayıları kullanmak için özür dilerim, ama bu sadece bir örnek.}

Birini veya diğerini seçmenin nedeni, niyet nedeniyledir ve bunun sonucunda okunabilirliği arttırır .

Amaç: Döngü i10'dan küçük olduğu sürece, i10'a eşit olmadığı sürece çalıştırılmamalıdır . Bu durumda, ikincisi aynı olsa da, demek istediğin gibi değil, bu yüzden yapmamalı. böyle yazılmak.

Okunabilirlik: ne demek istediğinizi yazmanın bir sonucu da, anlaşılmasının daha kolay olduğu. Örneğin i != 10, kodu okuyorsanız, kodu okuyan bir kişi döngünün içinde bir yolun i10'dan büyük olabileceğini ve döngünün devam edip etmeyeceğini merak edebilir (btw: yineleyiciyle kafasından başka bir yere karıştırmak kötü bir stildir). for) -Bildirim, ama bu demek insanlar bunu yapmayın değildir ve sonuç olarak bakım yapanlar bunu bekliyoruz.

<Model artış tam olarak 1 olması için bir sorun olsa bile, genel olarak kullanılabilir.

Bu, gerçekte nasıl yapıldığına bakılmaksızın, tek bir ortak yolun döngüler yapmasını sağlar.

C ++ 'da Scott Myers'ın Daha Etkili C ++' daki (madde 6) tavsiyesi, yinelemeci ve tamsayı indeksleri için aynı sözdizimine sahip olmanız anlamına gelmediğinden, gerekmediğiniz bir neden olmadıkça daima intikinciyi kullanmaktır. sözdiziminde herhangi bir değişiklik olmadan.

Diğer dillerde bu geçerli değildir, bu yüzden <Thorbjørn Ravn Andersen’nın meselesi nedeniyle muhtemelen tercih edildiğini düşünüyorum.

Bu arada, geçen gün derken başka bir geliştirici ile bu tartışmaya ve o tercih sebebi söz konusu <aşırı !=nedeni ikudretinin yanlışlıkla birden fazla aralıklara ve bu kırılma koşul yerine olmamak neden olabilir; Bu IMO saçmalık bir yük.

(İ <10) kullanmak bence daha güvenli bir uygulama. Potansiyel bırakma vakalarının azami sayısını yakalar - 10'dan büyük veya 10'a eşit olan her şey. Bunu diğer durumla karşılaştırın (i! = 10); Sadece bir olası bırakma olayını yakalar - tam olarak 10 yaşındayken.

Bunun bir yan ürünü okunabilirliği arttırmasıdır. Ek olarak, artış başka bir şey olursa 1, bırakma vakasını yazarken hata yapmamız durumunda sorun olasılığını en aza indirmeye yardımcı olabilir.

Düşünmek:

1) for (i = 1; i < 14; i+=2)

2) for (i = 1; i != 14; i+=2)

Her iki durumda da hatalı / yanlış olmasına rağmen, ikincisinin bırakmayacağından DAHA yanlış olması muhtemeldir. İlk vaka bırakılacak ve 14 muhtemelen yanlış sayı olsa da (15 muhtemelen daha iyi olacak) doğru yerde bırakma olasılığı daha yüksek.

İşte kimsenin henüz gelmemiş gibi göründüğü başka bir cevap. forBir dizi üzerinde yineleme yapmanız gerektiğinde döngüler kullanılmalıdır . Kullanımı !=, döngünün sonlandırma koşulunu belirtmek için en özlü yöntemdir. Ancak, daha az kısıtlayıcı bir operatör kullanmak çok yaygın bir savunma programlama deyimidir. Tamsayılar için önemli değil - bu daha spesifik bir örnek olmadan sadece kişisel bir seçimdir. !=Başkalarının belirttiği nedenlerden kullanmak istediğiniz yineleyicilerle koleksiyonların üzerinden geçerken . floatVeya dizilerini düşünüyorsanız double, o zaman ne !=pahasına olursa olsun kaçınmak istersiniz .

İşaret etmek istediğim, forbir dizi üzerinde yineleme yapmanız gerektiğinde kullanılan şey. Oluşturulan dizinin bir başlangıç ​​noktası, bir aralığı ve bir sonlandırma koşulu vardır. Bunlar kesinlikle forbeyan içerisinde belirtilmiştir . Kendinizi ya da (1) forya da (2) truekoruyucu koşulu gibi bir şey belirten adım bölümünü içermeyen buluyorsanız , bir fordöngü kullanmamalısınız !

whileDöngü, belirli bir durum karşılamakta olup işleme devam etmek için kullanılır. Bir diziyi işlemiyorsanız, muhtemelen whilebunun yerine bir döngü istiyorsunuz . Bekçi koşulu argümanları burada benzer, ancak a whileve forloop arasındaki karar çok bilinçli olmalıdır. whileIMO C ++ çevrelerinde altında takdir döngüdür.

Bir öğe koleksiyonunu (çok yaygın bir fordöngü kullanımı) işliyorsanız, gerçekten daha özel bir yöntem kullanmalısınız. Ne yazık ki, std::for_eachC ++ 'da bir çok sebepten dolayı oldukça acı verici. Birçok durumda, bir forilmek gövdesini serbest duran bir fonksiyonda (biraz ağrılı iken) ayırmak, daha temiz bir çözelti ile sonuçlanır. Koleksiyonları ile çalışırken, düşünün std::for_each, std::transformya std::accumulate. Birçok algoritmanın uygulanması, bu şekilde ifade edildiğinde kısa ve netleşir. Döngünün gövdesini ayrı bir işleve / yönteme ayırmanın sizi algoritmaya, giriş gereksinimlerine ve sonuçlarına odaklanmaya zorladığından bahsetmiyorum.

Java, Python, Ruby, hatta kullanıyorsanız C ++ 0x , o zaman uygun bir koleksiyon kullanarak olmalıdır foreach döngü. C ++ derleyicileri bu özelliği uygularken for, bu tür tartışmalarda olduğu gibi çok sayıda döngü kaybolacaktır.

"Küçükten küçük" ifadesi (genellikle) anlamsal olarak doğru ise, gerçekten i10'dan küçük olana kadar saymayı kastediyorsunuz , bu yüzden "küçükten az" niyetinizi açıkça ifade ediyor. "Eşit olmayan" kullanımı hemen hemen çağrı durumlarında açıkça çalışır, ancak biraz farklı bir anlam ifade eder. Bazı durumlarda ihtiyacınız olan şey olabilir ama benim tecrübeme göre bu asla böyle olmadı. Gerçekten i10'dan daha az ya da daha az olabileceği bir durumunuz olsaydı ancak 10'a eşit olana kadar döngü devam ettirmek istiyorsanız, o zaman bu kodun gerçekten çok net bir şekilde yorum yapması gerekirdi ve muhtemelen başka bir yapıyla daha iyi yazılmış olabilirdi. whilebelki bir döngü olarak .

Bir iyilik istiyorum nedenlerinden biri less thanaşkın not equalsbir bekçi olarak hareket etmektir. Bazı sınırlı durumlarda (kötü programlama veya sterilizasyon) yine not equalsde geçerli olacak şekilde atlanabilir less than.

İşte bir temizlik kontrolünün eksikliğinin tuhaf sonuçlara yol açtığı bir örnek: http://www.michaeleisen.org/blog/?p=358

İşte <yerine tercih etmenin bir nedeni !=. Genel değişken kapsamı olan bir dil kullanıyorsanız, diğer kod değiştirilirse ne olur i? Daha <ziyade !=, en kötüsü, yinelemenin daha çabuk bitmesidir: belki de iyanlışlıkla bazı kod artışları olabilir ve for döngüsünde birkaç yinelemeyi atlarsınız. Fakat 0'dan 10'a kadar döngü oluşturuyorsanız ne olur ve döngü 9'a, ibazı garip nedenlerden dolayı bazı kötü yazılmış iplik artışları . Ardından, döngünüz bu yinelemeyi ve artışları tamamlar, iböylece değer şimdi 11 olur. Döngü çıkış koşulunu atladığında ( iasla 10'a eşit olmaz) şimdi sonsuz bir şekilde dönecektir.

Bu duruma neden olacak özellikle garip bir iş parçacığı ve genel değişkenler türü mantığı olması gerekmez. Sadece geri izlemesi gereken bir döngü yazıyor olabilirsiniz. iDöngünün içinde mutasyona uğruyorsanız ve mantığınızı berbat ediyorsanız, onu !=bir sonsuzluk sınırında bırakma olasılığınızın düşük olması yerine, bir üst sınırına sahip olmasını sağlayın .

Gömülü dünyada, özellikle gürültülü ortamlarda, mutlaka olması gerektiği gibi davranan RAM'e güvenemezsiniz. '==' veya '! =' Kullanarak karşılaştırdığınız koşullu (yani, eğer) ise, değişkenlerinizin her zaman döngüyü sona erdiren kritik değeri atlaması riskini atlarsınız - bu felaket sonuçlara neden olabilir - Mars Lander seviye sonuçları. Bu durumda '<' veya '>' kullanımı, 'bilinmeyen bilinmeyenleri' yakalamak için ekstra güvenlik sağlar.

Orijinal örnekte, eğer iaçıklanamaz şekilde 10'dan daha büyük bir değere mandalina olsaydı , '<' karşılaştırması hatayı hemen yakalar ve döngüden çıkardı, ancak '! =', i0 ve sonlarına kadar sarılıncaya kadar saymaya devam edecekti. 10'a.