Sie sind auf Seite 1von 5
AND & ampersand OR | pipe NOT ~ tilde XOR ^ caret AND The bitwise

AND

&

ampersand

OR

|

pipe

NOT

~

tilde

XOR

^

caret

AND The bitwise AND may be used to perform a bit mask operation. This operation
AND
The bitwise AND may be used to perform a bit mask operation. This operation may be
used to isolate part of a string of bits, or to determine whether a particular bit is 1 or 0.
For example, given a bit pattern:
0011
To determine whether the second bit is 1, a bitwise AND is applied to it and another bit
pattern containing 1 in the second bit:
0011
AND 0010
=
0010
Since the result is 0010 (non-zero), the second bit in the original pattern was 1. Using
bitwise AND in this manner is called bit masking, by analogy to the use of masking tape
to cover, or mask, portions that should not be altered, or are not of interest. In this case,
the 0 values mask the bits that are not of interest.
The bitwise AND can also be combined with the bitwise NOT to clear bits. For example:
0110
The second bit may be cleared (i.e. set to 0) by applying the bitwise AND to this value,
along with the complement (i.e. NOT) of another value in which only the second bit is
set:
NOT 0100
= 1011
0110
AND 1011
=
0010
complement (i.e. NOT) of another value in which only the second bit is set: NOT 0100
complement (i.e. NOT) of another value in which only the second bit is set: NOT 0100
OR The bitwise OR may be used in situations where a set of bits are
OR
The bitwise OR may be used in situations where a set of bits are used as flags; the bits in
a single binary numeral may each represent a distinct Boolean variable. Applying the
bitwise OR operation to the numeral along with a bit pattern containing 1 in some
positions will result in a new numeral with those bits set. For example:
0010 (decimal 2)
can be considered as a set of four flags. The first, second, and fourth flags are not set (0);
the third flag is set (1). The first flag may be set by applying the bitwise OR to this value,
along with another value in which only the first flag is set:
0010 (decimal 2)
OR 1000 (decimal 8)
= 1010 (decimal 10)
This technique is often used to conserve Memory in programs dealing with large numbers
of Boolean values.
NOT
In many programming languages (including those in the C family), the bitwise NOT operator is
"~" (tilde). This operator must not be confused with the "logical not" operator, "!" (exclamation
point), which in C++ treats the entire value as a single Boolean—changing a true value to false,
and vice versa, and that C makes a value of 0 to 1 and a value other than 0 to 0. The "logical not"
is not a bitwise operation.
XOR
In the C programming language family, the bitwise XOR operator is "^" (caret).
Assembly language programmers sometimes use the XOR operation as a short-cut to set
the value of a register to zero. Performing XOR on a value against itself always yields
zero, and on many architectures, this operation requires fewer CPU clock cycles than the
sequence of operations that may be required to load a zero value and save it to the
register.
The bitwise XOR may also be used to toggle flags in a set of bits. Given the bit pattern,
0010
the first and third bits may be toggled simultaneously by a bitwise XOR with another
the first and third bits may be toggled simultaneously by a bitwise XOR with another bit
pattern containing 1 in the first and third positions:
0010
XOR 1010
= 1000
This technique may be used to manipulate bit patterns representing sets of Boolean
variables.
Arithmetic shift
A
left arithmetic shift by n is equivalent to multiplying by 2 n (provided the value does not
overflow), while a right arithmetic shift by n of a two's complement value is equivalent to
dividing by 2 n and rounding toward negative infinity. If the binary number is treated as ones'
complement, then the same right-shift operation results in division by 2 n and rounding toward
zero.
Logical shift
In
a logical shift, the bits that are shifted out are discarded, and zeros are shifted in (on either
end). Therefore, the logical and arithmetic left-shifts are exactly the same operation. However,
the logical right-shift inserts bits with value 0 instead of copying in the sign bit. Hence the logical
shift is suitable for unsigned binary numbers, while the arithmetic shift is suitable for signed
two's complement binary numbers.
Rotate no carry
Another form of shift is the circular shift or bit rotation. In this operation, the bits are "rotated"
as if the left and right ends of the register were joined. The value that is shifted in on the right
during a left-shift is whatever value was shifted out on the left, and vice versa. This operation is
useful if it is necessary to retain all the existing bits, and is frequently used in digital
cryptography.
Rotate through carry Rotate through carry is similar to the rotate no carry operation, but
Rotate through carry
Rotate through carry is similar to the rotate no carry operation, but the two ends of the
register are considered to be separated by the carry flag. The bit that is shifted in (on
either end) is the old value of the carry flag, and the bit that is shifted out (on the other
end) becomes the new value of the carry flag.
A single rotate through carry can simulate a logical or arithmetic shift of one position by
setting up the carry flag beforehand. For example, if the carry flag contains 0, then x
RIGHT-ROTATE-THROUGH-CARRY-BY-ONE is a logical right-shift, and if the carry flag
contains a copy of the sign bit, then x RIGHT-ROTATE-THROUGH-CARRY-BY-ONE is an
arithmetic right-shift. For this reason, some microcontrollers such as PICs just have
rotate and rotate through carry, and don't bother with arithmetic or logical shift
instructions.
Rotate through carry is especially useful when performing shifts on numbers larger than
the processor's native word size, because if a large number is stored in two registers, the
bit that is shifted off the end of the first register must come in at the other end of t he
second. With rotate-through-carry, that bit is "saved" in the carry flag during the first
shift, ready to shift in during the second shift without any extra preparation.