Döngü için C ++ 'dan önce hiç görülmedi

Bir C ++ algoritması için C # dönüştürüyordum. Ben döngü için bu rastladım:

for (u = b.size(), v = b.back(); u--; v = p[v]) 
b[u] = v;

C ++ 'da hata vermez, ancak C #' da yapar (int boole dönüştürülemez). Bunu gerçekten döngü için anlayamıyorum, durum nerede?

Birisi açıklayabilir mi lütfen?

PS. Sadece kontrol etmek, bir VEKTÖR'ü bir LİSTE uyarlamak için b.back () b [b.Count-1] 'e karşılık gelir mi?

Durumu foriki noktalı virgül arasındaki - döngü ortasında ;.

C ++ 'da hemen hemen her ifadeyi koşul olarak koymak sorun değildir: sıfıra göre değerlendirilen her şey false; sıfır olmayan araçlar true.

Sizin durumunuzda, koşul u--: C # 'a dönüştürdüğünüzde şunu ekleyin != 0:

for (u = b.size(), v = b.back(); u-- != 0; v = p[v]) 
    b[u] = v; //                     ^^^^ HERE

Çok doğru cevaplar, ama sanırım while döngüsü eşdeğerini yazmaya değer.

for (u = b.size(), v = b.back(); u--; v = p[v]) 
   b[u] = v;

Şuna eşittir:

u = b.size();
v = b.back();
while(u--) {
   b[u] = v;
   v = p[v];
}

C # diline çevirirken while () biçimine yeniden bakmayı düşünebilirsiniz. Bence bu daha açık, yeni programcılar için daha az tuzak ve aynı derecede etkili.

Diğerleri işaret gibi - ama cevabım eksiksiz yapmak için - bu değişimin gerekir C # çalışması için while(u--)için while(u-- != 0).

... ya da while(u-- >0)negatif çıkmaya başlarsa. (Tamam, b.size()asla olumsuz olmayacaktır - ama belki u başka bir şey başlattı genel bir durum düşünün).

Veya daha da netleştirmek için:

u = b.size();
v = b.back();
while(u>0) {
   u--;
   b[u] = v;
   v = p[v];
}

Açık olmak, düz olmaktan daha iyidir.

Durumdur u--;bu ikinci konumda olduğu için, için talimat.

Değeri u--;0'dan farklıysa, true(yani, dolaylı olarak boole değerine çevrilir true) olarak yorumlanacaktır. Bunun yerine, değeri 0 ise, bu değere çevrilir false.

Bu çok kötü bir kod .

Güncelleme: Bu blog yazısında "for" döngülerinin yazılmasını tartıştım . Önerileri aşağıdaki paragraflarda özetlenebilir:

For loop, pratik, okunabilir (alıştıktan sonra) ve kısa bir yapıdır, ancak iyi kullanmanız gerekir. Yaygın olmayan sözdizimi nedeniyle, onu çok yaratıcı bir şekilde kullanmak iyi bir fikir değildir.

For döngüsünün tüm parçaları kısa ve okunabilir olmalıdır. Değişimi isimler anlaşılmasını kolaylaştırmak için seçilmelidir.

Bu örnek, bu önerileri açıkça ihlal etmektedir.

Bu, döngünüzün C # formu olacaktır.

// back fetches the last element of vector in c++.
for (u = b.size(), v = b.back(); (u--) != 0; v = p[v]) 
{      
  b[u] = v;      
}

Size () ve back () için eşdeğerini değiştirin.

Yaptığı şey, listeyi tersine çevirir ve bir dizide saklar. Ancak C # 'da bunun için doğrudan sistem tanımlı fonksiyona sahibiz. Yani bu döngüyü de yazmanıza gerek yok.

b = b.Reverse().ToArray();

u = b.size(), v = b.back()

başlatmadır.

u--

şarttır.

v = p[v]

yineleme mi

Durum , azaltılmadan u--önceki değeri olan sonucudur u.

C ve C ++ ile bir int olup örtük bir yaparak bool dönüştürülebilir != 0karşılaştırma (0 false, her şey olduğu true).

b.back()bir kaptaki son öğedir b[b.size() - 1], yani size() != 0.

C'de sıfır olmayan her şey truedöngü sonu koşulu veya koşullu bir ifade gibi "boole" bağlamındadır. C # 'o onay açık yapmak zorunda: u-- != 0.

Başkaları tarafından belirtildiği gibi, C ++ 'ın boole'ye dolaylı döküm yapması koşulun, u--değer sıfırdan farklı olduğunda geçerli olacağı anlamına gelir .

