C++ Bitwise XOR

The ^ operator in C++ is the bitwise Exclusive OR (XOR) operator. It performs a logical XOR operation on each pair of corresponding bits of its two integer operands, returning a new value where each bit is set to 1 if the operand bits differ, and 0 if they are identical.

result = operand1 ^ operand2;

Bit-Level Mechanics

The operator evaluates the binary representation of the operands strictly bit-by-bit according to the following truth table:

Bit 1	Bit 2	Result (`Bit 1 ^ Bit 2`)
0	0	0
0	1	1
1	0	1
1	1	0

Type Requirements and Conversions

The ^ operator requires both operands to be of integral types (e.g., int, char, short, long, unsigned) or unscoped enumeration types. It cannot be applied to floating-point types. Before the bitwise operation is executed, C++ applies standard type conversions:

Integral Promotions: Operands smaller than int (like char or short) are promoted to int or unsigned int.
Usual Arithmetic Conversions: If the operands are of different types after promotion, they are converted to a common type (typically the larger or unsigned type) to ensure bit-width alignment.

Evaluation Example

#include <iostream>
#include <bitset>

int main() {
    unsigned char a = 0b10100101; // Decimal: 165
    unsigned char b = 0b00111100; // Decimal: 60

    // The ^ operator evaluates the bits vertically
    unsigned char result = a ^ b; 

    /* 
       Evaluation breakdown:
         10100101  (a)
       ^ 00111100  (b)

         10011001  (result) -> Decimal: 153
    */

    std::cout << std::bitset<8>(result) << '\n'; // Outputs: 10011001
    return 0;
}

Compound Assignment

C++ provides the ^= compound assignment operator, which applies the bitwise XOR operation and assigns the result directly to the left operand.

int a = 12;
int b = 5;

a ^= b; // Semantically equivalent to: a = a ^ b;

Operator Precedence

In the C++ operator precedence hierarchy, the bitwise XOR operator (^) sits:

Below the bitwise AND operator (&)
Above the bitwise OR operator (|)

It has left-to-right associativity. Because its precedence is lower than equality operators (==, !=), parentheses are strictly required when combining bitwise XOR with relational evaluations.

// Incorrect evaluation due to precedence:
if (a ^ b == c) // Evaluates as: a ^ (b == c)

// Correct evaluation:
if ((a ^ b) == c) 

Tired of Poor C++ Skills? Fix That With Deep Grasping!Learn More

Functions

Templates

Constructors

Destructors

Class Types

Class Variants

Lambdas

Coroutines

Pointers & References

Variables

Member Variables

Structured Bindings

Parameters

Error Handling

Enumerations

Namespaces

Selection Statements

Loops

Modules

Attributes

Fundamental Types

Include Directives

Comments

Memory Operators

Type Cast Operators

Access Operators

Increment & Decrement Operators

Unary Operators

Comparison Operators

Logical Operators

Conditional & Comma Operators

Arithmetic Operators

Assignment Operators

Bitwise Operators

Bit-Level Mechanics

Type Requirements and Conversions

Evaluation Example

Compound Assignment

Operator Precedence

​Bit-Level Mechanics

​Type Requirements and Conversions

​Evaluation Example

​Compound Assignment

​Operator Precedence

Bit-Level Mechanics

Type Requirements and Conversions

Evaluation Example

Compound Assignment

Operator Precedence