Operatore logico XOR in C ++?

C'è una cosa del genere? È la prima volta che ne ho riscontrato un bisogno pratico, ma non ne vedo uno elencato in Stroustrup . Ho intenzione di scrivere:

// Detect when exactly one of A,B is equal to five.
return (A==5) ^^ (B==5);

Ma non c'è nessun ^^operatore. Posso usare bitwise ^qui e ottenere la risposta giusta (indipendentemente dalla rappresentazione automatica di vero e falso)? Non mescolo mai &e &&, o |e ||, quindi esito a farlo con ^e ^^.

bool XOR(bool,bool)Invece mi sentirei più a mio agio nel scrivere la mia funzione.

L' !=operatore ha questo scopo per i boolvalori.

Per una vera operazione XOR logica, questo funzionerà:

if(!A != !B) {
    // code here
}

Nota che !ci sono per convertire i valori in booleani e negarli, in modo che truevalutino due interi positivi disuguali (ciascuno a ) false.

La corretta implementazione XOR logica manuale dipende da quanto si desidera imitare il comportamento generale di altri operatori logici ( ||e &&) con il proprio XOR. Ci sono due cose importanti su questi operatori: 1) garantiscono la valutazione del corto circuito, 2) introducono un punto di sequenza, 3) valutano i loro operandi una sola volta.

La valutazione XOR, come capisci, non può essere messa in corto circuito poiché il risultato dipende sempre da entrambi gli operandi. Quindi 1 è fuori discussione. Ma che dire di 2? Se non ti importa di 2, allora con boolvalori normalizzati (cioè ) l'operatore !=fa il lavoro di XOR in termini di risultato. E gli operandi possono essere facilmente normalizzati con unario !, se necessario. In tal modo, !A != !Bimplementa l'XOR corretto in tal senso.

Ma se ti preoccupi del punto di sequenza aggiuntivo, né !=né bit a bit ^è il modo corretto di implementare XOR. Un modo possibile per eseguire correttamente XOR (a, b) potrebbe essere il seguente

a ? !b : b

Questo è in realtà il più vicino possibile a rendere uno XOR fatto in casa "simile" a ||e &&. Questo funzionerà, ovviamente, solo se si implementa XOR come macro. Una funzione non funziona, poiché il sequenziamento non si applica agli argomenti della funzione.

Qualcuno potrebbe dire, però, che l'unica ragione di avere un punto di sequenza a ciascun &&ed ||è per supportare la valutazione corto-circuito, e quindi XOR non ne ha bisogno. Questo ha senso, in realtà. Tuttavia, vale la pena considerare di avere un XOR con un punto sequenza nel mezzo. Ad esempio, la seguente espressione

++x > 1 && x < 5

ha un comportamento definito e risultati specifici in C / C ++ (almeno per quanto riguarda il sequenziamento). Quindi, ci si potrebbe ragionevolmente aspettare lo stesso dallo XOR logico definito dall'utente , come in

XOR(++x > 1, x < 5)

mentre un !=XOR a base non ha questa proprietà.

C'è un altro modo di fare XOR:

bool XOR(bool a, bool b)
{
    return (a + b) % 2;
}

Che ovviamente può essere dimostrato di funzionare tramite:

#include <iostream>

bool XOR(bool a, bool b)
{
    return (a + b) % 2;
}

int main()
{
    using namespace std;
    cout << "XOR(true, true):\t" << XOR(true, true) << endl
         << "XOR(true, false):\t" << XOR(true, false) << endl
         << "XOR(false, true):\t" << XOR(false, true) << endl
         << "XOR(false, false):\t" << XOR(false, false) << endl
         << "XOR(0, 0):\t\t" << XOR(0, 0) << endl
         << "XOR(1, 0):\t\t" << XOR(1, 0) << endl
         << "XOR(5, 0):\t\t" << XOR(5, 0) << endl
         << "XOR(20, 0):\t\t" << XOR(20, 0) << endl
         << "XOR(6, 6):\t\t" << XOR(5, 5) << endl
         << "XOR(5, 6):\t\t" << XOR(5, 6) << endl
         << "XOR(1, 1):\t\t" << XOR(1, 1) << endl;
    return 0;
}

L'operatore XOR non può essere cortocircuitato; cioè non è possibile prevedere il risultato di un'espressione XOR semplicemente valutando il suo operando di sinistra. Pertanto, non c'è motivo di fornire una ^^versione.

È stato pubblicato un buon codice che ha risolto il problema meglio di! A! =! B

