C ++의 논리 XOR 연산자?

그런 것이 있습니까? 실용적으로 필요한 것은 처음이지만 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
}

(가) 주 !이 개 동일하지 않은 양의 정수 (각각은 그래서, 부울에 값이 변환하고이를 부정 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)

A는 동안 !=기반 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

증거는 입력 및 출력에 대한 철저한 연구에서 두 테이블의 모든 입력 세트에 대해 결과가 항상 두 테이블에서 동일하다는 것을 보여줍니다.

따라서 원래 질문은 작성 방법입니다.

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

대답은

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

또는 원하는 경우 쓰기

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

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

첫 번째 부분은 A OR B이며 이는 포괄적 OR입니다. 두 번째 부분은 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);
}

정의 된대로 작동합니다. 조건은 bool 대신 BOOL을 요청하는 Objective-C 사용 여부를 감지하는 것입니다 (길이가 다릅니다!)