What are bitwise operators?

后端 未结 9 1764
闹比i
闹比i 2020-11-22 02:05

I\'m someone who writes code just for fun and haven\'t really delved into it in either an academic or professional setting, so stuff like these bitwise operators really esca

相关标签:
9条回答
  • 2020-11-22 02:47

    In digital computer programming, a bitwise operation operates on one or more bit patterns or binary numerals at the level of their individual bits. It is a fast, primitive action directly supported by the processor, and is used to manipulate values for comparisons and calculations.

    operations:

    • bitwise AND

    • bitwise OR

    • bitwise NOT

    • bitwise XOR

    • etc

    List item

        AND|0 1        OR|0 1 
        ---+----      ---+---- 
          0|0 0         0|0 1 
          1|0 1         1|1 1 
    
       XOR|0 1        NOT|0 1 
       ---+----       ---+--- 
         0|0 1           |1 0 
         1|1 0
    

    Eg.

        203: 1100 1011
    AND  15: 0000 1111
    ------------------
      =  11: 0000 1011
    

    Uses of bitwise operator

    • The left-shift and right-shift operators are equivalent to multiplication and division by x * 2y respectively.

    Eg.

    int main()
    {
         int x = 19;
         printf ("x << 1 = %d\n" , x <<1);
         printf ("x >> 1 = %d\n", x >>1);
         return 0;
    }
    // Output: 38 9
    
    • The & operator can be used to quickly check if a number is odd or even

    Eg.

    int main()
    {
        int x = 19;
        (x & 1)? printf("Odd"): printf("Even");
        return 0;
     }
    // Output: Odd
    
    • Quick find minimum of x and y without if else statement

    Eg.

    int min(int x, int y)
    {
        return y ^ ((x ^ y) & - (x < y))
    }
    
    • Decimal to binary conversion

    Eg.

    #include <stdio.h>
    int main ()
    {
        int n , c , k ;
        printf("Enter an integer in decimal number system\n " ) ;
        scanf( "%d" , & n );
        printf("%d in binary number
        system is: \n " , n ) ;
        for ( c = 31; c >= 0 ; c -- )
        {
             k = n >> c ;
             if ( k & 1 )
                  printf("1" ) ;
             else
                  printf("0" ) ;
          }
          printf(" \n " );
          return 0 ;
    }
    
    • The XOR gate encryption is popular technique, because of its complixblity and reare use by the programmer.
    • bitwise XOR operator is the most useful operator from technical interview perspective.

    bitwise shifting works only with +ve number

    Also there is a wide range of use of bitwise logic

    0 讨论(0)
  • 2020-11-22 02:50

    Bitwise operators are operators that work on a bit at a time.

    AND is 1 only if both of its inputs are 1.

    OR is 1 if one or more of its inputs are 1.

    XOR is 1 only if exactly one of its inputs are 1.

    NOT is 1 only if its input are 0.

    These can be best described as truth tables. Inputs possibilities are on the top and left, the resultant bit is one of the four (two in the case of NOT since it only has one input) values shown at the intersection of the two inputs.

    AND|0 1      OR|0 1
    ---+----    ---+----
      0|0 0       0|0 1
      1|0 1       1|1 1
    
    XOR|0 1     NOT|0 1
    ---+----    ---+---
      0|0 1        |1 0
      1|1 0
    

    One example is if you only want the lower 4 bits of an integer, you AND it with 15 (binary 1111) so:

        203: 1100 1011
    AND  15: 0000 1111
    ------------------
     IS  11: 0000 1011
    
    0 讨论(0)
  • 2020-11-22 02:58

    Since nobody has broached the subject of why these are useful:

    I use bitwise operations a lot when working with flags. For example, if you want to pass a series of flags to an operation (say, File.Open(), with Read mode and Write mode both enabled), you could pass them as a single value. This is accomplished by assigning each possible flag it's own bit in a bitset (byte, short, int, or long). For example:

     Read: 00000001
    Write: 00000010
    

    So if you want to pass read AND write, you would pass (READ | WRITE) which then combines the two into

    00000011
    

    Which then can be decrypted on the other end like:

    if ((flag & Read) != 0) { //...
    

    which checks

    00000011 &
    00000001
    

    which returns

    00000001
    

    which is not 0, so the flag does specify READ.

    You can use XOR to toggle various bits. I've used this when using a flag to specify directional inputs (Up, Down, Left, Right). For example, if a sprite is moving horizontally, and I want it to turn around:

         Up: 00000001
       Down: 00000010
       Left: 00000100
      Right: 00001000
    Current: 00000100
    

    I simply XOR the current value with (LEFT | RIGHT) which will turn LEFT off and RIGHT on, in this case.

    Bit Shifting is useful in several cases.

    x << y
    

    is the same as

    x * 2y

    if you need to quickly multiply by a power of two, but watch out for shifting a 1-bit into the top bit - this makes the number negative unless it's unsigned. It's also useful when dealing with different sizes of data. For example, reading an integer from four bytes:

    int val = (A << 24) | (B << 16) | (C << 8) | D;
    

    Assuming that A is the most-significant byte and D the least. It would end up as:

    A = 01000000
    B = 00000101
    C = 00101011
    D = 11100011
    val = 01000000 00000101 00101011 11100011
    

    Colors are often stored this way (with the most significant byte either ignored or used as Alpha):

    A = 255 = 11111111
    R = 21 = 00010101
    G = 255 = 11111111
    B = 0 = 00000000
    Color = 11111111 00010101 11111111 00000000
    

    To find the values again, just shift the bits to the right until it's at the bottom, then mask off the remaining higher-order bits:

    Int Alpha = Color >> 24
    Int Red = Color >> 16 & 0xFF
    Int Green = Color >> 8 & 0xFF
    Int Blue = Color & 0xFF
    

    0xFF is the same as 11111111. So essentially, for Red, you would be doing this:

    Color >> 16 = (filled in 00000000 00000000)11111111 00010101  (removed 11111111 00000000)
    00000000 00000000 11111111 00010101 &
    00000000 00000000 00000000 11111111 =
    00000000 00000000 00000000 00010101 (The original value)
    
    0 讨论(0)
提交回复
热议问题