1 / 28

# CSC 270 – Survey of Programming Languages

CSC 270 – Survey of Programming Languages. C Lecture 5 – Bitwise Operations and Operations Miscellany. Logical vs. Bitwise Operations. Logical operations assume that the entire variable represents either true or false .

## CSC 270 – Survey of Programming Languages

E N D

### Presentation Transcript

1. CSC 270 – Survey of Programming Languages C Lecture 5 – Bitwise Operations and Operations Miscellany

2. Logical vs. Bitwise Operations • Logical operations assume that the entire variable represents either trueor false. • Combining two integer values using a logical operator produces one result, with the variable representing trueor false. • Bitwise operations assume that each bit in the variable’s value represents a separate true or false. • Combining two integer values using a bitwise operators produces 8 (or 16 or 32 or 64) separate bits each representing a trueor a false.

3. Logical Values in C • Although the 1999 standard for C includes booleans, it does not exist in older versions. • Integers are usually used for booleanvalues, with nonzero values being accepted as trueand zero values being accepted as false. • Boolean operations will produce a 1 for trueand a 0 for false.

4. x y x &&y 0 0 0 0 1 0 1 0 0 1 1 1 && - Logical AND • The logical AND operator is && and produces a 1 if both operands are nonzero; otherwise, it produces a 0.

5. &&– An Example #include <stdio.h> int main(void) { unsigned u, v, w, x = 0x10, //(hex 16) y = 0x110, //(hex 272: 256 + 16) z = 0x0; //(hex 0) u = x && y; v = x && z; w = y && z; printf("u = %x\tv = %x\tw = %x\n", u, v, z); return(0); } Output u = 1 v = 0 w = 0

6. || - Logical OR • The logical OR operator is || and produces a 1 if either operands is nonzero; otherwise, it produces a 0.

7. Logical ||– An Example #include <stdio.h> int main(void) { unsigned u, v, w, x = 0x10, y = 0x110, z = 0x0; u = x || y; v = x || z; w = y || z; printf("u = %x\tv = %x\tw = %x\n", u, v, z); return(0); } Outputu = 1 v = 1 w = 1

8. Logical NOT • The logical NOT operator ! Inverts the value; nonzero becomes 0 and 0 becomes 1.

9. Logical NOT – An Example #include <stdio.h> int main(void) { unsigned x = 0x110, y; y = !x; // because x has something, it becomes 0 printf("x = ox%x\ty = ox%x\n", x, y); x = 0x0; y = !x; // because x is 0, it becomes 1 printf("x = ox%x\ty = ox%x\n", x, y); return(0); } Output x = ox110 y = ox0 x = ox0 y = ox1

10. Bitwise Operations • Bitwise operations treat the operands as 8-bit (or 16- or 32-bit) operands. Performing a bit-wise AND operation on two 8-bit integers means that 8 ANDs are performed on corresponding bits. • Example: 00111011 00001111 00001011

11. Bitwise AND & • A bitwise ANDoperation is actually 8 (or 16 or 32) ANDoperations. • An example of ANDing: 0 0 1 1 1 0 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 0 1 1 • The AND instruction can be used to clear selected bits in an operand while preserving the remaining bits. This is called masking. cleared unchanged

12. Bitwise AND &– An Example http://www.rapidtables.com/convert/number/how-hex-to-binary.htm unsigned u, v, w, x = 0xab87, //(1010 1011 1000 0111) y = 0x4633, //(0100 0110 0011 0011) z = 0x1111; //(0001 0001 0001 0001) u = x & y; v = x & z; w = y & z; printf("u = ox%x\tv = ox%x\tw = ox%x\n", u, v, w); Output u = ox203v = ox101w = ox11 ox203 binary 0010 0000 0011 (was x & y) ox101 binary 0001 0000 0001 (was x & z) ox11 binary 0000 0001 0001 (was y & z)

13. Bitwise OR | • A bitwise OR operation is actually 8 (or 16 or 32) OR operations. • An example of ORing: 0 0 1 1 1 0 1 1 0 0 0 0 1 1 1 1 0 0 1 1 1 1 1 1 • The ORinstruction can be used to set selected bits in an operand while preserving the remaining bits. unchanged set

