Qual è l'output di "cout << (a, b)" e perché?

Question

È possibile combinare espressioni booleane con un separatore di virgola. L'ho visto in un codice e non sono sicuro di cosa questo risolva. Ho scritto un codice di esempio.

int BoolStatement(void) 
{ 
    using std::cout; 
    using std::endl; 

    cout << "(0, 0) => " << (0, 0) << endl; 
    cout << "(0, 1) => " << (0, 1) << endl; 
    cout << "(1, 0) => " << (1, 0) << endl; 
    cout << "(1, 1) => " << (1, 1) << endl; 
    cout << "(0, 0) => " << (0, 0) << endl; 
    cout << "(0, 3) => " << (0, 3) << endl; 
    cout << "(5, 0) => " << (5, 0) << endl; 
    cout << "(7, 1) => " << (7, 1) << endl; 

    cout << endl; 
    return 0; 
} 

L'output di questo è:

(0, 0) => 0 
(0, 1) => 1 
(1, 0) => 0 
(1, 1) => 1 
(0, 0) => 0 
(0, 3) => 3 
(5, 0) => 0 
(7, 1) => 1 

Non sono sicuro se questo è vero solo per il mio sistema e se questa chiamata è in realtà la stessa come una combinazione booleana di dichiarazioni.

Qual è l'output, è lo stesso su tutti i sistemi? Perché questa affermazione è possibile e c'è documentazione?

Answer 1

Qual è l'output, è lo stesso su tutti i sistemi?

L'output è come descritto: il secondo dei due valori. È ben definito.

Perché questa affermazione è possibile?

perché l'operatore virgola consente di valutare più di una cosa in una singola espressione.

c'è documentazione?

E 'documentato nello standard C++, [expr.comma]. In C++ 11, è 5.18.

In sintesi, l'operatore virgola:

• valuta l'espressione prima della virgola;
• scarta tale valore;
• valuta l'espressione dopo la virgola;
• restituisce tale valore come valore di espressione generale.

Puoi vedere quello dal tuo output: in ogni caso, l'output è il valore dopo la virgola.

In questo caso è completamente inutile; ma è utile se la prima espressione ha effetti collaterali che si desidera eseguire in sequenza prima del secondo, in una situazione che consente solo un'espressione singola. Ad esempio:

L'operatore consente all'espressione finale di eseguire due operazioni, anche se è possibile inserire solo un'espressione lì.

Answer 2

L'operatore virgola restituisce il lato destro.

Wikipedia:

Nel linguaggi di programmazione C e C++, l'operatore virgola (rappresentato dal token,) è un operatore binario che valuta il suo primo operando e scarta il risultato, e quindi valuta il secondo operando e restituisce questo valore (e digita).

Answer 3

Questo perché restituisce l'ultimo valore della sequenza di espressione, nei tuoi esempi:

cout << "(0, 1) => " << (0, 1) << endl; 
1-------------------------------^ 
    cout << "(1, 0) => " << (1, 0) << endl; 
0-------------------------------^ 
    cout << "(1, 1) => " << (1, 1) << endl; 
1-------------------------------^ 
    cout << "(0, 0) => " << (0, 0) << endl; 
0-------------------------------^ 
    cout << "(0, 3) => " << (0, 3) << endl; 
3-------------------------------^ 
    cout << "(5, 0) => " << (5, 0) << endl; 
0-------------------------------^ 
    cout << "(7, 1) => " << (7, 1) 
1-------------------------------^ 

Answer 4

Un'espressione che assomiglia a questo

(a, b) 

è un comma expression, il suo valore è il risultato è l'operando più a destra, ovvero

(a, b, ..., z) 

produrrebbe il valore di z.

Si noti che tutte le espressioni nella catena vengono valutate, compresi questi con effetti . Inoltre, la virgola funge da punto di sequenza , il che significa che gli effetti collaterali vengono applicati prima di valutare l'operando successivo.

Answer 5

In C++, un operatore virgola fornisce al compilatore l'ordine di valutazione. Di solito il compilatore è libero di valutare qualsiasi espressione nel modo desiderato. Ma l'operatore virgola valuta il suo operando di sinistra prima dell'operando di destra e restituisce il valore dell'operando di destra.

In una catena di operandi collegati dall'operatore virgola, il valore restituito è l'operando più a destra.