ตัวดำเนินการ XOR แบบโลจิคัลใน C ++?

มีอะไรแบบนี้เหรอ? มันเป็นครั้งแรกที่ผมพบความจำเป็นในการปฏิบัติสำหรับมัน แต่ฉันไม่เห็นหนึ่งที่ระบุไว้ใน Stroustrup ฉันตั้งใจจะเขียน:

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

แต่ไม่มี^^ผู้ประกอบการ ฉันสามารถใช้ bitwise ^ที่นี่และได้รับคำตอบที่ถูกต้อง (ไม่ว่าจะเป็นเครื่องจริงหรือเท็จ) ฉันไม่เคยผสม&และ&&หรือ|และ||ดังนั้นฉันลังเลที่จะทำอย่างนั้นด้วยและ^^^

ฉันจะสะดวกสบายมากขึ้นการเขียนของตัวเองbool XOR(bool,bool)ฟังก์ชั่นแทน

!=ผู้ประกอบการมีจุดมุ่งหมายนี้boolค่า

สำหรับการดำเนินการ XOR แบบลอจิคัลที่เป็นจริงสิ่งนี้จะทำงาน:

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

หมายเหตุ!จะมีการแปลงค่าที่จะ booleans และปฏิเสธพวกเขาเพื่อให้จำนวนเต็มบวกที่ไม่เท่ากัน (แต่ละtrue) falseจะประเมิน

การนำ XOR เชิงตรรกะที่เหมาะสมไปใช้ขึ้นอยู่กับว่าคุณต้องการเลียนแบบพฤติกรรมทั่วไปของตัวดำเนินการเชิงตรรกะอื่น ๆ ( ||และ&&) กับ XOR ของคุณอย่างไร มีสองสิ่งที่สำคัญเกี่ยวกับตัวดำเนินการเหล่านี้: 1) พวกเขารับประกันการประเมินผลการลัดวงจร 2) พวกเขาแนะนำจุดลำดับ, 3) พวกเขาประเมินตัวถูกดำเนินการเพียงครั้งเดียว

การประเมิน XOR อย่างที่คุณเข้าใจไม่สามารถทำให้เกิดการลัดวงจรเนื่องจากผลลัพธ์ขึ้นอยู่กับตัวถูกดำเนินการทั้งสอง ดังนั้น 1 หมดคำถาม แต่ประมาณ 2 ล่ะ หากคุณไม่สนใจเกี่ยวกับ 2 แล้วด้วยปกติ (เช่นboolผู้ประกอบการ) ค่า!=ไม่งานของแฮคเกอร์ในแง่ของผล และตัวถูกดำเนินการสามารถทำให้เป็นมาตรฐานได้อย่างง่ายดายด้วย unary !หากจำเป็น ดังนั้นจึง!A != !Bใช้ XOR ที่เหมาะสมในเรื่องนั้น

แต่ถ้าคุณสนใจเกี่ยวกับจุดลำดับพิเศษนั้นไม่ว่าจะไม่ใช่!=หรือ bitwise ^เป็นวิธีที่เหมาะสมในการนำ XOR มาใช้ วิธีหนึ่งที่เป็นไปได้ในการทำ XOR (a, b) อย่างถูกต้องอาจมีลักษณะดังนี้

a ? !b : b

นี้เป็นจริงใกล้ที่สุดเท่าที่คุณจะได้รับที่จะทำให้แฮคเกอร์โฮมเมด "ที่คล้ายกัน" ไปและ|| &&วิธีนี้ใช้ได้ผลแน่นอนถ้าคุณใช้ 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 คุณจะได้ A หรือ B ร่วมกัน แต่ไม่ใช่ทั้ง A และ B

นี่จะให้ XOR ที่พิสูจน์แล้วในตารางความจริงด้านล่าง

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

ผมใช้ "แฮคเกอร์" (ดูเหมือนว่ามันเป็นคำหลักนั้นในรหัส :: บล็อกอย่างน้อยจะได้รับตัวหนา) เช่นเดียวกับที่คุณสามารถใช้ "และ" แทน&&และ "หรือ" ||แทน

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 แทนที่จะเป็นบูลหรือไม่ (ความยาวแตกต่างกัน!)