blocks|key|1418469|text|我仍然为硬件中没有浮点支持的系统编写代码。在这些系统中，几乎所有的算术运算都需要进行位移位。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1418470|此外，您还需要移位来生成散列。多项式运算(CRC、里德-所罗门码是主流应用)或者也使用移位。|1418471|然而，使用移位只是因为它们很方便，并且准确地表达了作者的意图。如果你愿意，你可以用乘法来模拟所有的位移位，但是这样写起来会更难，可读性更差，有时还会更慢。|1418472|编译器检测乘法可以简化为移位的情况。|1418473|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I still write code for systems that do not have floating point support in hardware. In these systems you need bit-shifting for nearly all your arithmetic.

Also you need shifts to generate hashes. Polynomial arithmetic (CRC, Reed-Solomon Codes are the mainstream applications) or uses shifts as well.

However, shifts are just used because they are handy and express exactly what the writer intended. You can emulate all bit-shifts with multiplication if you want to, but that would be harder to write, less readable and sometimes slower. 

The compilers detect cases where multiplication can be reduced to a shift.

blocks|key|1632366|text|我一直在使用它们的一个地方是在跨平台应用程序中调换整数的字节顺序时。在处理2D图形时，它们有时也会派上用场(以及其他位操作操作符)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1632367|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

One place I use them all the time is when transposing the endian-ness of integers for cross-platform applications. They also sometimes come in handy (along with other bit-manipulation operators) when blitting 2D graphics.

blocks|key|1632407|text|我已经使用过它们几次，但几乎总是用于解析二进制文件格式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1632408|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I've used them a few times, but pretty much always for parsing a binary file format.

blocks|key|1632977|text|是的，我有。正如你可能怀疑的那样，它最有可能出现在低级编程中，例如开发设备驱动程序。但是，我在一个C#项目中工作，在这个项目中我必须开发一个从医疗设备接收数据的web服务。设备存储的所有二进制数据都被编码到SOAP数据包中，但二进制数据被压缩和编码。所以要解压缩它，你必须做很多很多的位操作。此外，你将不得不做大量的位移位来解析出任何有用的信息，例如设备序列号是第二个字节的下半部分或类似的东西。我也见过.NET+(C#)世界中的一些人使用位掩码和标志属性，我个人从来没有这样做的冲动。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1632978|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yes, I have. 
As you might suspect it's most likely to be found in low level programming, for example developing devices' drivers. But, I worked on a C# project where I had to develop a web service that received data from medical devices. All the binary data that device stored was encoded into SOAP packets, but the binary data was compressed and encoded. So to uncompress it, you would have to do lots and lots of bit manipulations. And furthermore you would have to do lots of bit shifting to parse out any useful information, for example device serial number is a lower half of the second byte or something like that.
Also I've seen some people in .NET (C#) world make a use of Bit masking and Flag Attribute, I personally never had an urge to do it.

blocks|key|1633338|text|当我用汇编语言编写时，我的代码充满了位移位和掩码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633339|用C语言也做了相当多的工作。|1633340|我在JavaScript或服务器语言中做的还不多。|1633341|最好的现代应用可能是遍历布尔值的压缩数组，该数组表示为1和0。我过去常常在汇编语言中左移并检查符号位，但在高级语言中，你需要与一个值进行比较。|1633342|例如，如果你有8位，你用"if+(a>127)+{...}“检查最上面的位。然后你离开shift+(或者乘以2)，对127做一个"+and“(或者如果最后一位被设置，做一个256的减法)，然后再做一次。|1633343|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

When I wrote in assembly language, my code was full of bit-shifting and masking.

Did it a fair amount in C, as well.

Haven't done it much in JavaScript or server languages.

Probably the best modern use is to step through a packed array of boolean values represented as ones and zeros. I used to always left shift and check for sign bit in assembly, but in higher level languages you compare against a value.

For example, if you have 8 bits, you check the top bit with "if (a>127) {...}". Then you left shift (or multiply by 2), do an "and" with 127 (or do a subtraction of 256 if the last bit was set), and do it again.

blocks|key|1632441|text|是啊。我必须在此之前编写加密算法，这肯定会用到它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1632442|当使用整数等来跟踪状态时，它们也很有用。|1632443|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

yep. I have to write encryption algorithms before and that definitely uses them. 

They are also useful when using integers etc for keeping track of statuses.

