Operador XOR lógico en C ++?

¿Hay tal cosa? Es la primera vez que encuentro una necesidad práctica, pero no veo una lista en Stroustrup . Tengo la intención de escribir:

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

Pero no hay ^^operador. ¿Puedo usar bitwise ^aquí y obtener la respuesta correcta (independientemente de la representación de máquina de verdadero y falso)? Nunca mezclo &y &&, o |y ||, así que dudo en hacer eso con ^y ^^.

Me sentiría más cómodo escribiendo mi propia bool XOR(bool,bool)función en su lugar.

El !=operador cumple este propósito para los boolvalores.

Para una verdadera operación XOR lógica, esto funcionará:

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

Tenga en cuenta que !están allí para convertir los valores en booleanos y negarlos, de modo que dos enteros positivos desiguales (cada uno a true) se evaluarían false.

La implementación adecuada de XOR lógico manual depende de cuán estrechamente desee imitar el comportamiento general de otros operadores lógicos ( ||y &&) con su XOR. Hay dos cosas importantes sobre estos operadores: 1) garantizan la evaluación de cortocircuito, 2) introducen un punto de secuencia, 3) evalúan sus operandos solo una vez.

La evaluación XOR, como comprenderá, no se puede cortocircuitar ya que el resultado siempre depende de ambos operandos. Entonces 1 está fuera de cuestión. ¿Pero qué hay de 2? Si no le importan 2, entonces, con boolvalores normalizados (es decir , el operador) !=hace el trabajo de XOR en términos del resultado. Y los operandos se pueden normalizar fácilmente con unario !, si es necesario. Por lo tanto, !A != !Bimplementa el XOR adecuado en ese sentido.

Pero si le importa el punto de secuencia adicional, ni la manera adecuada de implementar XOR es !=ni bit a bit ^. Una posible forma de hacer XOR (a, b) correctamente podría tener el siguiente aspecto

a ? !b : b

En realidad, esto es lo más cerca que puede llegar a hacer un XOR casero "similar" a ||y &&. Esto solo funcionará, por supuesto, si implementa su XOR como una macro. Una función no funcionará, ya que la secuencia no se aplicará a los argumentos de la función.

Sin embargo, alguien podría decir que la única razón de tener un punto de secuencia en cada uno &&y ||es apoyar la evaluación de cortocircuito, y por lo tanto, XOR no necesita uno. Esto tiene sentido, en realidad. Sin embargo, vale la pena considerar tener un XOR con un punto de secuencia en el medio. Por ejemplo, la siguiente expresión

++x > 1 && x < 5

tiene un comportamiento definido y un resultado específico en C / C ++ (con respecto a la secuencia al menos). Entonces, uno podría esperar razonablemente lo mismo de XOR lógico definido por el usuario , como en

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

mientras que un !=XOR basado en no tiene esta propiedad.

Hay otra forma de hacer XOR:

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

Que obviamente se puede demostrar que funciona a través de:

#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;
}

El operador XOR no se puede cortocircuitar; es decir, no puede predecir el resultado de una expresión XOR simplemente evaluando su operando izquierdo. Por lo tanto, no hay razón para proporcionar una ^^versión.

Hubo un buen código publicado que resolvió el problema mejor que! A! =! B

Tenga en cuenta que tuve que agregar BOOL_DETAIL_OPEN / CLOSE para que funcione en 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

Use un simple:

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

Así es como creo que escribes una comparación XOR en 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
}

Prueba

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 prueba es que un estudio exhaustivo de entradas y salidas muestra que en las dos tablas, para cada conjunto de entradas, el resultado es siempre el mismo en las dos tablas.

Por lo tanto, la pregunta original es cómo escribir:

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

La respuesta seria

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

O si quieres, escribe

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

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

La primera parte es A OR B, que es el OR inclusivo; la segunda parte es, NO A Y B. Juntos, obtienes A o B, pero no tanto A como B.

Esto proporcionará el XOR probado en la tabla de verdad a continuación.

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

Uso "xor" (parece que es una palabra clave; en Code :: Blocks al menos se pone en negrita) así como puedes usar "y" en lugar de &&y "o" en lugar de ||.

if (first xor second)...

Sí, es bit a bit. Lo siento.

#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);
}

Funciona como se define. Los condicionales son para detectar si está utilizando Objective-C , que solicita BOOL en lugar de bool (¡la longitud es diferente!)