Nigdy wcześniej nie widziano pętli for w C ++

Konwertowałem algorytm C ++ na C #. Natknąłem się na to for loop:

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

Nie daje błędu w C ++, ale robi to w C # (nie można przekonwertować int na bool). Naprawdę nie mogę tego rozgryźć pętli for, gdzie jest warunek?

Czy ktoś może wyjaśnić?

PS. Żeby sprawdzić, czy aby dostosować WEKTOR do LISTY, czy b.back () odpowiada b [b.Count-1]?

Stan forpętli znajduje się pośrodku - między dwoma średnikami ;.

W C ++ można umieścić prawie każde wyrażenie jako warunek: wszystko, co daje wynik zerowy, oznacza false; niezerowe oznacza true.

W twoim przypadku warunek jest taki u--: kiedy konwertujesz na C #, po prostu dodaj != 0:

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

Wiele trafnych odpowiedzi, ale myślę, że warto wypisać ich odpowiednik w pętli while.

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

Jest równa:

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

Możesz rozważyć refaktoryzację do formatu while () podczas tłumaczenia na język C #. Moim zdaniem jest to wyraźniejsze, mniej pułapka dla nowych programistów i równie wydajne.

Jak zauważyli inni - ale aby moja odpowiedź była kompletna - aby działała w C #, musisz zmienić while(u--)na while(u-- != 0).

... lub while(u-- >0)na wypadek, gdybyś zaczął negatywnie. (OK, b.size()nigdy nie będzie ujemne - ale rozważ ogólny przypadek, w którym być może coś innego zainicjowało u).

Lub, żeby było jeszcze jaśniej:

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

Lepiej być klarownym niż zwięzłym.

Warunkiem jest u--;, bo to jest w drugiej pozycji do instrukcji.

Jeśli wartość u--;jest różna od 0, zostanie zinterpretowana jako true(tj. Niejawnie rzutowana na wartość logiczną true). Jeśli zamiast tego jego wartość wynosi 0, zostanie rzutowana na false.

To bardzo zły kod .

Aktualizacja: omówiłem pisanie pętli „for” w tym poście na blogu . Jego zalecenia można podsumować w następujących akapitach:

Pętla for to praktyczna, czytelna (gdy się do niej przyzwyczaisz) i zwięzła konstrukcja, ale musisz jej dobrze używać. Ze względu na jego niezwykłą składnię używanie jej w zbyt pomysłowy sposób nie jest dobrym pomysłem.

Wszystkie części pętli for powinny być krótkie i czytelne. Nazwy zmiennych należy wybierać tak, aby były łatwe do zrozumienia.

Ten przykład wyraźnie narusza te zalecenia.

Będzie to forma Twojej pętli w języku C #.

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

Po prostu zastąp odpowiednik size () i back ().

To, co robi, odwraca listę i przechowuje w tablicy. Ale w C # mamy bezpośrednio zdefiniowaną przez system funkcję do tego. Więc nie musisz również pisać tej pętli.

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

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

to inicjalizacja.

u--

jest warunkiem.

v = p[v]

jest iteracją

Warunek jest wynikiem u--, którego jest wartościąu sprzed obniżenia wartości.

W C i C ++ an int można zamienić na bool przez niejawne wykonanie != 0porównania (0 to false, wszystko inne jest true).

b.back()to ostatni element w kontenerze, czyli b[b.size() - 1]kiedy size() != 0.

W języku C wszystko niezerowe znajduje się truew kontekstach „boolowskich”, takich jak warunek zakończenia pętli lub instrukcja warunkowa. W języku C # trzeba zrobić to sprawdzić jednoznaczne: u-- != 0.

Jak stwierdzili inni, fakt, że C ++ ma niejawne rzutowanie na wartość logiczną, oznacza, że ​​warunkowe jest u--, które będzie prawdziwe, jeśli wartość jest różna od zera.