blocks|key|1632508|text|我经常在图像压缩/解压缩中使用它们，其中位图中的位被压缩。使用http://en.wikipedia.org/wiki/Huffman_coding压缩的东西由不同数量的位组成(它们并不都是字节对齐的)，因此在编码或解码它们时需要对它们进行位移位。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1632509|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Huffman_coding^0|V|17|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I used them a lot in image compression/decompression, where the bits in a bitmap were compressed. Using <a href="http://en.wikipedia.org/wiki/Huffman_coding" rel="nofollow noreferrer">http://en.wikipedia.org/wiki/Huffman_coding</a> the things being compressed consist of various numbers of bits (they're not all byte-aligned), and therefore you need to bit-shift them when you encode or decode them.

blocks|key|1632559|text|例如，在诸如C、C%2B%2B等语言上的加密方法实现中。二进制文件、压缩算法和逻辑列表操作-按位操作总是好的=)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1632560|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

For example, in cryptographic methods implementation on languages such as C, C++. Binary files, compression algorithms and logical lists operations - bitwise operation is always good =)

blocks|key|1417962|text|位移位并不能解决高级编程问题，但有时我们必须解决低级编程问题，而且不必用C编写单独的库就可以很方便地解决这些问题。我猜这是它最常被使用的时候。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1417963|我曾亲自使用它为EBCDIC字符集转换器编写编码器。|offset|length|1417964|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/EBCDIC^0|0|8|6|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Bit shifting doesn't solve high level programming problems, but just we sometimes have to solve lower level problems, and it's convenient to not have to write a separate library in C to do it. That's when it gets used most is my guess.

I have personally used it in writing an encoder for an <a href="http://en.wikipedia.org/wiki/EBCDIC" rel="nofollow noreferrer">EBCDIC</a> character set converter.

blocks|key|1418554|text|在将数字从小端格式转换为大端格式时，反之亦然|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1418555|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

When converting numbers from little endian to the big endian format and vice versa

blocks|key|1633577|text|我在一家电脑周边设备制造商工作。我几乎每天都会遇到并不得不实现使用位移位的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633578|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I work for a computer peripheral manufacturer. I've encountered, and had to implement code that uses bit shifts, pretty much every day.

blocks|key|1633876|text|比特移位是破译网络游戏协议的常用方法。协议被设计为使用尽可能少的带宽，所以所有的信息都被打包成尽可能少的字节，而不是在int32s中传输服务器上的玩家数量、姓名等。现在大多数人都在使用宽带，这真的不是必要的，但当它们最初被设计时，人们使用56k调制解调器来玩游戏，所以每一位都很重要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633877|最突出的例子是在Valve的多人游戏中，特别是反打击，反攻击源。Quake3协议也是一样的，但是虚幻并不是那么纤细。|1633878|下面是一个示例(.NET+1.1)|1633879|string+data+=+Encoding.Default.GetString(receive);

