Gli operatori logici di corto circuito sono obbligati? E ordine di valutazione?

Lo standard ANSI impone agli operatori logici di essere cortocircuitati, in C o C ++?

Sono confuso perché ricordo il libro di K&R che dice che il tuo codice non dovrebbe dipendere da queste operazioni in corto circuito, perché potrebbero non esserlo. Qualcuno potrebbe indicare dove nello standard si dice che le operazioni logiche sono sempre in corto circuito? Sono principalmente interessato al C ++, una risposta anche per il C sarebbe ottima.

Ricordo anche di aver letto (non ricordo dove) che l'ordine di valutazione non è strettamente definito, quindi il codice non dovrebbe dipendere o assumere che le funzioni all'interno di un'espressione vengano eseguite in un ordine specifico: entro la fine di un'istruzione tutte le funzioni a cui viene fatto riferimento sarà stato chiamato, ma il compilatore ha la libertà di selezionare l'ordine più efficiente.

Lo standard indica l'ordine di valutazione di questa espressione?

if( functionA() && functionB() && functionC() ) cout<<"Hello world";

Sì, sono richiesti cortocircuiti e ordini di valutazione per gli operatori ||e&& negli standard C e C ++.

Lo standard C ++ dice (ci dovrebbe essere una clausola equivalente nello standard C):

1.9.18

Nella valutazione delle seguenti espressioni

a && b
a || b
a ? b : c
a , b

usando il significato incorporato degli operatori in queste espressioni, c'è un punto sequenza dopo la valutazione della prima espressione (12).

In C ++ c'è una trappola extra: il corto circuito NON si applica ai tipi che sovraccaricano gli operatori ||e &&.

Nota 12: Gli operatori indicati in questo paragrafo sono gli operatori integrati, come descritto nella clausola 5. Quando uno di questi operatori è sovraccarico (clausola 13) in un contesto valido, designando così una funzione di operatore definita dall'utente, l'espressione designa una chiamata di funzione e gli operandi formano un elenco di argomenti, senza un punto di sequenza implicito tra di loro.

Di solito non è consigliabile sovraccaricare questi operatori in C ++ a meno che tu non abbia un requisito molto specifico. Puoi farlo, ma potrebbe interrompere il comportamento previsto nel codice di altre persone, specialmente se questi operatori vengono utilizzati indirettamente tramite modelli di istanza con il tipo che sovraccarica questi operatori.

La valutazione del corto circuito e l'ordine di valutazione sono uno standard semantico obbligatorio in C e C ++.

Se così non fosse, un codice come questo non sarebbe un linguaggio comune

   char* pChar = 0;
   // some actions which may or may not set pChar to something
   if ((pChar != 0) && (*pChar != '\0')) {
      // do something useful

   }

Sezione 6.5.13 Operatore logico AND della specifica C99 (collegamento PDF) dice

(4). A differenza dell'operatore binario bit a bit, l'operatore && garantisce una valutazione da sinistra a destra; esiste un punto sequenza dopo la valutazione del primo operando. Se il primo operando confronta uguale a 0, il secondo operando non viene valutato.

Analogamente, la sezione 6.5.14 OR logico operatore dice

(4) A differenza del bit per bit | operatore, il || l'operatore garantisce una valutazione da sinistra a destra; c'è un punto sequenza dopo la valutazione del primo operando. Se il primo operando confronta in modo diverso da 0, il secondo operando non viene valutato.

Formulazioni simili sono disponibili negli standard C ++, consultare la sezione 5.14 di questa bozza . Come notano gli ispettori in un'altra risposta, se si sostituisce && o ||, entrambi gli operandi devono essere valutati in quanto diventa una normale chiamata di funzione.

