Wie liest der Compiler diese Ausdrücke? Warum bekomme ich diese Ausgaben (alle Variablen werden als 1 initialisiert)?

Question

int x = 1 , y = 1 , z = 1 ; 

nun diese Zeilen Code überprüfen: -

cout << (++x || ++y)<<endl;  //Output 1 
cout << x <<" " << y;   // now x = 2 and y = 1 . Why 'y' is not incremented ? 

wieder Werte initialisiert auf 1

cout <<(++x && ++y)<<endl;  //Output 1 
cout << x <<" " << y;   //now x = 2 and y = 2 . Why 'y' is incremented ? 

wieder Werte initialisiert werden 1

cout << (++x ||++y && ++z)<<endl; //Output 1 
cout << x<<" "<< y<<" "<<z ;  //now x = 2 , y = 1 , z = 1.Why these outputs? 

Kann jemand erklären Wie liest der Compiler diese Codes? Ich lese über die Reihenfolge der Reihenfolge, aber ich kann nicht herausfinden, wie der Compiler auf diese Arten von Code funktioniert. Selbst eine kleine Hilfe wird geschätzt werden!

Answer 1

Es wird Kurzschluss genannt.

1) In Ihrem ersten Fall, da x Wert von 1 auf der linken Seite hat, wird die rechte Seite des Betreibers || nie (genannt, weil Ergebnis mit || in jedem Fall, falls wahr wäre) - und damit y ist nie inkrementiert.

2) Ähnlich in Ihrem zweiten Beispiel, da x ist eine auf der linken Seite, das bedeutet nichts für && - Sie müssen immer noch rechts zu bewerten, um Endergebnis zu sehen; Wenn die rechte Seite falsch ist, ist das Ergebnis falsch, andernfalls wahr. In diesem Fall werden sowohl die linke als auch die rechte Seite ausgewertet. Und Werte von x und y sind erhöht.

3) wieder in Ihrem dritten Fall durch Kurzschluss, die rechte Seite Einbeziehung y und z nie ausgeführt werden (weil x Wert 1) - daher Wert von y und z ist 1.

Hier sind einige weitere info.

Answer 2

Ich bin mir nicht sicher, was passiert, wenn Sie || und && eingeben. Dies sind beide logische or/and Operatoren. Die interessante Sache über || und && ist, dass ihre Argumente lazily ausgewertet werden. Dies wird als Kurzschluss bezeichnet. Mit anderen Worten, sobald der Compiler genügend Informationen hat, um das Endergebnis des Ausdrucks zu bestimmen, hört er auf, die Argumente zu bewerten.

cout << (++x || ++y)<<endl; 

++ x als boolean true ausgewertet. Da mit || es genügt, dass eine Seite für den gesamten Ausdruck wahr ist, wird ++y nicht ausgewertet.

cout <<(++x && ++y)<<endl; 

++ x ist immer noch wahr, so dass der Compiler wertet ++y auch, als ob die false erweist, würde der Ausdruck false sein.

Ich werde die dritte verlassen, damit Sie auf eigene Faust herausfinden.

Ich werde auch hinzufügen, dass dies eine sehr starke Funktion ist.Ohne sie würde der folgende Ausdruck dereferenzieren einen null Zeiger:

if(a!=NULL && a->val>3)... 

So wie es ist, wenn anull ist, dann die rechte Seite wird nicht ausgewertet, und a nicht dereferenziert.