if+(+data+!=+""+)
{
++++//+If+first+byte+is+254+then+we+have+multiple+packets
++++if+(+(byte)+data[0]+==+254+)
++++{
++++++++//+High+order+contains+count,+low+order+index
++++++++packetCount+=+((byte)+data[8])+&+15;+//+indexed+from+0
++++++++packetIndex+=+((byte)+data[8])+>>+4;
++++++++packetCount+-=+1;

++++++++packets[packetIndex]+=+data.Remove(0,9);
++++}
++++else
++++{
++++++++packets[0]+=+data;

++++}
}|code-block|syntax|javascript|1633880|当然，您是将其视为一个真正的项目，还是仅仅是一个爱好(在C#中)，这取决于您。|1633881|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Bit shifting is used a lot in deciphering the protocols of online games. The protocols are designed to use a little bandwidth as possible, so instead of transmitting the number of players on a server, names and so forth in int32s, all the information is packed into as few bytes as possible. It's not really necessary these days with most people using broadband, but when they were originally designed people used 56k modems for gaming, so every bit counted.

The most prominent examples of this are in Valve's multiplayer games particularly Counter-Strike, Counter-Strike Source. The Quake3 protocol is also the same, however Unreal isn't quite as slimline.

Here's an example (.NET 1.1)

<pre><code>string data = Encoding.Default.GetString(receive);

if ( data != "" )
{
 // If first byte is 254 then we have multiple packets
 if ( (byte) data[0] == 254 )
 {
 // High order contains count, low order index
 packetCount = ((byte) data[8]) &amp; 15; // indexed from 0
 packetIndex = ((byte) data[8]) &gt;&gt; 4;
 packetCount -= 1;

 packets[packetIndex] = data.Remove(0,9);
 }
 else
 {
 packets[0] = data;

 }
}
</code></pre>

Of course whether you view this as a real project or just a hobby (in C#) is up to you.

blocks|key|1632580|text|Fast+Fourier+transform+—+FFT和它的库利-图基技术将需要使用位移位操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1632581|entityMap|0|LINK|mutability|MUTABLE|url|http://www.librow.com/articles/article-10^0|0|S|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="http://www.librow.com/articles/article-10" rel="nofollow noreferrer">Fast Fourier transform — FFT</a> and it's Cooley-Tukey technique will require use bit shifting operations.

blocks|key|1418999|text|找出大于或等于给定数字的2的最接近的幂：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419000|1+<<+(int)(ceil(log2(given)))|code-block|syntax|javascript|1419001|在不支持任意纹理大小的硬件上进行纹理处理时需要。|1419002|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Find the nearest power of two greater or equal to given number:

<pre><code>1 &lt;&lt; (int)(ceil(log2(given)))
</code></pre>

Needed for texturing on hardware that does not support arbitrary texture sizes.

blocks|key|1634013|text|另一个非常常见的事情是在提取字节的高位nibble时进行4位移位。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1634014|#define+HIGH_NIBBLE(byte)+(((byte)+>>+4)+&+0x0F)
#define+LOW_NIBBLE(byte)++(+(byte)+++++++&+0x0F)|code-block|syntax|javascript|1634015|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Nibble^0|J|6|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Another very common thing is to do a 4 bit shift when extracting the high <a href="http://en.wikipedia.org/wiki/Nibble" rel="nofollow noreferrer">nibble</a> of a byte, i.e.

<pre><code>#define HIGH_NIBBLE(byte) (((byte) &gt;&gt; 4) &amp; 0x0F)
#define LOW_NIBBLE(byte) ( (byte) &amp; 0x0F)
</code></pre>

blocks|key|1632614|text|是的，在MPEG2-2传输流解析器中使用。它更简单，可读性也更好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1632615|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yes, used them in MPEG2-2 Transport stream parser. It was easier and was better readable.

blocks|key|1418026|text|我不得不写一个程序来解析DVD盘上的.ifo文件。这些字段用于解释光盘上有多少标题、章节、菜单等。它们由各种大小和排列的压缩比特组成。我怀疑许多二进制格式都需要类似的位移位。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1418027|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I had to write a program to parse the .ifo files on DVD discs. These are the fileds that explain how many titles, chapters, menus, etc. are on the disc. They are made up of packed bits of all sizes and alignments. I suspect many binary formats require similar bit shifting.

blocks|key|1632813|text|我见过使用多个标志作为属性参数时使用的位运算符。例如，数字4=1+0+0表示设置了三个标志中的一个。这对公共API不好，但它可以在特殊情况下加快速度，因为检查位很快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1632814|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I have seen bitwise operators used when multiple flags were used as a property parameter. For example number 4 = 1 0 0 means that one of the three flags is set. This is not good for public API but it can speed up things in special cases since checking for bits is fast.

blocks|key|1632865|text|我写过的每一个bitblt都不可能在没有左右滑动位的能力的情况下完成。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1632866|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Every bitblt-er i ever wrote couldn't have been completed w/o ability to slide bits left and right.

blocks|key|1632895|text|我在游戏中使用了它们，将一堆标志打包成一个字节/字符，以便保存到数据卡中。像存储解锁对象的状态之类的事情。现在要求不是很高，但可以节省工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1632896|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I've used them on games for packing a bunch of flags into a single byte / char for saving out to a data card. Things like storing the status of unlockables etc. Not so much of a requirement nowadays, but can save work.

blocks|key|1633294|text|是的，在Java和C#应用程序之间执行二进制通信时，一个是大端字节排序，另一个是小端字节排序(不一定是这个顺序)。我创建了一个InputStream类，它可以读取具有不同字节顺序的数字，并且它使用了字节移位来工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633295|有时，当你想在一个长整型的4个字节中放置4个短整型时，使用字节移位就是这种情况。我想我很多年前就这么做了。|1633296|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Yes, when performing binary communication between Java and C# applications, one is big-endian byte ordering and the other is little-endian (not necessarily on this order). I created an InputStream class that could read numbers with a different byte order, and it used byte-shifting in order to work.

Sometimes also when you want to put 4 shorts in the 4 bytes of a long, it would be case the of using byte shifting. I think I did that many years ago...

blocks|key|1633178|text|当与“低级”设备、eq数字以太网IO+-boxes或PLC通信时，也需要位移位，这些设备通常将单独的输入/输出值打包成字节。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633179|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Bit shifting is also required when communicating with "lower level" equiment, eq digital ethernet-IO -boxes or PLC's, which usually pack invidual input/output values into bytes.

blocks|key|1418682|text|是的，位移位一直在低级嵌入式软件中使用。它还可以用作执行极快的数学运算的几乎是魔术的技巧，请看|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1418683|http://betterexplained.com/articles/understanding-quakes-fast-inverse-square-root/|offset|length|1418684|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|2A|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

Yes, bit shifting is being used at low-level embedded software all the time. It can also be used as an almost magic trick to perform extremely fast math operations, have a look at

<a href="http://betterexplained.com/articles/understanding-quakes-fast-inverse-square-root/" rel="nofollow noreferrer">http://betterexplained.com/articles/understanding-quakes-fast-inverse-square-root/</a>

blocks|key|1633440|text|是的，一直都是。像这些用于将3空间坐标打包和解包到32位整数或从32位整数解包的宏：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633441|#define+Top_Code(a,+b,+c)+++++++++++((((a)+%2B+x)+<<+20)+%7C+(((b)+%2B+y)+<<+10)+%7C+((c)+%2B+z))+++++++++++++++++++++++++++
#define+From_Top_Code(a,+b,+c,+f)+++(a+=+(((f)+>>>+20)+-+x),+b+=+((((f)+&+0xffc00)+>>>+10)+-+y),+c+=+(((f)+&+0x3ff)+-+z))++++++++|code-block|syntax|javascript|1633442|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Yes, all the time. Like these macros for packing and unpacking a 3space coordinate to/from a 32-bit integer:

<pre><code>#define Top_Code(a, b, c) ((((a) + x) &lt;&lt; 20) | (((b) + y) &lt;&lt; 10) | ((c) + z)) 
#define From_Top_Code(a, b, c, f) (a = (((f) &gt;&gt;&gt; 20) - x), b = ((((f) &amp; 0xffc00) &gt;&gt;&gt; 10) - y), c = (((f) &amp; 0x3ff) - z)) 
</code></pre>

blocks|key|1418822|text|我曾经(很久很久以前)为一个项目编写了一个输出例程，该项目使用Excel操作结构创建Excel电子表格。这是一个二进制文件共振峰，需要大量的位旋转。下面的链接介绍了操作结构Safari+Books。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1418823|entityMap|0|LINK|mutability|MUTABLE|url|http://my.safaribooksonline.com/0321262506/ch19lev1sec4^0|2E|C|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I once (many, many years ago) wrote an output routine for a project which created Excel Spreadsheets using the Excel Oper structure. This was a binary file formant which required a large amount of bit twiddling. The following link gives a flavour of the Oper structure <a href="http://my.safaribooksonline.com/0321262506/ch19lev1sec4" rel="nofollow noreferrer">Safari Books</a>.

blocks|key|1633646|text|我在C#中做了一些位移位。该应用程序需要对语音音频输入进行标准化，这需要在音频采样级别进行几个数学运算。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633647|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I've done some bit shifting in C#. The app needed to normalize speech audio input which requiered several math operations at the audio sample level.

blocks|key|1633679|text|是。尤其是在将控制和状态字节用于硬件驱动器的仿真器中。控制字节中的每一位都有特殊含义，而状态字节中的每一位都有特殊含义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633680|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yes. Especially in an emulator which used control and status bytes for a hardware driver. Each bit in the control byte had a special meaning and each bit in the status byte had a special meaning.

blocks|key|1419022|text|我在CRC计算中使用了它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419023|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

blocks|key|1633951|text|好的。处理affinity+masks时会使用位移位。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1633952|例如，您可能希望限制应用程序使用不超过给定数量的处理器(以获取使用每个处理器的资金)-您将使用位移位来计算亲和性掩码中的位吗？|1633953|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ms686223(VS.85).aspx^0|5|E|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Sure. Dealing with <a href="http://msdn.microsoft.com/en-us/library/ms686223(VS.85).aspx" rel="nofollow noreferrer">affinity masks</a> makes use of bit shifting.

For example you might want to limit an application to using no more than a given number of processors (to take money for using each processor) - you will use bit shifts to count bits in the affinity mask?

blocks|key|1419243|text|我用新颖的加密结构做了一些工作，在同态加法器后面隐藏了序列化的结构(以及对它们的后续更新)。许多散列也依赖于位操作；在位操作之间移动。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419244|涉及许多位移位和讨厌的大数字操作；所有这些都是在Java中实现的(诚然，这只是一个参考/研究实现)。|1419245|还做了压缩项目(GZIP+impl.尤其是)，您需要非常频繁地打包代码；如果没有<<和>>+(如果您使用的是Java语言，则可以使用>>>+)，这是无法想象的。|1419246|基本上，如果您使用的是加密或压缩，则很有可能需要在某一时刻进行位移位。|1419247|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I've done some work with novel crypto structures, hiding serialized structures (and subsequent updates to them) behind homomorphic adders. Alot of hashes also depend on bit operations; shifting amongst them.

Involed lots of bit shifting, and nasty big number operations; all in Java (admittedly, this was a reference/research implementation).

Also done compression projects (GZIP impl. in particular), where you need to pack bits quite frequently; can't imagine pulling that of without &lt;&lt; and >> (or >>>, if you're in Java).

Basically, if you're working with crypto or compression there's a good chance you'll need bit shifting at one point or another.

blocks|key|1419291|text|不久前，我在一个web项目中使用了位移位。这是一个电子商务应用程序，其中每个产品都有许多可配置的属性。用户可以选择他们想要的属性，UI将更新以提供所选选项的定价和SKU。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419292|不是在数据存储中搜索与用户选项匹配的SKU，而是每个选项组合对应于一个特定的散列，这实际上是一个使用位数学创建的数字。我允许每个选项4位(16个组合)，最多5个选项，所以总共20位。要根据用户的选项计算散列值，我将循环遍历每个编号属性，并添加散列值：|1419293|for(var+i+=+0;+i+<+getSku.arguments.length;+i%2B%2B)
{
++++index+=+getAttributeIndex(i,+getSku.arguments[i]);
++++hash+%2B=+(index%2B1)+<<+(4*i);
}|code-block|syntax|javascript|1419294|这比循环遍历数百个SKU，每次最多比较5个值要快得多。|1419295|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I used bit shifting in a web project a while back. It was an ecommerce application where each product had a number of configurable attributes. The user could pick the attributes they desired, and the UI would update to provide pricing and a SKU for the selected options.

Rather than search through the data store for the SKU matching the user's options, each combination of options corresponded to a specific hash, which was really a number created using bit math. I allowed 4 bits (16 combinations) for each option, up to five options, so 20 bits total. To calculate the hash from the user's options, I would loop over each numbered attribute adding to the hash value:

<pre><code>for(var i = 0; i &lt; getSku.arguments.length; i++)
{
 index = getAttributeIndex(i, getSku.arguments[i]);
 hash += (index+1) &lt;&lt; (4*i);
}
</code></pre>

This was quite a bit faster than looping through potentially hundreds of SKUs comparing up to 5 values each time.

blocks|key|1634169|text|不，我从来没有真正用过它们。我认为对于高级语言来说，这些二进制操作有点过时。正如有人所说，它总是可以用其他数学表达式来模拟，由于这些表达式很少使用，它们可以构建在外部库中。ruby或python中的位移位对我来说听起来真的很奇怪，有点像混合了高级别和低级别。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634170|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

No, I never really have to use them. I think that these binary operation are a bit deprecated for high level language.. As someone said, it can always be emulated with other mathematic expressions, and since those are hardly ever used, they could be built in an external library. Bit shifting in ruby or python sounds really weird to me, kind of like mixing high and low level.

blocks|key|1634240|text|我在扑克牌手评算器中使用过它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634241|扑克牌手牌表示为64位无符号整数，手中的每一张牌都有一个1位。通过移动和掩蔽的组合，你可以问一些问题，比如“给我所有我手中至少有3张牌的等级”等等。|offset|length|style|CODE|1634242|这是相当快的，但我后来学到了更快的方法，将手表示为一个字节数组。|1634243|entityMap^0|0|S|1|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

I've used them in a poker hand evaluator.

A poker hand is represented as a 64-bit unsigned integer with a <code>1</code> bit for each card that is present in the hand. Through a combination of shifting and masking you can ask questions like "give me all the ranks for which I have at least 3 cards in my hand" etc.

It's reasonably fast, but I've since learned of faster methods where the hand is represented as an array of bytes.

blocks|key|1419487|text|大多数数据包仍然是位编码的。如果您使用任何类型的低级网络通信，您将不得不使用bits。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419488|另外，分析包含声音和视频的数据包--我相信即使是MP3标签也会使用一些比特。|1419489|最重要的是，不熟悉位操作意味着您很可能会错过实现某些操作的更好方法。我的意思是，如果你正在处理50亿个有序对象的存在，这是能够非常舒适地将它们全部放入ram中进行即时查找还是每次都在文件中查找它们之间的区别--在这样的任务中，我想说，一个自称软件工程师的人在没有进行位操作的情况下实现了它，这在他的工作中是无能的。|1419490|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Most packets of data are still bit encoded. If you work with any kind of low-level network communications, you are going to have to play with bits.

Also analyzing packets containing sound &amp; video--I believe even MP3 tags use a few bits.

Most importantly, not being comfortable with bit manipulations means you will most likely miss MUCH better ways to implement some operations. I mean, if you were dealing with the existence of 5 billion ordered objects, it's the difference between being able to fit them all into ram pretty comfortably for an instant lookup or looking it up in a file every time--on a task like this I would say that someone calling themselves a software engineer who implemented it without bit manipulation was incompetent at his job.

blocks|key|1419507|text|我已经用它实现了UTF-8和UTF-32之间的转换。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419508|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I've used it to implement conversion between UTF-8 and UTF-32.

blocks|key|1419536|text|是。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1419537|在内存紧张、速度决定一切的嵌入式应用程序中，位移位非常有用。|1419538|例如，您可以只使用加法和位移位来执行相同的计算，而不是执行成本高昂的乘法运算，这是一个巨大的时间节约：|1419539|c+:=+0
while+b+!=+0
++++if+(b+and+1)+!=+0
++++++++c+:=+c+%2B+a
++++shift+a+left+by+one
++++shift+b+right+by+one
return+c|code-block|syntax|javascript|1419540|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Yes.

Bit shifting is extremely useful in embedded applications, when memory is tight and speed is everything.

For example, instead of doing a costly multiplication operation, you can perform the same calculation using only addition and bit-shifts, which is a huge time-saver:

<pre><code>c := 0
while b != 0
 if (b and 1) != 0
 c := c + a
 shift a left by one
 shift b right by one
return c
</code></pre>

blocks|key|1634404|text|我正在从计算机科学专业毕业，我已经在使用位移位了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634405|它们很适合存储标志，使用哈希等，人们已经说过了。|1634406|我使用了一次按位操作，将1个小整数(2字节)值和2个字符压缩到一个整数中。与我同事的项目相比，这为我节省了大量内存。|1634407|这些操作有时在算术运算中也非常快，例如，当您必须扩展类型double或使用函数来使用尾数操作浮点数据时(请参阅浮点算术标准)。|1634408|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I'm gradutating in Computer Science and I already use bitshifts.

They are good to store flags, to work with hashes, etc, people already said that.

I used bitwise operations once to compact 1 small integer (2 bytes) value and 2 chars in one integer. That saved me a lot of memory compared to my fellows' projects.

And these operations are also very fast sometimes with arithmectics, e.g. when you have to extend the type double or use a function to manipulate float-point data using mantisses (see standards for floating point arithmectics).

Have you ever had to use <a href="http://en.wikipedia.org/wiki/Bit_shift#Bit_shifts" rel="noreferrer">bit shifting</a> in real programming projects? Most (if not all) high level languages have shift operators in them, but when would you actually need to use them?

Have you ever had to use bit shifting in real projects?

设备驱动程序

数据存储

软件工程

服务器

编译器

Java

你有没有在实际的编程项目中使用过？大多数(如果不是所有的)高级语言都有移位运算符，但是什么时候你真正需要使用它们呢？

问你有没有在实际项目中使用过位移位？
EN

回答 37

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问你有没有在实际项目中使用过位移位？EN

回答 37

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问你有没有在实际项目中使用过位移位？
EN