Bitwise AND behaves differently than expected? - c

Question

#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
int a = 50; // 110010
int b = 30; // 011110
if (a & b) {
printf("Hi");
}
return 0;
}
The code above prints Hi.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
int a = 50; // 110010
int b = 13; // 001101
if (a & b) {
printf("Hi");
}
return 0;
}
The code above doesn't print anything.
Logically, you would think that a bitwise AND would mean that all the digits in binary would have to match in order to return true. Instead, in reality, each digit in binary would have to be different for the condition to return false.
I don't understand the point of bitwise AND.
I also understand that false is equivalent to 0 in C.

Answer 1

Like Karthik said it's bitwise.
int a = 50; // 110010 int a = 50; // 110010
int b = 30; // 011110 & int b = 13; // 001101 &
¯¯¯¯¯¯¯ ¯¯¯¯¯¯¯
010010 = 18 000000 = 0 --false

Answer 2

It is a bitwise &. That means the result of the operation is the result of applying & bit by bit on the two operands.
int a = 50; // 110010
int b = 30; // 011110
a & b == 010010 == 18 == true
If you want all the bits to be equal, that's just ==. Or you would bitwise & it with 111111

Answer 3

The operator is bitwise, which means it compares the binary representation of two variables bit by bit. When you have
int a = 50; // 110010
int b = 30; // 011110
int result = a & b; // 010010
What happens is this: the bits of result are set based on the values of the bits in a and b. Each pair of corresponding bits in a and b is compared. Here, since the second and fifth bits (from the right) of both a and b are 1, i.e., true, the comparison of those bits yields true, and correspondingly, the second and fifth bits in result are set to true as well. Consequently, result is nonzero. This nonzero evaluation of a & b would cause "Hi" to print in your first example.
In your second example:
int a = 50; // 110010
int b = 13; // 001101
int result = a & b; // 000000
There is no case in the binary representation of 50 and 13 where corresponding bits are on: the first bit (from the right) is off in 50, on in 13; vice-versa for the second bit, and so on. So the comparison of corresponding bits yields 0 in every case, and no corresponding bit is on in result. Hence result evaluates to zero. This zero result causes "Hi" not to print in your second example.
As to the utility of this operator: bitwise operations are essential in embedded systems programming. They are also extremely efficient for certain problems (e.g. a Sieve of Eratosthenes type program to generate primes). The bitwise or is useful in cryptography. The list goes on...

Answer 4

Case 1:
int a = 50; // 110010
int b = 30; // 011110
if (a & b) =>if (50 & 30) => if( 1 1 0 0 1 0 & => if(010010)=> if(18)=>
0 1 1 1 1 0 )
if(18)=>if(TRUE)=> printf("Hi")
Case 2:
int a = 50; // 110010
int b = 13; // 001101
if (a & b) =>if (50 & 13) => if( 1 1 0 0 1 0 & => if(000000)=> if(0)=>
0 0 1 1 0 1 )
if(0)=>if(FALSE) => NO printf("Hi")

Answer 5

What is not clear to you is that in C, the number 0 is false, and any other number is true.
if (0) {
printf("hi");
}
will do nothing, so if the bit-wise-and operation doesn't produce a single set bit, you have effectively computed an if statement that looks like
if (false) {
printf("hi");
}
As everyone else has done a fine example of showing the bit operation, I'll defer to their math.

Answer 6

This is exactly the purpose of the bitwise and. It's mostly used for bit testing with masks. The net effect is to keep all the common 1s and zero out everything else. Say, for instance you want to test if the 3rd bit is 1, you can just write
if ( a & 4 /*0100*/ )
// do something
As Karthik said there are other methods to compare the operands the way you expected.

Answer 7

"Logically, you would think that a bitwise AND would mean that all the digits in binary would have to match in order to return true. Instead, in reality, each digit in binary would have to be different for the condition to return false."
They don't have to be different. AND would yield zero if both bits were zero, for instance. XOR is the logical operator that returns true only if the bits are different, and XNOR is the one that returns true only if they're the same. Since anything non-zero is true, then to get AND to return true you just need any one bit to be 1 in both of the operands. Conversely, it'll return false if neither of the operands have a 1-bit in common.