Bir for döngüsünde <veya <= kullanılmalı mı [kapalı]

Bir döngü boyunca 7 kez yinelemeniz gerekse, şunu kullanır mıydınız:

for (int i = 0; i < 7; i++)

veya:

for (int i = 0; i <= 6; i++)

Dikkate alınması gereken iki nokta vardır:

• verim
• okunabilirliği

Performans için Java veya C # varsayıyorum. "Küçüktür" veya "küçüktür veya eşittir" kullanılması fark eder mi? Farklı bir dil hakkında fikriniz varsa lütfen hangisi olduğunu belirtin.

Okunabilirlik için 0 tabanlı dizileri varsayıyorum.

UPD: 0 tabanlı dizilerden bahsetmem bazı şeyleri karıştırmış olabilir. Dizi öğeleri aracılığıyla yinelemekten bahsetmiyorum. Sadece genel bir döngü.

Aşağıda, bu sihirli sayının ne olduğunu açıklayacak bir sabit kullanmakla ilgili iyi bir nokta var. Yani int NUMBER_OF_THINGS = 7" i <= NUMBER_OF_THINGS - 1" olsaydı "o zaman" tuhaf görünürdü, değil mi?

İlki daha deyimsel . Özellikle, (0 temelli anlamda) yineleme sayısını gösterir. 1 tabanlı bir şey kullanırken (örneğin JDBC, IIRC) <= kullanmak isteyebilirim. Yani:

for (int i=0; i < count; i++) // For 0-based APIs

for (int i=1; i <= count; i++) // For 1-based APIs

Gerçek dünya kodunda performans farkının önemsiz derecede küçük olmasını beklerdim.

Bu döngülerin her ikisi de 7 kez yinelenir. Diğeri için gerçekten iyi bir nedeniniz yoksa, içinde 7 olanın daha okunaklı / daha net olduğunu söyleyebilirim.

Üniversitede 8086 Meclisi yaptığımız günlerden hatırlıyorum, yapmanın daha başarılı olduğunu:

for (int i = 6; i > -1; i--)

Bir JNS işlemi olduğu için, bu da İşaret yoksa Atla anlamına gelir. Bunu kullanmak, her döngüden sonra karşılaştırma değerini almak için bellek araması olmadığı ve karşılaştırma da yapılmadığı anlamına geliyordu. Bugünlerde çoğu derleyici, yazmaç kullanımını optimize eder, böylece bellek meselesi artık önemli değildir, ancak yine de gerekli olmayan bir karşılaştırma elde edersiniz.

Bu arada, döngünüze 7 veya 6 koymak bir " sihirli sayı " demektir. Daha iyi okunabilirlik için, Niyet Gösteren Adı olan bir sabit kullanmalısınız. Bunun gibi:

const int NUMBER_OF_CARS = 7;
for (int i = 0; i < NUMBER_OF_CARS; i++)

DÜZENLEME: İnsanlar montaj işini almıyor, bu yüzden daha kapsamlı bir örnek açıkça gerekli:

(İ = 0; i <= 10; i ++) için yaparsak, bunu yapmanız gerekir:

    mov esi, 0
loopStartLabel:
                ; Do some stuff
    inc esi
                ; Note cmp command on next line
    cmp esi, 10
    jle exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

(İnt i = 10; i> -1; i--) için yaparsak, bundan kurtulabilirsiniz:

    mov esi, 10
loopStartLabel:
                ; Do some stuff
    dec esi
                ; Note no cmp command on next line
    jns exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

Az önce kontrol ettim ve Microsoft'un C ++ derleyicisi bu optimizasyonu yapmıyor, ancak yaparsanız yapıyor:

for (int i = 10; i >= 0; i--) 

Öyleyse ahlaki, Microsoft C ++ † kullanıyorsanız ve artan veya azalan bir fark yaratmazsa, hızlı bir döngü elde etmek için kullanmanız gereken:

for (int i = 10; i >= 0; i--)

bunlardan biri yerine:

for (int i = 10; i > -1; i--)
for (int i = 0; i <= 10; i++)

Ancak açıkçası "for (int i = 0; i <= 10; i ++)" okunabilirliğini elde etmek normalde bir işlemci komutunu kaçırmaktan çok daha önemlidir.

† Diğer derleyiciler farklı şeyler yapabilir.

