C ++の論理XOR演算子？

そんなことありますか？それが実際に必要になったのは初めてですが、Stroustrupにリストされているものはありません。私は書くつもりです：

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

しかし、^^演算子はありません。^ここでビット単位を使用して正しい答えを得ることができますか（trueとfalseのマシン表現に関係なく）？私はミックス決して&および&&、または|そして||私はそれを行うことを躊躇して、^と^^。

bool XOR(bool,bool)代わりに自分の関数を書くほうが快適です。

!=オペレータはこの目的に役立つbool値。

真の論理XOR演算の場合、これは機能します。

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

注意!2つの等しくない正の整数（それぞれaがそうすることを、そこにブール値に変換し、それらを否定しているtrue）と評価されてしまうからですfalse。

適切な手動論理 XOR実装は、XORを使用して他の論理演算子（||および&&）の一般的な動作をどれだけ厳密に模倣したいかによって異なります。これらの演算子には2つの重要な点があります。1）短絡評価を保証する、2）シーケンスポイントを導入する、3）オペランドを1回だけ評価する。

ご存知のように、XOR評価は、結果が常に両方のオペランドに依存するため、短絡することはできません。したがって、1は問題外です。しかし、2はどうでしょうか。2を気にしない場合、正規化された（つまりbool）値の演算子!=は結果に関してXORの役割を果たします。また、!必要に応じて、オペランドをunary で簡単に正規化できます。したがって!A != !B、その点で適切なXORを実装します。

ただし、余分なシーケンスポイントを気にする場合は、XORを実装する適切な方法!=もビット単位も^適切ではありません。XOR（a、b）を正しく実行する1つの方法は、次のようになります。

a ? !b : b

これは実際に、とに「類似した」自家製XORを作成するのと同じくらい近く||なり&&ます。もちろん、これはXORをマクロとして実装する場合にのみ機能します。シーケンスは関数の引数に適用されないため、関数は機能しません。

誰かが、けれども言う各時系列点を有する唯一の理由はその可能性がある&&と||短絡評価を支援することであるので、XORは1を必要としません。これは理にかなっています。ただし、シーケンスポイントが中央にある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よりも問題を解決する優れたコードが投稿されました

MSVC 2010で機能するように、BOOL_DETAIL_OPEN / CLOSEを追加する必要があることに注意してください。

/* 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));

これは、C ++でXOR比較を作成する方法です。

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

証拠は、入力と出力を徹底的に調査すると、2つのテーブルで、すべての入力セットの結果が2つのテーブルで常に同じであることを示しています。

したがって、元の質問はどのように書くかです：

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

答えは

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

または、必要に応じて、

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

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

最初の部分はA OR Bで、これは包含的ORです。2番目の部分は、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では少なくとも太字になります）。&&代わりに "and"と "or"を使用できます||。

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を要求します（長さが異なります！）