Nie zuvor gesehen C ++ for Schleife

Ich habe einen C ++ - Algorithmus in C # konvertiert. Ich bin auf diese for-Schleife gestoßen:

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

Es gibt keinen Fehler in C ++, aber in C # (int kann nicht in bool konvertiert werden). Ich kann das für die Schleife wirklich nicht herausfinden, wo ist die Bedingung?

Kann mir bitte jemand erklären?

PS. Nur um zu überprüfen, um einen VEKTOR an eine LISTE anzupassen, entspricht b.back () b [b.Count-1]?

Der Zustand der forSchleife liegt in der Mitte - zwischen den beiden Semikolons ;.

In C ++ ist es in Ordnung, fast jeden Ausdruck als Bedingung zu setzen: Alles, was als Null ausgewertet wird, bedeutet false; Nicht-Null-Mittel true.

In Ihrem Fall lautet die Bedingung u--: Wenn Sie in C # konvertieren, fügen Sie einfach Folgendes hinzu != 0:

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

Viele genaue Antworten, aber ich denke, es lohnt sich, die entsprechende while-Schleife aufzuschreiben.

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

Ist äquivalent zu:

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

Bei der Übersetzung in C # können Sie eine Umgestaltung in das while () -Format in Betracht ziehen. Meiner Meinung nach ist es klarer, für neue Programmierer weniger eine Falle und ebenso effizient.

Wie andere bereits betont haben - aber um meine Antwort zu vervollständigen -, müssten Sie zu C # wechseln while(u--), damit sie in C # funktioniert while(u-- != 0).

... oder while(u-- >0)nur für den Fall, dass du negativ anfängst. (OK, b.size()wird niemals negativ sein - aber betrachten Sie einen allgemeinen Fall, in dem vielleicht etwas anderes u initialisiert wurde).

Oder um es noch deutlicher zu machen:

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

Es ist besser klar zu sein als knapp zu sein.

Die Bedingung ist u--;, weil es sich an der zweiten Position der for- Anweisung befindet.

Wenn sich der Wert von u--;von 0 unterscheidet, wird er interpretiert als true(dh implizit in den booleschen Wert umgewandelt true). Wenn stattdessen der Wert 0 ist, wird er in umgewandelt false.

Das ist sehr schlechter Code .

Update: Ich habe das Schreiben von "for" -Schleifen in diesem Blog-Beitrag besprochen . Ihre Empfehlungen können in den folgenden Absätzen zusammengefasst werden:

Eine for-Schleife ist ein praktisches, lesbares (sobald Sie sich daran gewöhnt haben) und knappes Konstrukt, aber Sie müssen es gut verwenden. Aufgrund seiner ungewöhnlichen Syntax ist es keine gute Idee, es zu einfallsreich zu verwenden.

Alle Teile der for-Schleife sollten kurz und lesbar sein. Variablennamen sollten ausgewählt werden, um das Verständnis zu erleichtern.

Dieses Beispiel verstößt eindeutig gegen diese Empfehlungen.

Dies ist die C # -Form Ihrer Schleife.

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

Ersetzen Sie einfach das Äquivalent für Größe () und Rückseite ().

Es kehrt die Liste um und speichert sie in einem Array. Aber in C # haben wir direkt eine systemdefinierte Funktion dafür. Sie müssen diese Schleife also auch nicht schreiben.

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

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

ist Initialisierung.

u--

ist die Bedingung.

v = p[v]

ist die Iteration

Die Bedingung ist das Ergebnis von u--, was der Wert ist, ubevor er dekrementiert wurde.

In C und C ++, eine int ist umwandelbar in Bool durch implizit einen tun != 0Vergleich (0 ist false, alles andere ist true).

b.back()ist das letzte Element in einem Container, dh b[b.size() - 1]wann size() != 0.

In C befindet sich alles, was nicht Null ist, truein "booleschen" Kontexten, wie z. B. der Schleifenendbedingung oder einer bedingten Anweisung. In C # müssen Sie diese Prüfung explizit machen : u-- != 0.

Wie von anderen angegeben, bedeutet die Tatsache, dass C ++ implizites Casting in Boolesche u--Werte hat, die Bedingung , die wahr ist, wenn der Wert nicht Null ist.