Warto dodać, że pytając „gdzie jest warunek”, masz fałszywe założenie. W obu językach C ++ i C # (i innych językach o podobnej składni) możesz mieć pusty warunek. W tym przypadku jest zawsze wartość true, więc pętla trwa wiecznie, albo aż niektórych innych wyjść warunku (przez return, breaklub throw).

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

Rzeczywiście, dowolną część instrukcji for można pominąć, w takim przypadku po prostu nie jest wykonywana.

Ogólnie for(A; B; C){D}lub for(A; B; C)D;staje się:

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

Można pominąć jeden lub więcej z A, B, C lub D.

W rezultacie pewna przysługa for(;;) dla nieskończonych pętli. Robię to, ponieważ chociaż while(true)jest bardziej popularne, czytam to jako „dopóki prawda przestanie być prawdą”, co brzmi nieco apokaliptycznie w porównaniu z moim czytaniem for(;;) jako „na zawsze”.

To kwestia gustu, ale ponieważ nie jestem jedyną osobą na świecie, która lubi for(;;), warto wiedzieć, co to znaczy.

wszystkie odpowiedzi są prawidłowe: -

pętla for może być używana na różne sposoby w następujący sposób:

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;

W powyższym kodzie ui vsą inicjowane za pomocą b.size()i b.back().

Za każdym razem, gdy warunek jest sprawdzany, wykonuje również instrukcję dekrementacji, tj u--.

forPętla wyjdzie kiedy ubędzie 0.

Błąd napotkany w samym C # rozwiązuje wątpliwości. Pętla for wyszukuje plik

FAŁSZYWE

warunek do rozwiązania. Jak wiemy,

(BOOL) FALSE = (int) 0

ale C # nie może tego przetworzyć samodzielnie, w przeciwieństwie do C ++. Zatem warunek, którego szukasz, jest

u--

ale musisz jawnie podać warunek w C # jako

u--! = 0

lub

u--> 0

Ale nadal staraj się unikać tego rodzaju praktyk kodowania. Plik

pętla while

podana powyżej w odpowiedzi jest jedną z najbardziej uproszczonych wersji twojego

dla pętli.

Jeśli jesteś przyzwyczajony do C / C ++, ten kod nie jest trudny do odczytania, chociaż jest dość zwięzły i niezbyt świetny. Pozwólcie więc, że wyjaśnię części, które są bardziej Cismem niż czymkolwiek innym. Po pierwsze, ogólna składnia pętli C for wygląda następująco:

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

Kod inicjujący jest uruchamiany raz. Następnie warunek jest testowany przed każdą pętlą i na koniec po każdej pętli wywoływany jest przyrost. Więc w twoim przykładzie znajdziesz waruneku--

Dlaczego u--działa jako warunek w C, a nie C #? Ponieważ C niejawnie konwertuje wiele rzeczy, zbytnio jeździ i może powodować problemy. Dla liczby wszystko, co jest niezerowe, jest prawdą, a zero jest fałszem. Więc będzie odliczać od b.size () - 1 do 0. Efekt uboczny w stanie jest trochę denerwujący i lepiej byłoby umieścić go w przyrostowej części pętli for, chociaż dużo C kod to robi. Gdybym to pisał, zrobiłbym to bardziej tak:

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

Przyczyna tego jest przynajmniej dla mnie jaśniejsza. Każda część pętli for wykonuje swoją pracę i nic więcej. W oryginalnym kodzie warunkiem była modyfikacja zmiennej. Część inkrementacyjna robiła coś, co powinno znajdować się w bloku kodu itp.

Operator przecinka może również rzucać ci w pętlę. W C coś x=1,y=2wygląda jak jedna instrukcja, jeśli chodzi o kompilator i pasuje do kodu inicjalizacji. Po prostu ocenia każdą z części i zwraca wartość ostatniej. Na przykład:

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

wydrukowałby 2.