Compound Bitwise Operators (&=
, |=
, ^=
)¶
The compound bitwise operators perform their calculations at the bit level of variables. They are often used to clear and set specific bits of a variable.
See the bitwise math tutorial for more information on bitwise operators.
Compound bitwise AND (&=
)¶
The compound bitwise AND operator &=
is often used with a variable
and a constant to force particular bits in a variable to be zero. This
is often referred to in programming guides as “clearing” or
“resetting” bits. In a program, writing the line x &= y;
is
equivalent to writing x = x & y;
. That is, the value of x
after the line will be equal to its old value bitwise ANDed with the
value of y
:
x &= y; // equivalent to x = x & y;
You can use any integer variable for x
(i.e., any variable of type
int
, char
, byte
, long long
, etc.). You can use either
an integer variable or any integer value (like 3
or 0x20
) for y
.
Before doing an example of &=
, let’s first review the Bitwise AND
(&
) operator:
0 0 1 1 operand1
0 1 0 1 operand2
----------
0 0 0 1 (operand1 & operand2) = result
As shown above, bits that are “bitwise ANDed” with 0 become 0, while
bits that are “bitwise ANDed” with 1 are left unchanged. So, if b
is a byte
variable, then b & B00000000
equals zero, and b &
B11111111
equals b
.
Note
The above uses binary constants. The numbers are still the same value in other representations, they just might not be as easy to understand.
Normally, in C and C++ code, hexadecimal or octal are used when we’re interested in an integer’s bits, rather than its value as a number.
While hexadecimal and octal literals might be harder to understand at first, you should really take the time to learn them. They’re part of C, C++, and many other programming languages, while binary constants are available only for compatibility with Arduino.
Also, B00000000
is shown for clarity, but zero in any number
format is zero.
So, to clear (set to zero) bits 0 and 1 of a one-byte variable, while
leaving the rest of the variable’s bits unchanged, use the compound
bitwise AND operator &=
with the constant B11111100
(hexadecimal 0xFC
):
1 0 1 0 1 0 1 0 variable
1 1 1 1 1 1 0 0 mask
----------------------
1 0 1 0 1 0 0 0
^^^^^^^^^^^^^^^^ ^^^^
unchanged cleared
Here is the same representation with the variable’s bits replaced
with the symbol x
x x x x x x x x variable
1 1 1 1 1 1 0 0 mask
----------------------
x x x x x x 0 0
^^^^^^^^^^^^^^^^ ^^^^
unchanged cleared
So, using a byte variable b
, if we say:
b = B10101010; // B10101010 == 0xAA
b &= B11111100; // B11111100 == 0xFC
then we will have
b == B10101000; // B10101000 == 0xA8
Compound bitwise OR (|=
)¶
The compound bitwise OR operator |=
is often used with a variable
and a constant to “set” (set to 1) particular bits in a variable. In
a program, writing the line x |= y;
is equivalent to writing x =
x | y;
. That is, the value of x
after the line will be equal to
its old value bitwise ORed with the value of y
:
x |= y; // equivalent to x = x | y;
You can use any integer variable for x
(i.e., any variable of type
int
, char
, long long
etc.). You can use either an integer
variable or any integer value (like 3
or 0x20
) for y
.
(This works the same way as compound bitwise AND, &=
).
Before doing an example of |=
, let’s first review the Bitwise OR
(|
) operator:
0 0 1 1 operand1
0 1 0 1 operand2
----------
0 1 1 1 (operand1 | operand2) = result
Bits that are “bitwise ORed” with 0 are unchanged, while bits that are
“bitwise ORed” with 1 are set to 1. So if b
is a byte
variable, then b | B00000000
equals b
, and b & B11111111
equals B11111111
(here we’ve used binary constants; see the
note above).
So, to set bits 0 and 1 of a one-byte variable, while leaving the rest
of the variable unchanged, use the compound bitwise OR operator
(|=
) with the constant B00000011
(hexadecimal 0x3
):
1 0 1 0 1 0 1 0 variable
0 0 0 0 0 0 1 1 mask
----------------------
1 0 1 0 1 0 1 1
^^^^^^^^^^^^^^^^ ^^^^
unchanged set
Here is the same representation with the variable’s bits replaced with
the symbol x
:
x x x x x x x x variable
0 0 0 0 0 0 1 1 mask
----------------------
x x x x x x 1 1
^^^^^^^^^^^^^^^^ ^^^^
unchanged set
So, using a byte variable b
, if we say:
b = B10101010; // B10101010 == 0xAA
b |= B00000011; // B00000011 == 0x3
then we will have
b == B10101011; // B10101011 == 0xAB
Compound bitwise XOR (^=
)¶
The compound bitwise XOR operator ^=
is used with a variable and a
constant to “toggle” (change 0 to 1, and 1 to 0) particular bits in a
variable. In a program, writing the line x ^= y;
is equivalent to
writing x = x ^ y;
. That is, the value of x
after the line
will be equal to its old value bitwise XORed with the value of y
:
x ^= y; // equivalent to x = x ^ y;
You can use any integer variable for x
(i.e., any variable of type
int
, char
, long long
, etc.). You can use either an
integer variable or any integer value (like 3
or 0x20
) for
y
. (This works the same way as &= and |=;
in fact, these three operators all work the same in this way).
Before doing an example of ^=
, let’s first review the Bitwise
XOR operator, ^
:
0 0 1 1 operand1
0 1 0 1 operand2
----------
0 1 1 0 (operand1 ^ operand2) = result
One way to look at bitwise XOR is that each bit in the result is a 1 if the input bits are different, or 0 if they are the same. Another way to think about it is that the result bit will be 1 when exactly one (no more, no less) of the input bits is 1; otherwise, it will be zero. This means that if you XOR a bit with 1, it will change (or toggle) its value, while if you XOR a bit with 0, it stays the same.
So, to toggle bits 0 and 1 of a one-byte variable, while leaving the
rest of the variable unchanged, use the compound bitwise XOR operator
^=
with the constant B00000011
(hexadecimal 0x3
; see
note above):
1 0 1 0 1 0 1 0 variable
0 0 0 0 0 0 1 1 mask
----------------------
1 0 1 0 1 0 1 1
^^^^^^^^^^^^^^^^ ^^^^
unchanged toggled
So, using a byte variable b
, if we say:
b = B10101010; // B10101010 == 0xAA
b ^= B00000011; // B00000011 == 0x3
then we will have
b == B10101001; // B10101001 == 0xA9
See Also¶
- Boolean operations (
&&
,||
) - Bitwise operators (
&
,|
,^
,~
)
License and Attribution
This documentation page was adapted from the Arduino Reference Documentation, which is released under a Creative Commons Attribution-ShareAlike 3.0 License.