Логічний оператор XOR в C ++?

Чи є таке? Це перший раз, коли я зіткнувся з практичною потребою в цьому, але я не бачу жодної, переліченої в Stroustrup . Я маю намір написати:

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

Але ^^оператора немає . Чи можу я тут скористатися побітним способом ^і отримати правильну відповідь (незалежно від машинного подання істинного та хибного)? Я ніколи не змішую &і &&, або, |і ||, тому вагаюся робити це з ^і ^^.

Мені було б зручніше bool XOR(bool,bool)замість цього писати власну функцію.

!=Оператор цієї мети служить для boolзначень.

Для справжньої логічної операції XOR це спрацює:

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

Зауважте, що !є для перетворення значень в булеві та заперечення їх, щоб два нерівні додатні цілі числа (кожне a true) оцінювали false.

Правильна логічна реалізація XOR залежить від того, наскільки тісно ви хочете імітувати загальну поведінку інших логічних операторів ( ||і &&) з вашим XOR. У цих операторів є дві важливі речі: 1) вони гарантують оцінку короткого замикання, 2) вводять точку послідовності, 3) оцінюють свої операнди лише один раз.

Як ви розумієте, оцінка XOR не може бути короткою, оскільки результат завжди залежить від обох операндів. Отже, 1 не викликає сумніву. А як щодо 2? Якщо вам не байдуже 2, boolоператор із нормалізованими (тобто ) значеннями !=виконує роботу XOR з точки зору результату. І операнди можна легко нормалізувати з одинарними !, якщо це необхідно. Таким чином !A != !Bреалізується належний XOR в цьому відношенні.

Але якщо ви хвилюєтесь додатковою точкою послідовності, ні, !=ні бітовий ^спосіб не є правильним способом реалізації XOR. Один з можливих способів правильно зробити XOR (a, b) може виглядати наступним чином

a ? !b : b

Це насправді настільки близько, як ви можете зробити так, щоб зробити домашній XOR «подібним» до ||та &&. Це буде працювати, звичайно, якщо ви реалізуєте XOR як макрос. Функція не буде виконувати, оскільки послідовність не застосовуватиметься до аргументів функції.

Хто - то може сказати , однак, що єдиною причиною , що має точку послідовності на кожному &&і ||є підтримка короткозамкненим оцінки, і , таким чином , XOR не потрібен. Це має сенс, власне. Тим не менш, варто подумати про те, що в середині є XOR з точкою послідовності. Наприклад, наступний вираз

++x > 1 && x < 5

визначає поведінку та конкретний результат у C / C ++ (щонайменше щодо послідовності). Отже, можна з розумом очікувати того ж від визначеного користувачем логічного XOR, як у

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

в той час як !=XOR на базі не має цього властивості.

Є ще один спосіб зробити XOR:

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

Що, очевидно, можна продемонструвати для роботи через:

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

Оператор XOR не може бути короткозамкненим; тобто ви не можете передбачити результат вираження XOR, просто оцінивши його операнд лівої руки. Таким чином, немає жодної причини надати ^^версію.

Був розміщений хороший код, який вирішив проблему краще, ніж! A! =! B

Зауважте, що мені довелося додати BOOL_DETAIL_OPEN / CLOSE, щоб це працювало на 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

Використовуйте просте:

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

Ось як я думаю, ви пишете порівняння XOR в 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
}

Доказ

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

Підтвердженням цього є те, що вичерпне вивчення входів та результатів показує, що в двох таблицях для кожного вхідного набору результат завжди однаковий у двох таблицях.

Тому оригінальним питанням було як написати:

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

Відповідь була б

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

Або якщо вам подобається, пишіть

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

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

Перша частина - АБО В, яка є Включно АБО; друга частина - НЕ А І В. Разом ви отримуєте A або B, але не A і B.

Це дасть XOR, доведений в таблиці правди нижче.

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

Я використовую "xor" (здається, це ключове слово; у Code :: Blocks принаймні він стає жирним) так само, як ви можете використовувати "і" замість &&і "або" замість ||.

if (first xor second)...

Так, це побіжно. Вибачте.

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

Він працює як визначено. Умовами є виявлення, якщо ви використовуєте Objective-C , який запитує BOOL замість bool (довжина різна!)