Toán tử XOR logic trong C ++?

Có một điều như vậy? Đây là lần đầu tiên tôi gặp phải nhu cầu thiết thực cho nó, nhưng tôi không thấy một danh sách nào được liệt kê trong Stroustrup . Tôi dự định viết:

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

Nhưng không có ^^nhà điều hành. Tôi có thể sử dụng bitwise ^ở đây và nhận được câu trả lời đúng (bất kể đại diện của máy là đúng và sai) không? Tôi không bao giờ trộn lẫn &, và &&, |và ||vì vậy, tôi ngần ngại làm điều đó với ^và ^^.

bool XOR(bool,bool)Thay vào đó tôi sẽ thoải mái hơn khi viết chức năng của riêng mình .

Các !=nhà điều hành phục vụ mục đích này cho boolcác giá trị.

Đối với một hoạt động XOR logic thực sự, điều này sẽ hoạt động:

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

Lưu ý rằng !có để chuyển đổi các giá trị thành booleans và phủ định chúng, sao cho hai số nguyên dương không bằng nhau (mỗi a true) sẽ đánh giá thành false.

Việc triển khai XOR logic thủ công đúng cách phụ thuộc vào mức độ bạn muốn bắt chước hành vi chung của các toán tử logic khác ( ||và &&) với XOR của bạn. Có hai điều quan trọng về các toán tử này: 1) chúng đảm bảo đánh giá ngắn mạch, 2) chúng giới thiệu một điểm thứ tự, 3) chúng chỉ đánh giá toán hạng của chúng một lần.

Đánh giá XOR, như bạn hiểu, không thể được ngắn mạch vì kết quả luôn phụ thuộc vào cả hai toán hạng. Vì vậy, 1 là ra khỏi câu hỏi. Nhưng còn 2 thì sao? Nếu bạn không quan tâm đến 2, thì với booltoán tử giá trị chuẩn hóa (nghĩa là ) !=thực hiện công việc của XOR về mặt kết quả. Và các toán hạng có thể dễ dàng được chuẩn hóa với unary !, nếu cần thiết. Do đó !A != !Bthực hiện XOR thích hợp trong vấn đề đó.

Nhưng nếu bạn quan tâm đến điểm chuỗi bổ sung, thì cũng không !=phải ^là cách thích hợp để thực hiện XOR. Một cách có thể để làm XOR (a, b) chính xác có thể trông như sau

a ? !b : b

Điều này thực sự gần đến mức bạn có thể tạo ra một XOR tự chế "tương tự" ||và &&. Tất nhiên, điều này sẽ chỉ hoạt động nếu bạn triển khai XOR dưới dạng macro. Một hàm sẽ không được thực hiện, vì trình tự sẽ không áp dụng cho các đối số của hàm.

Tuy nhiên, ai đó có thể nói rằng lý do duy nhất để có một điểm thứ tự ở mỗi điểm &&và ||là để hỗ trợ đánh giá ngắn mạch, và do đó XOR không cần một điểm. Điều này có ý nghĩa, thực sự. Tuy nhiên, đáng để xem xét có một XOR với một điểm thứ tự ở giữa. Ví dụ: biểu thức sau

++x > 1 && x < 5

đã xác định hành vi và kết quả cụ thể trong C / C ++ (ít nhất là liên quan đến giải trình tự). Vì vậy, người ta có thể mong đợi một cách hợp lý điều tương tự từ XOR logic do người dùng định nghĩa , như trong

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

trong khi !=XOR dựa trên cơ sở không có thuộc tính này.

Có một cách khác để làm XOR:

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

Mà rõ ràng có thể được chứng minh để làm việc thông qua:

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

Toán tử XOR không thể được ngắn mạch; tức là bạn không thể dự đoán kết quả của biểu thức XOR chỉ bằng cách đánh giá toán hạng tay trái của nó. Vì vậy, không có lý do để cung cấp một ^^phiên bản.

Có một số mã tốt được đăng đã giải quyết vấn đề tốt hơn! A! =! B

Lưu ý rằng tôi phải thêm BOOL_DETAIL_OPEN / ĐÓNG để nó hoạt động trên 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

Sử dụng đơn giản:

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

Đây là cách tôi nghĩ bạn viết một so sánh XOR trong 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
}

Bằng chứng

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

Bằng chứng là một nghiên cứu đầy đủ về đầu vào và đầu ra cho thấy rằng trong hai bảng, với mỗi bộ đầu vào, kết quả luôn giống nhau trong hai bảng.

Do đó, câu hỏi ban đầu là làm thế nào để viết:

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

Câu trả lời sẽ là

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

Hoặc nếu bạn thích, viết

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

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

Phần đầu tiên là A HOẶC B, là Bao gồm HOẶC; phần thứ hai là, KHÔNG phải A VÀ B. Cùng nhau bạn có được A hoặc B, nhưng không phải cả A và B.

Điều này sẽ cung cấp XOR đã được chứng minh trong bảng sự thật dưới đây.

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

Tôi sử dụng "xor" (có vẻ như đó là một từ khóa; trong Code :: Blocks ít nhất nó được in đậm) giống như bạn có thể sử dụng "và" thay vì &&và "hoặc" thay vì ||.

if (first xor second)...

Vâng, nó là bitwise. Lấy làm tiếc.

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

Nó hoạt động như được định nghĩa. Các điều kiện là để phát hiện nếu bạn đang sử dụng Objective-C , yêu cầu BOOL thay vì bool (độ dài là khác nhau!)