Sì, impone questo (sia l'ordine di valutazione che il corto circuito). Nel tuo esempio se tutte le funzioni ritornano vere, l'ordine delle chiamate è rigorosamente dalla funzione A, quindi dalla funzione B e quindi dalla funzione C. Usato per questo tipo

if(ptr && ptr->value) { 
    ...
}

Lo stesso per l'operatore virgola:

// calls a, then b and evaluates to the value returned by b
// which is used to initialize c
int c = (a(), b()); 

Si dice tra destra e sinistra operando di &&, ||, ,e tra la prima e seconda / terza operando ?:(operatore condizionale) è un "punto sequenza". Tutti gli effetti collaterali vengono valutati completamente prima di quel punto. Quindi, questo è sicuro:

int a = 0;
int b = (a++, a); // b initialized with 1, and a is 1

Nota che l'operatore virgola non deve essere confuso con la virgola sintattica usata per separare le cose:

// order of calls to a and b is unspecified!
function(a(), b());

Lo standard C ++ dice in 5.14/1:

L'operatore && raggruppa da sinistra a destra. Gli operandi vengono entrambi implicitamente convertiti in tipo bool (clausola 4). Il risultato è vero se entrambi gli operandi sono veri e falsi altrimenti. A differenza di &, && garantisce la valutazione da sinistra a destra: il secondo operando non viene valutato se il primo operando è falso.

E in 5.15/1:

Il || gruppi di operatori da sinistra a destra. Gli operandi sono entrambi implicitamente convertiti in bool (clausola 4). Restituisce vero se uno dei suoi operandi è vero e falso altrimenti. A differenza di |, || garantisce la valutazione da sinistra a destra; inoltre, il secondo operando non viene valutato se il primo operando viene valutato come vero.

Dice per entrambi accanto a quelli:

Il risultato è un bool. Tutti gli effetti collaterali della prima espressione tranne la distruzione dei provvisori (12.2) si verificano prima che la seconda espressione venga valutata.

Inoltre, 1.9/18afferma

Nella valutazione di ciascuna delle espressioni

• a && b
• a || b
• a ? b : C
• a , b

usando il significato incorporato degli operatori in queste espressioni (5.14, 5.15, 5.16, 5.18), c'è un punto di sequenza dopo la valutazione della prima espressione.

Direttamente dal buon vecchio K&R:

C garantisce che &&e ||sono valutati da sinistra a destra - vedremo presto casi in cui questo è importante.

Stai molto attento.

Per i tipi fondamentali si tratta di operatori di scelta rapida.

Ma se si definiscono questi operatori per la propria classe o tipo di enumerazione, questi non sono collegamenti. A causa di questa differenza semantica nel loro utilizzo in queste diverse circostanze, si consiglia di non definire questi operatori.

Per i tipi fondamentali operator &&e operator ||per l'ordine di valutazione è da sinistra a destra (altrimenti il ​​taglio corto sarebbe difficile :-) Ma per gli operatori sovraccarichi che si definiscono, questi sono fondamentalmente zucchero sintattico per definire un metodo e quindi l'ordine di valutazione dei parametri è non definito.

La tua domanda si riduce alla precedenza e all'associatività dell'operatore C ++ . Fondamentalmente, nelle espressioni con più operatori e senza parentesi, il compilatore costruisce l'albero delle espressioni seguendo queste regole.

Per la precedenza, quando hai qualcosa del genere A op1 B op2 C, puoi raggruppare le cose come una (A op1 B) op2 Co A op1 (B op2 C). Se op1ha una precedenza maggiore di op2, otterrai la prima espressione. Altrimenti, otterrai il secondo.

Per associatività, quando si ha qualcosa di simile A op B op C, è possibile raggruppare nuovamente i thin come (A op B) op Co A op (B op C). Se opha lasciato l'associatività, finiamo con la prima espressione. Se ha la giusta associatività, finiamo con la seconda. Questo funziona anche per gli operatori allo stesso livello di precedenza.

In questo caso particolare, &&ha una precedenza maggiore di ||, quindi l'espressione verrà valutata come(a != "" && it == seqMap.end()) || isEven .

L'ordine stesso è "da sinistra a destra" nella forma dell'albero delle espressioni. Quindi valuteremo prima a != "" && it == seqMap.end(). Se è vero, l'intera espressione è vera, altrimenti andiamo a isEven. Ovviamente la procedura si ripete in modo ricorsivo all'interno della sottoespressione di sinistra.

Idee interessanti, ma il concetto di precedenza ha le sue radici nella notazione matematica. La stessa cosa accade in a*b + c, dove *ha una precedenza più alta di +.

Ancora più interessante / oscuro, per un'espressione senza paragoni A1 op1 A2 op2 ... opn-1 An, in cui tutti gli operatori hanno la stessa precedenza, il numero di alberi di espressioni binarie che potremmo formare è dato dai cosiddetti numeri catalani . Per grandi n, questi crescono estremamente velocemente. d

Se ti fidi di Wikipedia:

[ &&e ||] sono semanticamente distinti dagli operatori bit-saggi & e | perché non valuteranno mai l'operando giusto se il risultato può essere determinato solo da sinistra

C (linguaggio di programmazione)