Es lohnt sich hinzuzufügen, dass Sie eine falsche Annahme haben, wenn Sie fragen, wo die Bedingung ist. Sowohl in C ++ als auch in C # (und anderen ähnlich syntaxierten Sprachen) können Sie eine leere Bedingung haben. In diesem Fall wertet es immer wahr, so dass die Schleife für immer weitergeht, oder bis zu einigen anderen Zustand verlässt sie (über return, breakoder throw).

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

In der Tat kann jeder Teil der for-Anweisung weggelassen werden. In diesem Fall wird er einfach nicht ausgeführt.

Im Allgemeinen for(A; B; C){D}oder for(A; B; C)D;wird:

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

Ein oder mehrere von A, B, C oder D können weggelassen werden.

Infolgedessen einige Vorliebe for(;;) für Endlosschleifen. Ich mache das, weil ich zwar while(true)populärer bin, aber das als "bis die Wahrheit nicht mehr wahr ist" lese, was im Vergleich zu meiner Lektüre for(;;) als "für immer" etwas apokalyptisch klingt .

Es ist Geschmackssache, aber da ich nicht die einzige Person auf der Welt bin, die es mag for(;;), lohnt es sich zu wissen, was es bedeutet.

Alle Antworten sind richtig: -

Die for-Schleife kann auf verschiedene Arten wie folgt verwendet werden:

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;

Im obigen Code uund vwerden mit b.size()und initialisiert b.back().

Jedes Mal, wenn die Bedingung überprüft wird, führt sie auch eine Dekrementanweisung aus, dh u--.

Die forSchleife wird verlassen , wenn usein wird 0.

Der in C # selbst aufgetretene Fehler löscht den Zweifel. Die for-Schleife sucht nach a

FALSCH

Bedingung zu beenden. Und wie wir wissen,

(BOOL) FALSE = (int) 0

Im Gegensatz zu C ++ kann C # dies jedoch nicht alleine verarbeiten. Die Bedingung, nach der Sie suchen, ist also

u--

Sie müssen die Bedingung jedoch explizit in C # als angeben

u--! = 0

oder

u--> 0

Versuchen Sie dennoch, diese Art der Codierungspraxis zu vermeiden. Das

while-Schleife

Die oben als Antwort angegebene ist eine der einfachsten Versionen von Ihnen

for-Schleife.

Wenn Sie an C / C ++ gewöhnt sind, ist dieser Code nicht so schwer zu lesen, obwohl er ziemlich knapp und nicht so großartig ist. Lassen Sie mich also die Teile erklären, die mehr Cism als alles andere sind. Zunächst sieht die allgemeine Syntax einer C for-Schleife folgendermaßen aus:

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

Der Initialisierungscode wird einmal ausgeführt. Dann wird die Bedingung vor jeder Schleife getestet und zuletzt wird das Inkrement nach jeder Schleife aufgerufen. In Ihrem Beispiel finden Sie also die Bedingungu--

Warum u--arbeitet als Bedingung in C und nicht in C #? Weil C implizit viele Dinge zu bools konvertiert und es Probleme verursachen kann. Für eine Zahl ist alles, was nicht Null ist, wahr und Null ist falsch. Es wird also von b.size () - 1 bis 0 heruntergezählt. Der Nebeneffekt in der Bedingung ist etwas ärgerlich und es wäre vorzuziehen, ihn in den inkrementellen Teil der for-Schleife zu setzen, obwohl viel C. Code macht das. Wenn ich es schreiben würde, würde ich es eher so machen:

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

Der Grund dafür ist zumindest für mich klarer. Jeder Teil der for-Schleife erledigt seinen Job und sonst nichts. Im ursprünglichen Code wurde die Variable durch die Bedingung geändert. Der Inkrement-Teil hat etwas getan, das sich im Codeblock usw. befinden sollte.

Der Kommaoperator wirft Sie möglicherweise auch für eine Schleife. In C x=1,y=2sieht so etwas wie eine Anweisung für den Compiler aus und passt in den Initialisierungscode. Es wertet nur jedes der Teile aus und gibt den Wert des letzten zurück. Also zum Beispiel:

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

würde ausdrucken 2.