wie ist x&&y||z ausgewertet?

x && y || z 

entspricht

(x && y) || z

wenn x=1 und y=2
dann x&&y ist 1 && 2 die true && true die true.

true || z 

ist immer true. z gar nicht ausgewertet

(bool)1 = true
(bool)2 = true

Nicht initialisierte int-bezieht sich auf Daten, die im Arbeitsspeicher gespeichert, wo es platziert wird auf stack... und es selten ist 0x00000000, und selbst wenn es war, true || false = true.

Können Sie denken x && y || z als äquivalent zu:

int func(int x, int y, int z) {
  if (x) {
    if (y) {
      return true;
    }
  }
  if (z) {
    return true;
  }
  return false;
}

Da beide x und y fixiert sind, um nicht-null-Werte der ersten return-Anweisung ist immer ein hit.

Auf IA32, ohne Optimierung x && y || z wird:

        movl    $1, 28(%esp)        ; store 1 in x (on stack)
        movl    $2, 24(%esp)        ; store 2 in y (on stack)
        cmpl    $0, 28(%esp)        ; compare x to 0
        je      .L6                 ; if x is 0 jump to L6
        cmpl    $0, 24(%esp)        ; compare y to 0
        jne     .L7                 ; if y is 0 jump to L7
.L6:                                ; We only get to L6 if (x && y) was false
        cmpl    $0, 20(%esp)        ; compare z to 0
        je      .L8                 ; if z is 0 jump to L8
.L7:                                ; We get to this label if either (x && y) was true
                                    ; or z was true
        movl    $1, %eax            ; copy 1 into register eax, the result
        jmp     .L9                 ; jump unconditionally to L9
.L8:                                ; We only get here if both (x && y) and z are false
        movl    $0, %eax            ; copy 0 into register eax, the result
.L9:

Sowie func wird:

        cmpl    $0, 8(%ebp)        ; compare first argument (x) with 0
        je      .L2                ; jump to L2 if it is
        cmpl    $0, 12(%ebp)       ; compare second argument (y) with 0
        je      .L2                ; jump to L2 if it is
        movl    $1, %eax           ; store 1 for the return value (via register eax)
        jmp     .L3                ; jump to L3 (done, return to caller)
.L2:                               ; if we hit this label both x and y were false
        cmpl    $0, 16(%ebp)       ; compare third argument (z) with 0
        je      .L4                ; if it is 0 jump to L4
        movl    $1, %eax           ; store 1 in register eax, which is the return value
        jmp     .L3                ; jump to L3 (return to caller)
.L4:                               ; if we get here x, y and z were all 0
        movl    $0, %eax           ; store 0 in eax to return false
.L3:

Mit Optimierungen aktiviert func() sieht sogar noch mehr wie der Ausdruck (der Rückgabewert wird nur geladen, von einem Ort, obwohl es ist verdeckt von x86-isms), aber der Ausdruck x && y || z im Grunde verschwindet, da der compiler in der Lage ist, ableiten, dessen Wert zur compile-Zeit.

Den && - operator hat eine höhere Priorität als die || Betreiber