问题描述:

can someone explain to me why the following results in b = 13?

`int a, b, c;`

a = 1|2|4;

b = 8;

c = 2;

b |= a;

b&= ~c;

It is using binary manipultaors. (Assuming ints are 1 byte, and use Two's complement for storage, etc.)

`a = 1|2|4`

means `a = 00000001 or 00000010 or 00000100`

, which is 00000111, or 7.

`b = 8`

means `b = 00001000`

.

`c = 2`

means `c = 00000010`

.

`b |= a`

means `b = b | a`

which means `b = 00001000 or 00000111`

, which is 00001111, or 15.

`~c`

means `not c`

, which is 11111101.

`b &= ~c`

means `b = b & ~c`

, which means `b = 00001111 and 11111101`

, which is 00001101, or 13.

http://www.cs.cf.ac.uk/Dave/C/node13.html

```
a = 1|2|4
= 0b001
| 0b010
| 0b100
= 0b111
= 7
b = 8 = 0b1000
c = 2 = 0b10
b|a = 0b1000
| 0b0111
= 0b1111 = 15
~c = 0b111...1101
(b|a) & ~c = 0b00..001111
& 0b11..111101
= 0b00..001101
= 13
```

lets go into binary mode: a = 0111 (7 in decimal) b = 1000 (8) c = 0010 (2)

then we OR b with a to get b = 1111 (15) c = 0010 and ~c = 1101 finally b is anded with negated c which gives us c = 1101 (13)

The link posted by Ed is a good one. Have you analyzed the operators one step at a time? Do you fully understand what is happening at each step? Is there a particular step you are stuck on? Or are you just confused at the math overall?

hint: Convert decimal to binary and give it a shot.. maybe... just maybe you'll figure it all out by yourself

`a = 1 | 2 | 4;`

Assigns the value 7 to `a`

. This is because you are performing a bitwise `OR`

operation on the constants 1, 2 and 4. Since the binary representation of each of these is 1, 10 and 100 respectively, you get 111 which is 7.

`b |= a;`

This `OR`

s `b`

and `a`

and assigns the result to `b`

. Since `b`

's binary representation is now 111 and `a`

's binary representation is 1000 (8), you end up with 1111 or 15.

`b &= ~c;`

The `~c`

in this expression means the bitwise negation of `c`

. This essentially flips all 0's to 1's and vice versa in the binary representation of `c`

. This means `c`

switches from 10 to 111...11101.

After negating `c`

, there is a bitwise `AND`

operation between `b`

and `c`

. This means only bits that are 1 in both `b`

and `c`

remain 1, all others equal 0. Since `b`

is now 1111 and `c`

is all 1's except in the second lowest order bit, all of `b`

's bits remain 1 except the 2 bit.

The result of flipping `b`

's 2 bit is the same as if you simply subtracted 2 from its value. Since its current value is 15, and 15-2 = 13, the assignment results in `b == 13`

.