1 / 28

290 likes | 486 Views

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 .

Download Presentation
## CSC 270 – Survey of Programming Languages

**An Image/Link below is provided (as is) to download presentation**
Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.
Content is provided to you AS IS for your information and personal use only.
Download presentation by click this link.
While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.
During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

**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 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.**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.**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.**&&– 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**|| - Logical OR**• The logical OR operator is || and produces a 1 if either operands is nonzero; otherwise, it produces a 0.**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**Logical NOT**• The logical NOT operator ! Inverts the value; nonzero becomes 0 and 0 becomes 1.**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**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**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**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)**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**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)**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**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**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**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.**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**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.**Assignment Operators**• Caution! i *= 2 + y; is rewritten as i = i * (2+y); NOT i = (i *2) + y;**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); }**Conditional Expressions**• Why write if (a > b) z = a; else a = b; when you can write z = (a > b)? a : b;**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;**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');**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**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