La valutazione del cortocircuito è C ++? [duplicare]

La valutazione del cortocircuito non è vera o falsa. Si tratta di non valutare parte di un'espressione se è possibile prevedere il risultato senza di essa. Poiché false && whatever() restituisce false indipendentemente da whatever() , non devi chiamare whatever() .

Il tuo codice non lo dimostra affatto. Semplicemente non puoi dimostrarlo con true e false . Hai bisogno di un effetto collaterale.

Dire whatever() genera un'eccezione. Ora sapremo se è stato chiamato e se non lo fosse. Puoi anche visualizzarlo sulla console.

La valutazione del cortocircuito può essere pensata in due modi. Un modo efficace per evitare il lavoro non necessario e come un modo per controllare il flusso. Dei due, il secondo è molto più significativo. Ecco un idioma comune che lo usa:

if (foo != null && foo->isValid()) {
    foo->doStuff();
}

foo->isValid() rinvierebbe un valore null e causerebbe un comportamento non definito se foo è null . Qui, la valutazione del cortocircuito impedisce semplicemente di non chiamare foo->isValid() . Può farlo perché "falso e qualsiasi cosa" rimarrà sempre falso. Quel c ++ lo fa in realtà è chiamato valutazione del cortocircuito. Funziona anche con "true or anything". Ricorda solo che valuta da sinistra a destra. Quindi usi la sinistra per controllare l'esecuzione della destra.

Il testo che hai citato è un po 'sciatto (se non altro per il fatto che && e || non sono operatori bit a bit).

Nell'espressione a && b , l'espressione b verrà valutata se e solo se l'espressione a viene valutata su true. Se a viene valutato come falso, quindi a && b verrà valutato su falso indipendentemente dal valore di b , quindi b non viene valutato affatto:

a      b      result   b is evaluated
-      -      ------   --------------
true   true   true     yes
true   false  false    yes
false  ??     false    no

Nell'espressione a || b , b verrà valutato se e solo se a viene valutato come falso. Se a è true, a || b verrà valutato su true indipendentemente dal valore di b , quindi b non viene valutato affatto:

a      b      result   b is evaluated
-      -      ------   --------------
true   ??     true     no
false  true   true     yes
false  false  false    yes

Diversamente dalla maggior parte degli operatori in C, && e || impongono una valutazione da sinistra a destra e introducono punti sequenza ( a è valutata e tutti gli effetti collaterali sono applicati prima che b sia valutata), quindi espressioni come x++ && x++ sono ben definiti.

Quando il compilatore vede l'istruzione if:

if (condition1 & condition2)

It says to itself, condition 1 is true, so now my users wants to know if condition2 is also true.....hmmmm..... condition2 is false, therefore this statement is false

Se vuoi vedere un cortocircuito, rifatta il tuo stato if:

if (condition2 & condition1)

Ora il compilatore troverà una cosa del genere:

"Ok, I have an if statement. The first argument is false. Now user wants me to 'and' it with something. But I don't even have to look at condtion1 since I'm sure this if statement evaluates to false.

Quindi il compilatore non si preoccupa nemmeno di valutare condtion1.

La valutazione del cortocircuito funziona solo nei casi in cui è possibile garantire dopo aver valutato il primo operando che il risultato finale non sarà influenzato dal secondo operando.

Quindi per && , se il primo operando valuta true , non puoi garantire logicamente il risultato e devi valutare il secondo operando (ricorda: && restituisce solo true se entrambi gli operandi sono% codice%!). Tuttavia, se il primo operando è true , possiamo saltare la valutazione del secondo operando, poiché non cambierà il risultato ( false ).

Quasi lo stesso vale per false , anche se corti su un primo operando che valuta || (poiché true restituisce || se uno degli operandi è true ).

Ciò potrebbe causare problemi (o essere abusato) quando uno o entrambi gli operandi sono chiamate di funzione, ad es. %codice%. true verrà chiamato solo se doStuff() || reportFailure() ha restituito reportFailure() . Questo a volte può causare confusione, specialmente se in seguito il codice si basa su alcuni effetti collaterali di doStuff() .

Il testo che hai citato mi convincerebbe a non permettere mai a nessuno di comprare questo libro.

& & e || sono non operatori bit a bit, sono operatori logici. & e | sono operatori bit a bit e non sono cortocircuitati.

Le operazioni di cortocircuito sono ovviamente diverse per & & e ||. Se valuti condition1 & & condition2, quindi se condition1 è false, sai che condition1 & & condition2 è false, quindi non si valuta condition2. Se condizione1 è vera, allora non conosci il risultato della & & ancora; è necessario valutare la condizione2.

Per ||, è l'esatto opposto. Se condizione1 è vera, allora condizione1 || condition2 è noto per essere vero, quindi condition2 non viene valutato. Se la condizione 1 non è vera, allora dobbiamo valutare la condizione2.

if (condition1 && condition2)

È uguale a

if (condition1 == true && condition2 == true)

Poiché il tuo codice mostra:

bool condition1 = true;
bool condition2 = false;

If statement non sarà vero, perché condition2 è false