Operador XOR lógico em C ++?

Existe uma coisa dessas? É a primeira vez que encontrei uma necessidade prática, mas não vejo uma listada no Stroustrup . Eu pretendo escrever:

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

Mas não há ^^operador. Posso usar o bit a bit ^aqui e obter a resposta certa (independentemente da representação da máquina como verdadeira e falsa)? Eu nunca misturo &e &&, ou |e ||, por isso hesito em fazer isso com ^e ^^.

Eu ficaria mais confortável escrevendo minha própria bool XOR(bool,bool)função.

O !=operador serve a esse propósito para boolvalores.

Para uma verdadeira operação lógica do XOR, isso funcionará:

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

Observe que !existem para converter os valores em booleanos e negá-los, para que dois inteiros positivos desiguais (cada um true) sejam avaliados como false.

A implementação manual correta do XOR lógico depende de quão próximo você deseja imitar o comportamento geral de outros operadores lógicos ( ||e &&) com o seu XOR. Há duas coisas importantes sobre esses operadores: 1) garantem a avaliação de curto-circuito, 2) introduzem um ponto de sequência, 3) avaliam seus operandos apenas uma vez.

A avaliação do XOR, como você entende, não pode ter um curto-circuito, pois o resultado sempre depende dos dois operandos. Então, 1 está fora de questão. Mas e quanto a 2? Se você não se importa com 2, o booloperador com valores normalizados (ou seja ) !=realiza o trabalho de XOR em termos do resultado. E os operandos podem ser facilmente normalizados com unário !, se necessário. Assim, !A != !Bimplementa o XOR apropriado a esse respeito.

Mas se você se importa com o ponto extra de sequência, !=nem a bit ^a bit é a maneira correta de implementar o XOR. Uma maneira possível de executar o XOR (a, b) corretamente pode ser a seguinte

a ? !b : b

Este é realmente o mais perto que você pode começar a fazer um XOR caseiro "similar" à ||e &&. Obviamente, isso só funcionará se você implementar seu XOR como uma macro. Uma função não funciona, pois o seqüenciamento não se aplica aos argumentos da função.

Alguém pode dizer, porém, que a única razão de ter um ponto de sequência em cada um &&e ||é apoiar a avaliação em curto-circuito e, portanto, o XOR não precisa de um. Isso faz sentido, na verdade. No entanto, vale a pena considerar ter um XOR com um ponto de sequência no meio. Por exemplo, a seguinte expressão

++x > 1 && x < 5

definiu comportamento e resultado específico em C / C ++ (com relação ao seqüenciamento, pelo menos). Portanto, pode-se esperar razoavelmente o mesmo do XOR lógico definido pelo usuário , como em

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

enquanto um !=XOR baseado em não tem essa propriedade.

Há outra maneira de fazer o XOR:

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

O que obviamente pode ser demonstrado para funcionar atravé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;
}

O operador XOR não pode ter um curto-circuito; ou seja, você não pode prever o resultado de uma expressão XOR apenas avaliando seu operando esquerdo. Portanto, não há razão para fornecer uma ^^versão.

Houve um bom código postado que resolveu o problema melhor do que! A! =! B

Observe que eu tive que adicionar o BOOL_DETAIL_OPEN / CLOSE para que ele funcionasse no 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 um simples:

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

Aqui está como eu acho que você escreve uma comparação XOR em 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

A prova é que um estudo exaustivo de entradas e saídas mostra que, nas duas tabelas, para cada conjunto de entradas, o resultado é sempre o mesmo nas duas tabelas.

Portanto, a pergunta original é como escrever:

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

A resposta seria

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

Ou, se quiser, escreva

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

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

A primeira parte é A OR B, que é o OR Inclusivo; a segunda parte é, NÃO A e B. Juntos, você obtém A ou B, mas não ambos, A e B.

Isso fornecerá o XOR comprovado na tabela verdade abaixo.

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

Eu uso "xor" (parece que é uma palavra-chave; em Code :: Blocks, pelo menos, fica em negrito), assim como você pode usar "e" em vez de &&e "ou" em vez de ||.

if (first xor second)...

Sim, é bit a bit. Desculpe.

#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 definido. Os condicionais são para detectar se você está usando Objective-C , que está pedindo BOOL em vez de bool (o comprimento é diferente!)