Was bewirkt in C++, dass eine Zuweisung als wahr oder falsch ausgewertet wird, wenn sie in einer Kontrollstruktur verwendet wird?

Kann mir also jemand helfen, alle (oder die meisten relevanten) Situationen einer Aufgabe in etwas wie einem if (…) oder while (…) usw. zu erfassen?

Was ich meine ist so:

if(a = b)

oder

while(a = &c)
{
}

etc…

Wann wird es als wahr und wann als falsch bewertet? Ändert sich dies überhaupt je nach den in der Zuweisung verwendeten Typen? Was ist, wenn Zeiger im Spiel sind?

Danke.

In C++ wertet eine Zuordnung den zugeschriebenen Wert aus:

int c = 5; // evaluates to 5, as you can see if you print it out
float pi = CalculatePi(); // evaluates to the result
                          // of the call to the CalculatePi function

Also, Ihre Aussagen:

if (a = b) { }
while (a = &c) { }

sind ungefähr gleichbedeutend mit:

a = b
if (b) { }
a = &c
while (&c) { }

die gleich sind

a = b
if (a) { }
a = &c
while (a) { }

Und was ist mit denen if (a) usw., wenn sie keine booleschen Werte sind? Nun, wenn es ganze Zahlen sind, ist 0 falsch, der Rest ist wahr. Dies (ein “Null”-Wert -> falsch, der Rest -> wahr) gilt normalerweise, aber Sie sollten wirklich auf eine C++-Referenz verweisen, um sicherzugehen (beachten Sie jedoch, dass das Schreiben von if (a == 0) ist nicht viel schwieriger als if (!a), was für den Leser viel einfacher ist).

Sowieso, Sie sollten immer Nebeneffekte vermeiden, die Ihren Code verschleiern.

Du solltest noch nie tun müssen if (a = b): Sie können genau dasselbe auf andere Weise erreichen, die klarer ist und nicht wie ein Fehler aussieht (wenn ich einen Code wie lese if (a = b) Das erste, was mir in den Sinn kommt, ist, dass der Entwickler, der das geschrieben hat, einen Fehler gemacht hat; Das zweite, wenn ich dreifach überprüfe, ob es richtig ist, ist, dass ich ihn hasse! 🙂

Viel Glück

Eine Zuweisung „Operation“ gibt ebenfalls einen Wert zurück. Es ist der Typ und Wert des Ausdrucks. Bei Handhabung durch einen if Typ-Anweisung:

• while (expr)
• do … until (expr)
• if (expr)
• oder der ternäre Operator (expr) ? (wahrer Wert) : falscher Wert

expr wird ausgewertet. Wenn es nicht Null ist, ist es wahr. Wenn Null, ist es falsch.

Der Rückgabetyp der Zuweisung ist der linke Wert, der Anweisungen wie erlaubt a = b = c kompilieren. In deinem Beispiel:

while(a = &c)
{
}

Gibt wahr zurück, wenn “a” wahr ist, nachdem ihm der Wert von &c zugewiesen wurde.

In beiden Beispielen, die Sie aufgelistet haben, wird innerhalb der Klammern wahr ausgewertet, wenn a nach der Zuweisung ungleich Null ist.

In einem häufigeren Fall vergleichen Sie eine Variable mit einer Konstanten. Um dieses Problem zu vermeiden, verlangen einige Codierungsstandards, dass Sie zuerst die Konstante schreiben.

wenn (A_CONSTANT = var_a)

Dies würde vom Compiler abgefangen werden, während

wenn (var_a = A_CONSTANT)

Gewohnheit.

Eine Zuweisungsanweisung ergibt den neuen Wert der zugewiesenen Variablen (abgesehen von bizarren Überladungen von operator=). Wenn die Zuweisung in einem booleschen Kontext erfolgt, hängt es vom Typ dieses Werts ab, wie er behandelt wird. Wenn der Wert ein Bool ist, wird er natürlich als Bool behandelt. Wenn der Wert ein numerischer Wert ist, wird ein Wert ungleich Null als wahr behandelt. Wenn der Wert ein Zeiger ist, wird ein Nicht-NULL-Wert als wahr behandelt. Wenn es sich um ein Objekt handelt, versucht der Compiler, es in einen booleschen Wert umzuwandeln (z. B. operator bool). Wenn das nicht möglich ist, versucht der Compiler, das Objekt in einen Wert umzuwandeln, der in bool konvertierbar ist (z. B. ein Zeigertyp oder ein numerischer Typ wie int). Wenn schließlich keine Konvertierung durchgeführt werden muss oder mehrere Konvertierungen möglich sind (z. B. definiert das Objekt den Operator int und den Operator foo*), wird der Code nicht kompiliert.

if (a = b)
    ...

ist die Abkürzung für:

a = b;
if (a != 0)
    ...

In einer while-Anweisung aktiviert die Zuweisung innerhalb der Bedingung die TROCKEN Prinzip:

while (a = b)
{
    ...
}

ist eine Abkürzung für (beachten Sie, wie ich die Zuweisung replizieren musste, damit sie direkt vor der Bedingungsprüfung ausgeführt wird):

a = b;
while (a != 0)
{
    ...
    a = b;
}

Allerdings besteht ein klassisches Problem bei Code wie diesem darin, zu wissen, ob der Code eine Zuweisung beabsichtigt hat oder ob der Code ein „=“ vergessen hat, wenn die Absicht war, „==“ zu schreiben (d. h. sollte das gewesen sein). while (a == b).

Aus diesem Grund sollten Sie niemals nur eine einfache Zuweisung schreiben (gcc gibt eine Warnung aus, wie z. B. „Schläge Klammern um Zuweisung vor, die als Wahrheitswert verwendet wird“). Wenn Sie die Zuweisung in einer Kontrollstruktur verwenden möchten, sollten Sie sie immer mit zusätzlichen Klammern umgeben und das Ungleich explizit hinzufügen:

if ((a = b) != 0)
    ...

while ((a = b) != 0)
    ...