14. Bitwise OR | – An Example unsigned u, v, w, x = 0xab87, //(1010 1011 1000 0111) y = 0x4633, //(0100 0110 0011 0011) z = 0x1111; //(0001 0001 0001 0001) u = x | y; v = x | z; w = y | z; printf("u = ox%x\tv = ox%x\tw = %oxx\n“, u, v, w); Output u = oxefb7 v = oxbb97 w = ox5733 oxefb7 binary 1110 1111 1011 0111(was x & y) oxbb97 binary 1011 1011 1011 0111(was x & z) ox5733 binary 0101 0111 0011 0011(was y & z)

15. Bitwise NOT ~(One’s Complement) • The bitwise NOT (better known as the one’s complement) inverts each bit in the operand. • Example unsigned x, y = 0xab87; x = ~y; printf("x = %x\ty = %x\n", x, y); Output x = ffff5478 y = ab87 Add 1 to this to make a two’s complement – negative number representation

16. Bitwise XOR ^ • A bitwise XORoperation is actually 8 (or 16 or 32) ANDoperations. • An example of XORing: 00111011 00111111 00000100 • The XOR instruction can be used to reverse selected bits in an operand while preserving the remaining bits. unchanged inverted

17. Bitwise XOR – An Example unsigned u, v, w, x = 0xab87, y = 0x4633, z = 0x1111; u = x ^ y; v = x ^ z; w = y ^ z; printf("u = %x\tv = %x\tw = %x\n", u, v, w); Output u = edb4 v = ba96 w = 5722

18. Bit Shifting • To make your mask • >> Right shifting << Left Shifting x = 0x ff ; // 1111 1111 y = x << 8; /* y is 0x ff00 */ // 1111 1111 0000 0000 • Results may vary depending on the computer – int can be different sizes on different computers. • x & ~077 will turn off lowest six bits.

19. getbits() /* * getbits() - Get n bits from position p */ unsigned getbits(unsigned x, int p, int n) { return ((x >> (p + 1 - n)) & ~(~0 << n)); } /** if p is 4 and n is 3 – 3 bits from pos 4 x is oxfb (1111 1011) ((oxfb >> (4 + 1 – 3)) & ~(~0 << 3)); ((1111 1011 >> 2 ) & ~(1111 1111 << 3)) ((0011 1110) & ~(1111 1000 )) ((0011 1110) & (0000 0111)) 0000 0110

20. Assignment Operators • An assignment operator is just another operator in C. • We can rewrite i = i + 2; as i += 2; or i = i + x * y; as i += x * y; • Similarly, there are -=, *=, /=, etc.

21. Assignment Operators • Caution! i *= 2 + y; is rewritten as i = i * (2+y); NOT i = (i *2) + y;

22. bitcount() /* * bitcount() - Count 1s in x */ int bitcount(unsigned x) { int b; for (b = 0; x != 0; x >>= 1) if (x & 01) b++; return(b); }

23. Conditional Expressions • Why write if (a > b) z = a; else a = b; when you can write z = (a > b)? a : b;

24. Conditional Expressions • The general form is expression1? expression2: expression3; when expression1 is nonzero, expression2 is evaluated. Otherwise expression3 is evaluated. • The usual rules of conversion are in effect. int i, j, a, b; float x; … … i = (a > b)? j: x;

25. Conditional Expressions • If this useful? YES!! z = (a > b)? a : b; /* z = max (a, b); */ x = (x > 0)? x : -x; /* x = abs(x) */ /* Print 5 values to a line */ for (i = 0; i < MAXSIZE; i++) printf("%d%c", x[i], i % 5 == 4? '\n':'\t');

26. Operator Precedence

27. Bitwise Summary • Bitwise operators act on bits inside the number • 1 hex digit = 4 binary digits • Mask – the number set for comparison • & - used to clear bits – 1 = both true; • 0 in the mask clears and 1 preserves original • | - used to set bits – 1= either true; • 1 in the mask sets to 1 and 0 preserves original • ^ - used to reverse bits – 1 = only one true; • 1 in the mask reverses bits and 0 preserves

28. Bitwise Summary • ~ one’s complement – reverses every bit • Set your mask using shifting • << a number : left shift by the number and zero fill • >> a number : right shift by the number and zero fill • Extra gift – ternary operator – embedded if/else: • (a > b)? j: x; If a is greater than b then replace expression with j, otherwise replace with x.

More Related