Eklemekte fayda var, "şartlı olanı nerede" diye sormakta yanlış bir varsayım var. Hem C ++ hem de C # 'da (ve benzer şekilde sözdizimi yapılan dillerde) boş bir koşulunuz olabilir. Bu durumda her zaman döngü sonsuza devam veya bunu, doğru olarak değerlendirilir başka koşul çıkar kadar o (via return, breakya throw).

for(int i = 0; ; ++i)
  doThisForever(i);

Aslında, for ifadesinin herhangi bir kısmı dışarıda bırakılabilir, bu durumda sadece gerçekleştirilmez.

Genel olarak for(A; B; C){D}veya for(A; B; C)D;olur:

{A}
loopBack:
if(!(B))
  goto escapeLoop;
{D}
{C}
goto loopBack;
escapeLoop:

A, B, C veya D'nin herhangi biri veya daha fazlası dışarıda bırakılabilir.

Bunun sonucu olarak, for(;;) sonsuz döngüler için bir iyilik . Çünkü while(true)daha popüler olsa da, bunu "hakikat gerçek oluncaya kadar" olarak okuyorum, bu da benim okumamla for(;;) "sonsuza dek" olarak biraz kıyamet gibi geliyor .

Bu bir zevk meselesi, ama dünyada hoşuna giden tek kişi olmadığım için for(;;)ne anlama geldiğini bilmeye değer.

tüm cevaplar doğru: -

for loop aşağıdaki gibi çeşitli şekillerde kullanılabilir:

Single Statement inside For Loop
Multiple Statements inside For Loop
No Statement inside For Loop
Semicolon at the end of For Loop
Multiple Initialization Statement inside For
Missing Initialization in For Loop
Missing Increment/Decrement Statement
Infinite For Loop
Condition with no Conditional Operator.

for (u = b.size(), v = b.back(); u--; v = p[v]) 
   b[u] = v;

Yukarıdaki kodu, uve vile başlatılır b.size()ve b.back().

Koşul her kontrol edildiğinde azalma ifadesini de çalıştırır u--.

forNe zaman döngü çıkılacak uhale gelecektir 0.

C # 'da karşılaşılan hata şüphe giderir. For-loop bir

YANLIŞ

sonlandırma koşulu. Ve bildiğimiz gibi,

(BOOL) YANLIŞ = (int) 0

ancak C # bunu C ++ 'dan farklı olarak kendi başına işleyemez. Yani aradığınız koşul

dimi

ama açıkça C # 'daki koşulu

u--! = 0

veya

u--> 0

Ama yine de bu tür kodlama uygulamalarından kaçınmaya çalışın.

döngü sırasında

Yukarıda yanıt olarak belirtilen,

döngü için.

C / C ++ 'a alışkınsanız, bu kodun okunması o kadar zor değildir, ancak oldukça tik ve kod büyük değildir. Öyleyse, her şeyden daha Cism olan parçaları açıklayayım. İlk önce bir C for loop'un genel sözdizimi şöyle görünür:

for (<initialization> ; <condition>; <increment>)
{
    <code...>
}

Başlatma kodu bir kez çalıştırılır. Daha sonra durum her döngüden önce test edilir ve son olarak her döngüden sonra artış çağrılır. Yani, örneğinizde durumunu--

Neden u--C # 'da değil C' de koşul olarak çalışır? Çünkü C bir çok şeyi dolaylı olarak bools'a dönüştürür ve belaya neden olabilir. Bir sayı için sıfır olmayan her şey doğrudur ve sıfır yanlıştır. Bu yüzden b.size () - 1'den 0'a kadar geri sayılacaktır. Durumda yan etkiye sahip olmak biraz sinir bozucu ve çok fazla C olsa da for döngüsünün artış kısmına koymak tercih edilir. kodu bunu yapar. Eğer yazıyor olsaydım bunu daha çok yaparım:

for (u = b.size() - 1, v = b.back(); u>=0; --u) 
{
    b[u] = v;
    v = p[v]
}

Bunun nedeni, en azından benim için daha açık. For döngüsünün her parçası bu işi yapar ve başka hiçbir şey yapmaz. Orijinal kodda koşul değişkeni değiştiriyordu. Artış kısmı, kod bloğunda vb. Olması gereken bir şey yapıyordu.

Virgül operatörü de sizi bir döngü için atıyor olabilir. C'de x=1,y=2derleyici söz konusu olduğunda tek bir ifadeye benziyor ve başlatma koduna uyuyor. Sadece parçaların her birini değerlendirir ve sonuncunun değerini döndürür. Yani mesela:

std::cout << "(1,2)=" << (1,2) << std::endl;

çıktı 2.