Nota che ho dovuto aggiungere BOOL_DETAIL_OPEN / CLOSE in modo che funzionasse su MSVC 2010

/* From: http://groups.google.com/group/comp.std.c++/msg/2ff60fa87e8b6aeb

   Proposed code    left-to-right?  sequence point?  bool args?  bool result?  ICE result?  Singular 'b'?
   --------------   --------------  ---------------  ---------- ------------  -----------  -------------
   a ^ b                  no              no             no          no           yes          yes
   a != b                 no              no             no          no           yes          yes
   (!a)!=(!b)             no              no             no          no           yes          yes
   my_xor_func(a,b)       no              no             yes         yes          no           yes
   a ? !b : b             yes             yes            no          no           yes          no
   a ? !b : !!b           yes             yes            no          no           yes          no
   [* see below]          yes             yes            yes         yes          yes          no
   (( a bool_xor b ))     yes             yes            yes         yes          yes          yes

   [* = a ? !static_cast<bool>(b) : static_cast<bool>(b)]

   But what is this funny "(( a bool_xor b ))"? Well, you can create some
   macros that allow you such a strange syntax. Note that the
   double-brackets are part of the syntax and cannot be removed! The set of
   three macros (plus two internal helper macros) also provides bool_and
   and bool_or. That given, what is it good for? We have && and || already,
   why do we need such a stupid syntax? Well, && and || can't guarantee
   that the arguments are converted to bool and that you get a bool result.
     Think "operator overloads". Here's how the macros look like:

   Note: BOOL_DETAIL_OPEN/CLOSE added to make it work on MSVC 2010
  */

#define BOOL_DETAIL_AND_HELPER(x) static_cast<bool>(x):false
#define BOOL_DETAIL_XOR_HELPER(x) !static_cast<bool>(x):static_cast<bool>(x)

#define BOOL_DETAIL_OPEN (
#define BOOL_DETAIL_CLOSE )

#define bool_and BOOL_DETAIL_CLOSE ? BOOL_DETAIL_AND_HELPER BOOL_DETAIL_OPEN
#define bool_or BOOL_DETAIL_CLOSE ? true:static_cast<bool> BOOL_DETAIL_OPEN
#define bool_xor BOOL_DETAIL_CLOSE ? BOOL_DETAIL_XOR_HELPER BOOL_DETAIL_OPEN

Usa un semplice:

return ((op1 ? 1 : 0) ^ (op2 ? 1 : 0));

Ecco come penso che tu scriva un confronto XOR in C ++:

bool a = true;   // Test by changing to true or false
bool b = false;  // Test by changing to true or false
if (a == !b)     // THIS IS YOUR XOR comparison
{
    // do whatever
}

Prova

XOR TABLE
 a   b  XOR
--- --- ---
 T   T   F
 T   F   T
 F   T   T
 F   F   F

a == !b TABLE
 a   b  !b  a == !b
--- --- --- -------
 T   T   F     F
 T   F   T     T
 F   T   F     T
 F   F   T     F

La prova è che uno studio esaustivo di input e output mostra che nelle due tabelle, per ogni set di input il risultato è sempre identico nelle due tabelle.

Pertanto, la domanda originale è come scrivere:

return (A==5) ^^ (B==5)

La risposta sarebbe

return (A==5) == !(B==5);

O se ti piace, scrivi

return !(A==5) == (B==5);

(A || B) && !(A && B)

La prima parte è A OR B, ovvero OR inclusivo; la seconda parte è, NON A E B. Insieme ottieni A o B, ma non entrambi A e B.

Ciò fornirà lo XOR dimostrato nella tabella della verità di seguito.

|-----|-----|-----------|
|  A  |  B  |  A XOR B  |
|-----|-----|-----------|
|  T  |  T  |   False   |
|-----|-----|-----------|
|  T  |  F  |   True    |
|-----|-----|-----------|
|  F  |  T  |   True    |
|-----|-----|-----------|
|  F  |  F  |   False   |
|-----|-----|-----------|

Uso "xor" (sembra che sia una parola chiave; in Code :: Blocks almeno diventa grassetto) così come puoi usare "e" invece di &&e "o" invece di ||.

if (first xor second)...

Sì, è bit a bit. Scusate.

#if defined(__OBJC__)
    #define __bool BOOL
    #include <stdbool.h>
    #define __bool bool
#endif

static inline __bool xor(__bool a, __bool b)
{
    return (!a && b) || (a && !b);
}

Funziona come definito. I condizionali sono per rilevare se stai usando Objective-C , che richiede BOOL invece di bool (la lunghezza è diversa!)