C ++ mantıksal XOR operatörü?

Böyle bir şey var mı? İlk kez pratik bir ihtiyaçla karşılaştım, ancak Stroustrup'ta listelenen birini göremiyorum . Yazmayı düşünüyorum:

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

Ama ^^operatör yok . ^Burada bitsel olarak kullanabilir ve doğru cevabı alabilir miyim (doğru ve yanlışın makine temsilinden bağımsız olarak)? Asla karıştırmam &ve &&ya da |ve ||bu yüzden ^ve ile yapmaktan çekinmeyin ^^.

Onun bool XOR(bool,bool)yerine kendi fonksiyonumu yazmakta daha rahat olurdum .

!=Operatör için bu amaca hizmet booldeğerler.

Gerçek bir mantıksal XOR işlemi için bu işe yarayacaktır:

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

Not !İki eşitsiz pozitif tamsayılar (her bir böylece, boolelerde değerleri vardır dönüştürmek ve onları etkisiz hale true) için değerlendirirsiniz false.

Uygun manuel mantıksal XOR uygulaması, diğer mantıksal operatörlerin ( ||ve &&) XOR'nuzla genel davranışını ne kadar taklit etmek istediğinize bağlıdır . Bu operatörler hakkında iki önemli şey vardır: 1) kısa devre değerlendirmesini garanti ederler, 2) bir dizi noktası eklerler, 3) işlenenlerini yalnızca bir kez değerlendirirler.

Anladığınız gibi XOR değerlendirmesi kısa devre yapılamaz çünkü sonuç her zaman her iki işlenene de bağlıdır. Yani 1 söz konusu değil. Peki ya 2? 2'yi umursamıyorsanız, normalleştirilmiş (yani bool) değerlerle operatör !=XOR'un işini sonuç olarak yapar. Ve işlenenler !gerekirse tekli ile kolayca normalleştirilebilir . Böylece !A != !Bbu konuda uygun XOR'u uygular.

Ancak, ekstra dizi noktasını önemsiyorsanız, !=XOR'u ^uygulamak için uygun yol ne de bitsel değildir . XOR (a, b) 'yi doğru yapmanın olası bir yolu aşağıdaki gibi görünebilir

a ? !b : b

Bu "benzer" bir ev yapımı XOR yapmaya alabilirsiniz kadar yakın aslında ||ve &&. Bu, elbette, yalnızca XOR'nuzu bir makro olarak uygularsanız çalışır. Sıralama işlevi işlevin bağımsız değişkenlerine uygulanmayacağından işlev çalışmaz.

Birisi her bir sekans noktası olmasının tek nedeni bu olsa diyebilirsiniz &&ve ||bir kısa devre değerlendirmesini destekleyen ve böylece XOR birini gerekmez. Bu aslında mantıklı. Yine de, ortada bir sekans noktası olan bir XOR'a sahip olmayı düşünmeye değer. Örneğin, aşağıdaki ifade

++x > 1 && x < 5

(en az sekanslama ile ilgili olarak) C / C ++ 'da davranış ve spesifik sonuç tanımlamıştır. Dolayısıyla, kullanıcı tanımlı mantıksal XOR'dan aynı şekilde makul bir şekilde beklenebilir .

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

Bir süre !=tabanlı XOR bu özelliği yoktur.

XOR yapmanın başka bir yolu var:

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

Hangi açıkça çalışmak için kanıtlanabilir:

#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 operatörü kısa devre yapamaz; yani bir XOR ifadesinin sonucunu sadece sol tarafındaki işleneni değerlendirerek tahmin edemezsiniz. Dolayısıyla, bir ^^sürüm sağlamak için hiçbir neden yoktur .

Sorunu daha iyi çözen bazı iyi kodlar vardı! A! =! B

MSVC 2010 üzerinde çalışması için BOOL_DETAIL_OPEN / CLOSE eklemem gerektiğini unutmayın

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

Basit kullanın:

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

İşte nasıl C ++ XOR karşılaştırma yazmak düşünüyorum:

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
}

Kanıt

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

Kanıt, girdi ve çıktıların kapsamlı bir çalışmasının, iki tabloda, her girdi seti için sonucun her iki tabloda da aynı olduğunu gösterdiğidir.

Bu nedenle, orijinal soru nasıl yazılacağıdır:

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

Cevap şu olurdu:

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

İsterseniz yazın

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

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

İlk bölüm, Kapsayıcı VEYA olan A OR B'dir; ikinci kısım, A VE B DEĞİLDİR. Birlikte A veya B alırsınız, ancak hem A hem de B elde edemezsiniz.

Bu, aşağıdaki doğruluk tablosunda kanıtlanmış XOR'u sağlayacaktır.

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

"Xor" kullanıyorum (bir anahtar kelime gibi görünüyor; Code :: Blocks'ta en azından kalınlaşıyor) tıpkı "ve" yerine &&ve "veya" yerine kullanabileceğiniz gibi ||.

if (first xor second)...

Evet, bitsel. Afedersiniz.

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

Tanımlandığı gibi çalışır. Koşullar, bool yerine BOOL isteyen Objective-C kullanıp kullanmadığınızı tespit etmektir (uzunluk farklıdır!)