Okuması <= dizi.length-1'den daha kolay olduğundan her zaman <dizi.length kullanırım.

ayrıca <7'ye sahip ve bunun 0 dizini ile başladığını bildiğiniz göz önüne alındığında, sayının yineleme sayısı olduğu sezgisel olmalıdır.

Optimize edici bir bakış açısından bakıldığında önemli değil.

Kod stili bakış açısından bakıldığında <. Sebep:

for ( int i = 0; i < array.size(); i++ )

şundan çok daha okunaklı

for ( int i = 0; i <= array.size() -1; i++ )

ayrıca <size yineleme sayısını hemen verir.

<İçin başka bir oy, çok sayıda yanlışlıkla yapılan tek tek hataları önleyebileceğinizdir.

@Chris, .NET'te .Length'ün maliyetli olduğuna dair ifadeniz aslında doğru değil ve basit türler söz konusu olduğunda tam tersi.

int len = somearray.Length;
for(i = 0; i < len; i++)
{
  somearray[i].something();
}

aslında daha yavaştır

for(i = 0; i < somearray.Length; i++)
{
  somearray[i].something();
}

Daha sonra, çalışma zamanı tarafından optimize edilen bir durumdur. Çalışma zamanı, i dizisinin geçerli bir dizin olduğunu garanti edebildiğinden, sınır kontrolü yapılmaz. İlkinde, çalışma zamanı döngüden önce değiştirilmediğimi garanti edemez ve her dizin araması için dizide sınır kontrollerini zorlar.

Performans söz konusu olduğunda etkili bir fark yaratmaz. Bu nedenle, çözdüğünüz problem bağlamında anlaşılması daha kolay olanı kullanırdım.

Tercih ederim:

for (int i = 0; i < 7; i++)

Sanırım bu daha kolay bir şekilde "bir döngü boyunca 7 kez yineleme" anlamına geliyor.

Performans etkilerinden emin değilim - herhangi bir farkın derleneceğinden şüpheleniyorum.

Java 1.5'te şunları yapabilirsiniz:

for (int i: myArray) {
    ...
}

bu yüzden dizi durumu için endişelenmenize gerek yok.

Performans farkı olduğunu sanmıyorum. İkinci form kesinlikle daha okunaklı olsa da, son yineleme numarasını bulmak için zihinsel olarak bir tane çıkarmanız gerekmez.

DÜZENLEME: Başkalarının aynı fikirde olmadığını görüyorum. Şahsen benim için, döngü yapısında gerçek dizin numaralarını görmeyi seviyorum. Belki de bunun 0..6eşdeğer olduğunu bildiğim Perl'in sözdizimini daha çok anımsattığı içindir (0,1,2,3,4,5,6). Bir 7 görürsem, aslında indeks 7'ye asla ulaşılmadığını görmek için yanındaki operatörü kontrol etmeliyim.

"<7" sürümünü kullanın derim çünkü insanların çoğunluğunun okuyacağı şey budur - yani insanlar kodunuzu gözden kaçırırsa, yanlış yorumlayabilirler.

"<" Nin "<=" den daha hızlı olup olmadığı konusunda endişelenmem, sadece okunabilirlik için gidin.

Hız artışı için gitmek istiyorsanız, aşağıdakileri göz önünde bulundurun:

for (int i = 0; i < this->GetCount(); i++)
{
  // Do something
}

Performansı artırmak için bunu biraz yeniden düzenleyebilirsiniz:

const int count = this->GetCount();
for (int i = 0; i < count; ++i)
{
  // Do something
}

GetCount () 'un döngüden kaldırıldığına (çünkü bu her döngüde sorgulanacaktır) ve "i ++" nın "++ i" olarak değiştirilmesine dikkat edin.

C ++ ' !=da tüm STL kapsayıcılarla kullanılabilen kullanmayı tercih ediyorum . Tüm STL kapsayıcı yineleyicileri karşılaştırılamayacak kadar az değildir.

Edsger Dijkstra , 1982'de bu konuda bir makale yazdı ve alt <= i <üst:

En küçük bir doğal sayı var. Alt sınırın hariç tutulması - b) ve d) 'de olduğu gibi - en küçük doğal sayıdan, alt sınırdan başlayarak doğal olmayan sayılar alanına giren bir alt diziye yönelik kuvvetler. Bu çirkin, bu yüzden alt sınır için a) ve c) 'de olduğu gibi ≤'yi tercih ediyoruz. Şimdi en küçük doğal sayıdan başlayan alt dizileri düşünün: Üst sınırın dahil edilmesi, sıra boş olana doğru küçülene kadar ikincisini doğal olmaymaya zorlar. Bu çirkin, bu yüzden üst sınır için <a) ve d) 'yi tercih ediyoruz. Sözleşmenin a) tercih edilmesi gerektiği sonucuna vardık.

İlk olarak, 6 veya 7'yi kullanmayın.

Kullanması daha iyi:

int numberOfDays = 7;
for (int day = 0; day < numberOfDays ; day++){

}

Bu durumda kullanmaktan daha iyidir

for (int day = 0; day <= numberOfDays  - 1; day++){

}

Daha da iyisi (Java / C #):

for(int day = 0; day < dayArray.Length; i++){

}

Ve daha da iyisi (C #)

foreach (int day in days){// day : days in Java

}

Ters döngü gerçekten daha hızlıdır, ancak okunması daha zor olduğundan (diğer programcılar sizin tarafınızdan değilse), içeri girmekten kaçınmak daha iyidir. Özellikle C #, Java'da ...

Bu durumda 7'nin mantıklı olduğunu söyleyen kalabalığa katılıyorum, ancak 6'nın önemli olduğu durumda, sadece 6. dizine kadar olan nesneler üzerinde hareket ettiğinizi netleştirmek istediğinizi söyleyin, sonra <=, 6'nın görülmesini kolaylaştırdığı için daha iyidir.

Üniversiteye geri döndüğümde, bu iki işlemin CPU'daki işlem süresinde benzer olduğunu hatırlıyorum. Elbette montaj seviyesinde konuşuyoruz.

Bununla birlikte, C # veya Java'dan bahsediyorsanız, birinin diğerine göre hız artışı sağlayacağını gerçekten düşünmüyorum. Kazandığınız birkaç nanosaniye, büyük olasılıkla sunduğunuz herhangi bir karışıklığa değmez.

Şahsen, iş uygulaması açısından mantıklı olan kodu yazar ve kolay okunmasını sağlardım.

Bu, doğrudan "Yanlış Kodu Yanlış Görünmek" kategorisine girer .

Java veya C # gibi sıfır tabanlı indeksleme dillerinde insanlar koşuldaki varyasyonlara alışkındır index < count. Bu nedenle, bu fiili sözleşmeden yararlanmak, tek tek hataları daha belirgin hale getirecektir.

Performansla ilgili olarak: bellek ayak izine değecek herhangi bir iyi derleyici, sorun olmayan gibi oluşturmalıdır.

Küçük bir kenara, .Net'te bir dizi veya başka bir koleksiyonda dolaşırken,

foreach (string item in myarray)
{
    System.Console.WriteLine(item);
}

sayısal for döngüsünden daha okunaklı olması için. Bu elbette, gerçek sayaç Int'in kendisinin döngü kodunda kullanılmadığını varsayar. Performans değişikliği var mı bilmiyorum.

İ <7 yazmanın birçok iyi nedeni vardır. 7 kez yinelenen bir döngüde 7 numarasına sahip olmak iyidir. Performans fiilen aynıdır. Hemen hemen herkes i <7 yazar. Okunabilirlik için yazıyorsanız, herkesin anında tanıyacağı formu kullanın.

Her zaman tercih ettim:

for ( int count = 7 ; count > 0 ; -- count )

<Kullanmayı alışkanlık haline getirmek, bir dizi üzerinde yineleme yaparken hem siz hem de okuyucu için tutarlı olmasını sağlayacaktır. Herkesin standart bir sözleşmeye sahip olması daha kolay olacaktır. Ve 0 tabanlı dizilere sahip bir dil kullanıyorsanız, <kuraldır.

Bu neredeyse kesinlikle <ve <= arasındaki herhangi bir performans farkından daha önemlidir. Önce işlevselliği ve okunabilirliği hedefleyin, ardından optimize edin.

Diğer bir not da, i ++ yerine ++ i yapma alışkanlığı içinde olmanın daha iyi olacağıdır, çünkü getirme ve artırma geçici bir süre gerektirir ve artırma ve getirme gerektirmez. Tamsayılar için, derleyiciniz muhtemelen geçici olanı optimize edecektir, ancak yineleme türünüz daha karmaşıksa, bunu yapamayabilir.

Sihirli sayılar kullanmayın.

Neden 7? (veya bu konuda 6).

kullanmak istediğiniz numara için doğru sembolü kullanın ...

Bu durumda kullanmanın daha iyi olacağını düşünüyorum

for ( int i = 0; i < array.size(); i++ )

'<' Ve '<=' operatörleri tam olarak aynı performans maliyetidir.

'<' Operatörü bir standarttır ve sıfır tabanlı bir döngüde okunması daha kolaydır.

İ ++ yerine ++ i kullanmak, C ++ 'da performansı artırır, ancak C #' da değil - Java hakkında bilgim yok.

İnsanların gözlemlediği gibi, bahsettiğiniz iki alternatif arasında hiçbir fark yoktur. Bunu doğrulamak için JavaScript'te bazı basit kıyaslamalar yaptım.

Sonuçları burada görebilirsiniz . Bundan net olmayan şey, 1. ve 2. testlerin konumlarını değiştirirsem, bu 2 testin sonuçlarının değişmesi, bu açıkça bir hafıza sorunudur. Bununla birlikte, yinelemenin sırasını tersine çevirdiğim 3. test açıkça daha hızlı.

Herkesin dediği gibi, dizilerin dışındaki şeyler için bile 0 dizinli yineleyiciler kullanmak gelenekseldir. Her şey burada başlayıp 0bitiyorsa n-1ve alt sınırlar her zaman <=ve üst sınırlar her zaman ise <, kodu gözden geçirirken yapmanız gereken çok daha az düşünme vardır.

Harika soru. Cevabım: A tipi kullan ('<')

• Kaç tane yinelemeniz olduğunu açıkça görürsünüz (7).
• İki uç nokta arasındaki fark, aralığın genişliğidir
• Daha az karakter onu daha okunaklı hale getirir
• Daha çok , son elemanın indeksii < strlen(s) yerine toplam eleman sayısına sahip olursunuz, bu yüzden tekdüzelik önemlidir.

Diğer bir sorun, tüm bu yapıyla ilgili. içinde 3 kezi görünür , bu nedenle yanlış yazılabilir. For döngüsü yapı diyor nasıl yerine ne yapacağını . Bunu benimsemenizi öneririm:

BOOST_FOREACH(i, IntegerInterval(0,7))

Bu daha açık, aynı asm komutlarını vb. Derler. İsterseniz bana IntegerInterval kodunu sorun.

Çok fazla cevap var ... ama eklemem gereken bir şey olduğuna inanıyorum.

Tercihim, değişmez sayıların döngüde "i" nin hangi değerleri alacağını açıkça göstermesidir . Sıfır tabanlı bir dizide yineleme durumunda:

for (int i = 0; i <= array.Length - 1; ++i)

Ve sadece döngü yapıyorsanız, bir diziyi yinelemiyorsanız, 1'den 7'ye kadar saymak oldukça sezgiseldir:

for (int i = 1; i <= 7; ++i)

Okunabilirlik, siz profili çıkarana kadar performanstan üstün gelir, çünkü muhtemelen o zamana kadar derleyicinin veya çalışma zamanının kodunuzla ne yapacağını bilmiyorsunuzdur.

Bunun !=yerine de kullanabilirsiniz . Bu şekilde, başlatma sırasında bir hata yaparsanız sonsuz bir döngü elde edersiniz, bu hatanın daha erken fark edilmesine ve döngüde takılıp kalmasına neden olan herhangi bir sorunun sınırlandırılmasına neden olur (çok daha sonra bir problem yaşamak ve bulamamak yerine o).

Bence her ikisi de tamam, ama seçtiğinizde, birine ya da diğerine bağlı kalın. <= Kullanmaya alışkınsanız, <veya tersini kullanmamaya çalışın.

<= Tercih ederim, ancak sıfırdan başlayan dizinler ile çalıştığınız durumlarda, muhtemelen <= kullanmayı denerim. Yine de tamamen kişisel tercih.

Kesinlikle mantıksal bir bakış açısından, bunun eşitliği de test edecek kesin nedenden < countdaha verimli olacağını düşünmelisiniz .<= count<=