1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
.. _arduino-bitshift:
bitshift left (<<), bitshift right (>>)
=======================================
Description
-----------
From *The Bitmath Tutorial* in The Playground
There are two bit shift operators in C++: the left shift operator
<< and the right shift operator >>. These operators cause the bits
in the left operand to be shifted left or right by the number of
positions specified by the right operand.
More on bitwise math may be found
`here. <http://www.arduino.cc/playground/Code/BitMath>`_
Syntax
------
variable << number\_of\_bits
variable >> number\_of\_bits
Parameters
----------
variable - (byte, int, long) number\_of\_bits integer <= 32
Example:
--------
::
int a = 5; // binary: 0000000000000101
int b = a << 3; // binary: 0000000000101000, or 40 in decimal
int c = b >> 3; // binary: 0000000000000101, or back to 5 like we started with
When you shift a value x by y bits (x << y), the leftmost y bits in
x are lost, literally shifted out of existence:
::
int a = 5; // binary: 0000000000000101
int b = a << 14; // binary: 0100000000000000 - the first 1 in 101 was discarded
If you are certain that none of the ones in a value are being
shifted into oblivion, a simple way to think of the left-shift
operator is that it multiplies the left operand by 2 raised to the
right operand power. For example, to generate powers of 2, the
following expressions can be employed:
::
1 << 0 == 1
1 << 1 == 2
1 << 2 == 4
1 << 3 == 8
...
1 << 8 == 256
1 << 9 == 512
1 << 10 == 1024
...
When you shift x right by y bits (x >> y), and the highest bit in x
is a 1, the behavior depends on the exact data type of x. If x is
of type int, the highest bit is the sign bit, determining whether x
is negative or not, as we have discussed above. In that case, the
sign bit is copied into lower bits, for esoteric historical
reasons:
::
int x = -16; // binary: 1111111111110000
int y = x >> 3; // binary: 1111111111111110
This behavior, called sign extension, is often not the behavior you
want. Instead, you may wish zeros to be shifted in from the left.
It turns out that the right shift rules are different for unsigned
int expressions, so you can use a typecast to suppress ones being
copied from the left:
::
int x = -16; // binary: 1111111111110000
int y = (unsigned int)x >> 3; // binary: 0001111111111110
If you are careful to avoid sign extension, you can use the
right-shift operator >> as a way to divide by powers of 2. For
example:
::
int x = 1000;
int y = x >> 3; // integer division of 1000 by 8, causing y = 125.
|
