按位移位(左移或右移)有什么作用以及它的用途是什么?
我在我看过的各种代码中看到了运算符 >>
和 <<
(我实际上都不理解),但是我'我只是想知道它们实际上是做什么的以及它们的实际用途是什么。
如果移位类似于 x * 2
和 x / 2
,那么与实际使用 *
和 /< 的真正区别是什么/代码> 运算符?有性能差异吗?
I've seen the operators >>
and <<
in various code that I've looked at (none of which I actually understood), but I'm just wondering what they actually do and what some practical uses of them are.
If the shifts are like x * 2
and x / 2
, what is the real difference from actually using the *
and /
operators? Is there a performance difference?
如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱,如果其他用户或者作者回复了您的评论,将不能在第一时间通知您!
发布评论
评论(9)
这是一个小程序,您可以在其中执行一些位操作,包括移位。
你有一个位的集合,并且你将其中一些移到了它们的范围之外:
它从右侧填充了新的零。 :)
从左边开始填充。一种特殊情况是前导 1。它通常表示负值 - 取决于语言和数据类型。通常情况下,如果向右移动,第一位保持原样。
它在多次移位中是保守的:
如果你不想保留第一位,你可以使用(据我所知,在 Java、Scala、C++、C 中,也许更多)一个三重符号运算符
:在另一个方向上没有任何等价物,因为它没有任何意义 - 也许在你非常特殊的背景下,但在一般情况下没有意义。
从数学上讲,左移一次是 *=2,左移 2 次是 *=4,依此类推。右移是 a /= 2 等等。
Here is an applet where you can exercise some bit-operations, including shifting.
You have a collection of bits, and you move some of them beyond their bounds:
It is filled from the right with fresh zeros. :)
Filled from the left. A special case is the leading 1. It often indicates a negative value - depending on the language and datatype. So often it is wanted, that if you shift right, the first bit stays as it is.
And it is conserved over multiple shifts:
If you don't want the first bit to be preserved, you use (in Java, Scala, C++, C as far as I know, and maybe more) a triple-sign-operator:
There isn't any equivalent in the other direction, because it doesn't make any sense - maybe in your very special context, but not in general.
Mathematically, a left-shift is a *=2, 2 left-shifts is a *=4 and so on. A right-shift is a /= 2 and so on.
左移位乘以 2 的任意次方,右移位则除以 2 的任意次方。
例如,
x = x * 2;
也可以写成x<<1
或x = x*8
可以写成x<<3
(因为 2 的 3 次方是 8)。类似地,x = x / 2;
是x>>1
等等。Left bit shifting to multiply by any power of two and right bit shifting to divide by any power of two.
For example,
x = x * 2;
can also be written asx<<1
orx = x*8
can be written asx<<3
(since 2 to the power of 3 is 8). Similarlyx = x / 2;
isx>>1
and so on.左移
x = x * 2^value
(正常操作)x << value
(按位运算)x = x * 16
(与2^4
相同)左移等效项为
x = x << 4
右移
x = x / 2^value
(普通算术运算)x >>> value
(按位运算)x = x / 8
(与2^3
相同)右移等效项为
x =x>> 3
Left Shift
x = x * 2^value
(normal operation)x << value
(bit-wise operation)x = x * 16
(which is the same as2^4
)The left shift equivalent would be
x = x << 4
Right Shift
x = x / 2^value
(normal arithmetic operation)x >> value
(bit-wise operation)x = x / 8
(which is the same as2^3
)The right shift equivalent would be
x = x >> 3
左移:等于要移位的值与2的要移位的位数次方的乘积。
示例:
右移:它等于必须移位 2 的值的商,该商是要移位的位数次方。
例子:
Left shift: It is equal to the product of the value which has to be shifted and 2 raised to the power of number of bits to be shifted.
Example:
Right shift: It is equal to quotient of value which has to be shifted by 2 raised to the power of number of bits to be shifted.
Example:
左移位以乘以 2 的任意幂。
右移位以除以 2 的任意幂。
在 C/C++ 中可以写成:
Left bit shifting to multiply by any power of two.
Right bit shifting to divide by any power of two.
In C/C++ it can be written as,
与
/
或*
运算符相比,移位运算符的效率更高。在计算机体系结构中,除法(/)或乘法(*)需要多个时间单元和寄存器来计算结果,而移位运算符只是一个寄存器和一个时间单元计算。
The bit shift operators are more efficient as compared to the
/
or*
operators.In computer architecture, divide(/) or multiply(*) take more than one time unit and register to compute result, while, bit shift operator, is just one one register and one time unit computation.
一些示例:
1 << 4
等于2^4
即 16)<代码>1 << 4 或
1 << 5
更具可读性。Some examples:
1 << 4
equal to2^4
i.e. 16)1 << 4
or1 << 5
is more readable.是的,我认为在性能方面您可能会发现差异,因为可以使用巨大的数据集以 o(1) 的复杂度执行按位左移和右移操作。
例如,计算 2 ^ n 的幂:
使用按位左移运算的类似代码如下所示:
此外,执行按位运算就像精确复制用户级数学运算(这是处理的最终机器级指令)由微控制器和处理器)。
Yes, I think performance-wise you might find a difference as bitwise left and right shift operations can be performed with a complexity of o(1) with a huge data set.
For example, calculating the power of 2 ^ n:
Similar code with a bitwise left shift operation would be like:
Moreover, performing a bit-wise operation is like exacting a replica of user level mathematical operations (which is the final machine level instructions processed by the microcontroller and processor).
这是一个例子:
Here is an example: