Real world use cases of bitwise operators

 

What are some real world use cases of the following bitwise operators?

  • AND
  • XOR
  • NOT
  • OR

  • Bit fields (flags)
    They're the most efficient way of representing something whose state is defined by several "yes or no" properties. ACLs are a good example; if you have let's say 4 discrete permissions (read, write, execute, change policy), it's better to store this in 1 byte rather than waste 4. These can be mapped to enumeration types in many languages for added convenience.

  • Communication over ports/sockets
    Always involves checksums, parity, stop bits, flow control algorithms, and so on, which usually depend on the logic values of individual bytes as opposed to numeric values, since the medium may only be capable of transmitting one bit at a time.

  • Compression, Encryption
    Both of these are heavily dependent on bitwise algorithms. Look at the deflate algorithm for an example - everything is in bits, not bytes.

  • Finite State Machines
    I'm speaking primarily of the kind embedded in some piece of hardware, although they can be found in software too. These are combinatorial in nature - they might literally be getting "compiled" down to a bunch of logic gates, so they have to be expressed as AND , OR , NOT , etc.

  • Graphics There's hardly enough space here to get into every area where these operators are used in graphics programming. XOR (or ^ ) is particularly interesting here because applying the same input a second time will undo the first. Older GUIs used to rely on this for selection highlighting and other overlays, in order to eliminate the need for costly redraws. They're still useful in slow graphics protocols (ie remote desktop).

    • Those were just the first few examples I came up with - this is hardly an exhaustive list.

    Is it odd? 

    (value & 0x1) > 0

    Is it divisible by two (even)? 

    (value & 0x1) == 0

    Low-level programming is a good example. You may, for instance, need to write a specific bit to a memory-mapped register to make some piece of hardware do what you want it to: 

    volatile uint32_t *register = (volatile uint32_t *)0x87000000;
uint32_t          value;
uint32_t          set_bit   = 0x00010000;
uint32_t          clear_bit = 0x00001000;

value = *register;            // get current value from the register
value = value & ~clear_bit;   // clear a bit
value = value | set_bit;      // set a bit
*register = value;            // write it back to the register

    Also, htonl() and htons() are implemented using the & and | operators (on machines whose endianness(Byte order) doesn't match network order): 

    #define htons(a) ((((a) & 0xff00) >> 8) | 
                  (((a) & 0x00ff) << 8))

#define htonl(a) ((((a) & 0xff000000) >> 24) | 
                  (((a) & 0x00ff0000) >>  8) | 
                  (((a) & 0x0000ff00) <<  8) | 
                  (((a) & 0x000000ff) << 24))
    链接地址: http://www.djcxy.com/p/72668.html

    上一篇: 算术运算

    下一篇: 真实世界的按位运算符用例