List and explain bitwise operators in C language?

Answer 1

void main()

{

unsigned int word1 = 077u, word2 = 0150u, word3 = 0210u;

printf ("%o ", word1 & word2);

printf ("%o ", word1 & word1);

printf ("%o ", word1 & word2 & word3);

printf ("%o\n", word1 & 1);

getch();

}

Answer 2

To understand the difference between logical AND and bitwise AND operators you first need to examine the truth tables. Both operators are binary operators which means they have two operands, one on either side of the operator.

Logical AND is the easier of the two to understand because bot operands are bool types (Boolean types). All integral types implicitly convert to a bool, such that zero evaluates false and non-zero evaluates true. Typically we use the all-ones bit pattern to denote true, which has the value -1 in signed notation. This is why we typically return -1 to denote that an error has occurred, although it's usually more useful to return a specific value to denote what type of error has occurred. But if we're only interested in success or failure, -1 is as good a value as any to denote a failure.

The truth table for logical AND is as follows, where T denotes true and F denotes false:

Logical AND (&&):

F && F = F

F && T = F

T && F = F

T && T = T

Note that if either or both input operands are false, the output is false. Thus 42 && 0 is false because 0 is false.

Bitwise AND is a little more complex, but it works in a similar manner to logical AND. As its name suggests, bitwise AND operates at the bit-level and thus operates on the corresponding bits of its operand. Each pair of bits provides the operands and outputs a corresponding 0 bit or 1 bit according to the following truth table:

Bitwise AND (&):

0 & 0 = 0

0 & 1 = 0

1 & 0 = 0

1 & 1 = 1

We typically use bitwise AND to determine if a given bit is set in a bitmap. For instance, if we wish to test if bit 5 is set in a variable named x, then we perform the following operation:

x & (2^5)

2^5 = 2 * 2 * 2 * 2 * 2 = 32, so we can also write this as:

x & 32

If we suppose that x is 42, then x & 32 = 32. To understand why, we need to look at the binary representations. It's easier if we place the values one above the other so we can compare the corresponding bits:

00101010 (42)

00100000 (32)

As you can see, bit 5 is the only bit that is set in both operands. As per the truth table above, the output binary value must be 00100000 which is 32 decimal (and therefore matches the right hand operand). Thus 42 & 32 = 32.

Testing an individual bit is simple: if the result is non-zero, then the bit we're examining must be set, regardless of which bit we're looking for. If the result is zero (that all-zeroes bit pattern) then the bit is not set. Note that the least significant bit is always bit 0 so we can determine the value of any bit from its zero-based index position (reading right-to-left):

2^0 = 1

2^1 = 2

2^2 = 4

2^3 = 8

2^4 = 16

...and so on.

Thus if we want to test bit 4, we use bitwise AND with the value 2^4, which is 16.

Note that we can only test one bit at a time this way. If we test multiple bits simultaneously, we can only determine if some or all of the bits are set, or none of the bits are set. If some, but not all of the bits are set, then we need to test each bit individually to determine which are set and which are not. However, testing multiple bits is a useful technique for masking off certain bits, essentially stripping off those that we're not interested in. For instance, if we're only interested in examining bits 2, 3, 4 and 5, we use the following operation:

x & (2^2 + 2^3 + 2^4 + 2^5)

This equates to x & 60. Given x is still 42, then 42 & 60 would be:

00101010 (42) &

00111100 (60) =

00101000 (40)

40 is non-zero so this tells us that at least 1 of those 4 bits is set. Moreover, knowing that 40 is not equal to 60 also tells us that not all of the 4 bits are set. If we need to know which of the 4 bits is set, we can test each of them individually, as before. However, the point of masking bits like this is simply to zero those bits that were not interested in.

Answer 3

Bitwise operators are operators that operate upon and return individual bits from the operand(s). Whereas boolean operators such as && and return true or false, bitwise operators, such as & (AND), | (OR), ^ (XOR) and ~(INVERT) return values based upon the state of the bits in the operands.

For instance, if you wished to check if bit 7 were set in a particular value, then you would AND (&) the value with 0x80 (which is 10000000 in binary). If the result is 0x80 then bit 7 is definitely set. If the result is 0 then it is not. If you wished to check if bit 7 were set in one value but not in another, then you would AND 0x80 with the XOR of the two values. Thus if ( x ^ y ) & 0x80 00000011). If you wish to check if bit 0 or bit 1, or both, were set in a value, then you AND with 0x03. If the result is zero, neither is set. If the result is 0x01 then only bit 0 is set. 0x02 means only bit 1 is set. And 0x03 means both bits are set.

Answer 4

The C bitwise operators allow programmers to operate upon the individual bits within a bit pattern of integral type. The bitwise shift operators (<< and >>) allow the programmer to shift bits left or right a specified number of binary positions while the bitwise NOT operator (~) allows the programmer to examine the ones-complement of an integral value. The bitwise AND (&), OR (|) and XOR (^) operators are binary operators (with two operands) and are useful for testing the state of individual bits within a bit pattern of integral type.

Answer 5

#include<stdio.h>

int main(){

int i;

i=i<<2+i;

printf("%d",i);

return 0;

}

Answer 6

The bitwise operators in C and C++ are

• & and
• ^ exclusive or
• | inclusive or
• << left shift
• >> right shift

Answer 7

they is and &, or |, xor ^ and not ~