Mai visto prima in C ++ per loop

Stavo convertendo un algoritmo C ++ in C #. Mi sono imbattuto in questo per loop:

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

Non dà alcun errore in C ++, ma lo fa in C # (impossibile convertire int in bool). Non riesco davvero a capirlo per loop, dov'è la condizione?

Qualcuno può spiegare per favore?

PS. Solo per verificare, per adattare un VETTORE a un ELENCO b.back () corrisponde a b [b.Count-1]?

La condizione del forciclo è nel mezzo - tra i due punti e virgola ;.

In C ++ è OK mettere quasi ogni espressione come condizione: tutto ciò che valuta zero significa false; significa zero true.

Nel tuo caso, la condizione è u--: quando converti in C #, aggiungi semplicemente != 0:

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

Molte risposte precise, ma penso che valga la pena scrivere l'equivalente ciclo while.

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

È equivalente a:

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

Potresti considerare il refactoring nel formato while () mentre traduci in C #. Secondo me è più chiaro, meno una trappola per i nuovi programmatori ed ugualmente efficiente.

Come altri hanno fatto notare - ma per fare la mia risposta completa - per farlo funzionare in C # si avrebbe bisogno di cambiamento while(u--)a while(u-- != 0).

... o while(u-- >0)nel caso in cui inizi in modo negativo. (OK, b.size()non sarà mai negativo - ma considera un caso generale in cui forse qualcos'altro ti ha inizializzato).

Oppure, per renderlo ancora più chiaro:

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

È meglio essere chiari che essere concisi.

La condizione è u--;, perché si trova nella seconda posizione dell'istruzione for .

Se il valore di u--;è diverso da 0, verrà interpretato come true(ovvero, implicitamente inserito nel valore booleano true). Se, invece, il suo valore è 0, verrà eseguito il cast su false.

Questo è un pessimo codice .

Aggiornamento: ho discusso la scrittura di loop "for" in questo post del blog . Le raccomandazioni possono essere riassunte nei seguenti paragrafi:

Un ciclo for è un costrutto pratico, leggibile (una volta che ti ci abitui) e conciso, ma devi usarlo bene. A causa della sua sintassi non comune, usarlo in un modo troppo fantasioso non è una buona idea.

Tutte le parti del ciclo for dovrebbero essere brevi e leggibili. I nomi delle variabili dovrebbero essere scelti per facilitarne la comprensione.

Questo esempio viola chiaramente queste raccomandazioni.

Questa sarà la forma C # del tuo loop.

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

Basta sostituire l'equivalente per size () e back ().

Quello che fa è invertire l'elenco e memorizza in un array. Ma in C # abbiamo direttamente una funzione definita dal sistema per questo. Quindi non è necessario scrivere anche questo ciclo.

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

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

è l'inizializzazione.

u--

è la condizione.

v = p[v]

è l'iterazione

La condizione è il risultato di u--, che è il valore di uprima che fosse diminuito.

In C e C ++, un int è convertibile in bool implicitamente facendo un != 0confronto (0 è false, tutto il resto è true).

b.back()è l'ultimo elemento in un contenitore, ovvero b[b.size() - 1]quando size() != 0.

In C tutto ciò che è diverso da zero è truein contesti "booleani", come la condizione di fine del ciclo o un'istruzione condizionale. In C # si deve fare quel controllo esplicito: u-- != 0.

Come affermato da altri, il fatto che C ++ abbia il cast implicito in booleano significa che il condizionale è u--, il che sarà vero se il valore è diverso da zero.

Vale la pena aggiungere che hai un falso presupposto nel chiedere "dov'è il condizionale". In C ++ e C # (e in altri linguaggi con sintassi simile) puoi avere un condizionale vuoto. In questo caso restituisce sempre vero, così il ciclo continua sempre, o fino a qualche altra condizione uscite (tramite return, breako throw).

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

In effetti, qualsiasi parte dell'istruzione for può essere esclusa, nel qual caso non viene eseguita.

In generale, for(A; B; C){D}o for(A; B; C)D;diventa:

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

Uno o più di A, B, C o D possono essere esclusi.

Di conseguenza, qualche favore for(;;) per infiniti loop. Lo faccio perché mentre while(true)è più popolare, leggo che "fino a quando la verità non finisce per essere vera", che suona in qualche modo apocalittico rispetto alla mia lettura for(;;) come "per sempre".

È una questione di gusti, ma poiché non sono l'unica persona al mondo a cui piace for(;;), vale la pena sapere cosa significa.

tutte le risposte sono corrette: -

for loop può essere utilizzato in vari modi come segue:

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;

Nel codice sopra, ue vsono inizializzati con b.size()e b.back().

Ogni volta che viene verificata la condizione, viene eseguita anche un'istruzione di decremento, ovvero u--.

Il forloop uscirà quando udiventerà 0.

L'errore riscontrato in C # stesso cancella il dubbio. Il ciclo for cerca un

FALSE

condizione da terminare. E come sappiamo,

(BOOL) FALSE = (int) 0

ma C # non può elaborarlo da solo, diversamente da C ++. Quindi la condizione che stai cercando è

u--

ma devi dare esplicitamente la condizione in C # come

u--! = 0

o

u--> 0

Ma cerca ancora di evitare questo tipo di pratica di codifica. Il

mentre loop

indicato sopra in risposta è una delle versioni più semplificate del tuo

for-loop.

Se sei abituato a C / C ++ questo codice non è così difficile da leggere, anche se è piuttosto conciso e non eccezionale. Quindi lasciami spiegare le parti che sono più cismiche di ogni altra cosa. Prima di tutto, la sintassi generale di un ciclo C per appare così:

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

Il codice di inizializzazione viene eseguito una volta. Quindi la condizione viene testata prima di ogni ciclo e infine l'incremento viene chiamato dopo ogni ciclo. Quindi nel tuo esempio troverai che la condizione èu--

Perché u--funziona come condizione in C e non in C #? Perché C converte implicitamente molte cose anche bool e può causare problemi. Per un numero tutto ciò che è diverso da zero è vero e zero è falso. Quindi farà il conto alla rovescia da b.size () - da 1 a 0. Avere l'effetto collaterale nella condizione è un po 'fastidioso e sarebbe preferibile metterlo nella parte incrementale del ciclo for, anche se molto C il codice fa questo. Se lo scrivessi lo farei più in questo modo:

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

La ragione di ciò è, almeno per me, più chiara. Ogni parte del ciclo for fa il suo lavoro e nient'altro. Nel codice originale la condizione stava modificando la variabile. La parte di incremento stava facendo qualcosa che dovrebbe essere nel blocco di codice ecc.

L'operatore virgola potrebbe anche lanciarti per un ciclo. In C qualcosa di simile x=1,y=2sembra un'istruzione per quanto riguarda il compilatore e si inserisce nel codice di inizializzazione. Valuta solo ciascuna delle parti e restituisce il valore dell'ultima. Quindi per esempio:

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

stamperebbe 2.