Chap. 2. Types, Operators, and Expressions

1. Chap. 2. Types, Operators, and Expressions • 2.1 Variable Names • 2.2 Data Types and Sizes • 2.3 Constants • 2.4 Declarations 2.5 Arithmetic Operators 2.6 Relational and Logical Operators 2.7 Type Conversations 2.8 Increment and Decrement Operators 2.9 Bitwise Operators 2.10 Assignment Operators and Expressions 2.11 Conditional Expressions 2.12 Precedence and Order of Evaluation Imperative and System Programming, B. Hirsbrunner, diuf.unifr.ch/pai/ip, Lecture 2 – 28 September 2011KR – Chap. 2: ~60’; Tutorials: Memory Diagrams: ~45’, scanf: ~30’, Unix variables: ~15’; Exercises: ~30’

2. 2.1 Variable Names • Names are made of letters and digits, but : • the first character must be a letter • the underscore “_” counts as a letter (useful for improving readability) • don’t begin variable names with underscore (since library routines often use such names) • Case sensitivity • Upper and lower case are distinct, so x and X are two different names • Traditional C pratice is to use : • lower case for variable names • upper case for symbolic constants • Miscellaneous • At least the first 31 characters of an internal name are significant (!!!) • For external names, the standard guarantees uniqueness only for 6 characters (!!!) • Keywords like int, float, if, else, etc., are reserved: you can’t use them as variable names

3. 2.2 Data Types and Sizes • Basic data types • char, int, float, double • Qualifiers • short int, long int • short is often 16 bits, long 32 bits, and int either 16 or 32 bits • signed, unsigned : apply to char and any integer • if chars are 8 bits, unsigned chars have values between 0 and 255 (i.e. 0 and 28-1), while signed chars between -128 and 127 in a two’s complement machine (i.e. -27 and 27-1) • long double • Standard Header Files (see [KR88], p.257) • <limits.h> defines constants for the sizes of integral types • Examples: INT_MIN, INT_MAX, LONG_MAX, LONG_MIN • <float.h> defines constants related to floating-point arithmetic

4. 0 0 1 1 2 2 3 3 -0 -1 -2 -3 000 000 001 001 010 010 011 011 100 100 101 101 110 110 111 111 -3 -2 -1 -0 Signed integer (1/3) • Signed magnitude • The leftmost bit is the sign bit • One’s complement • To negate a number, replace each 1 by 0 and each 0 by 1

5. 000 001 111 110 010 101 011 100 Signed integer (2/3) 0 -1 1 -2 2 -3 3 -4 • Two’s complement • First step: as one’s complement • Second step: add one to the result

6. -4 -3 3 2 -2 1 -1 0 Signed integer (3/3) 000 001 111 110 010 101 011 100 • Excess 2m-1(here m=3) • a number is stored as its true value plus 2m-1

7. 1234 : integer constant 123456789L : long constant 1234U : unsigned constant 123456789UL : unsigned long Complete set of escape sequences: \a \b \f \n \r \t \v \\ \? \' \" \ooo \xhh 2.3 Constants "I am a string" : string constant "hello" "world" : string concatenation (a string constant is a array of characters, with a null character '\0'at the end; '\0'represents the character with value zero) Be careful : 'x'is a character constant and "x" is a string constant 01234 : octal (with a leading zero) 0X1234 : hexadecimal 'x' : character constant (The value of ‘x’ is the numeric value of x in the machine’s character set) Enumeration constant : enum boolean {NO, YES} enum escape {BELL = '\a', \ TAB='\t'} '\ooo' : ooo is one to three octal digits (0 .. 7) '\xhh' : hh is 1 or 2 hexadecimal digits (0 .. 9, a .. f, A .. F)

8. 2.4 Declarations • All variables must be declared before use • A declaration specifies a type, and contains a list of one or more variables of that type, as in : int lower, upper, step; char c, line[1000]; • A variable may be initialized in its declaration, as in : char esc = '\\'; int i = 0, limit = MAXLINE + 1; float eps = 1.0e-5; • External and static variables are intialized to zero by default • Automatic variables for which there is no explicit initializer have undefined (garbage) values. • const qualifier can be applied to the declaration of any variable to specify that its value will not be changed const double e = 2.71828182845905; const char msg[] = "warning: "; int strlen(const char[]);

9. 2.4 Declarations : enum variables enum {RED, GREEN, BLUE} • type enum with values RED (=0), GREEN (=1), BLUE (=2) • this is just a type, like char or int, but with different possible values enum {RED, GREEN, BLUE} c1 = RED, c2; • variable declaration c1 and c2 of type enum{RED, GREEN, BLUE} • variable c2 with value RED (=0) • variable c2 without any value; later a value, e.g. BLUE, can be assigned to c2: c2=BLUE; enumcolor_tag {RED, GREEN, BLUE} c1; • type enum{RED, GREEN, BLUE} with optional tag color_tag, and variable declaration c1 enumcolor_tag c2, c3=GREEN, c4=2; • variable declaration of type enumcolor_tag: • c2, without any value • c3, with value GREEN • c4, with value 2, i.e. BLUE

10. 2.5 Arithmetic Operators • +, -, *, /, % • The integer division / truncates any fractional part • The expression x%y, which reads “x modulus y”, produces the remainder when x is divided by y • Machine dependance for negative integer operands • The direction of truncation for / • The sign of the result for % • Precedence rules • The binary + and - operators have the same precedence, which is lower than the precedence of *, /, and %, which is in turn lower than the unary + and -. • Arithmetic operators associate left to right.

11. 2.6 Relational and Logical Operators • Relational operators: >, >=, <, <= • Equality operators: ==, != • Logical operators: &&, || • Expressions connected by && and || are evaluated left to right, and evaluation stops as soon as the truth or falsehood of the result is known • Example: for (i=0; i<lim-1 && (c=getchar()) != '\n' && c != EOF; ++i) s[i] = c; • By definition, the numeric value of a relational or logical expression is 1 if the relation is true, and 0 if the relational is false • Unary negation operator ! • Converts a non-zero operand into 0, and a zero operand into 1 • Example: if (!valid) is equivalent to if (valid == 0)

12. int –> unsigned –> long –> double char, short int float 2.7 Type Conversation • Automatic Arithmetic Conversion Rules (a slight simplified vue) Vertical conversions are always performed Horizontal conversions are performed only when necessary • Explicit type conversions : cast unary operator • (type-name) expression • Example: (double) n

13. 2.8 Increment and Decrement Operators • The increment operator ++ adds 1 to its operand, while the decrement operator -- substracts 1 • ++ and -- may be used either as prefix or postfix operators: • ++n increments n before its value is used • n++ increments n after its value has been used • Example if n is 5, then x = ++n; sets x to 6, but x = n++; sets x to 5. In both cases, n becomes 6.

14. p - n + 1 n moves the desired n bits to the right places 0-bits in the rightmost n bits and 1-bits elsewhere 0 p p - n 2.9 Bitwise Operators << left shift >> right shift ~ one’s complement (converts each 1-bit into a 0-bit and vice versa) • & bitwise AND • | bitwise inclusive OR • ^ bitwise exclusive OR Examples • n = n & 0177 (sets to zero all but the low-order 7 bits of n) • n = n & ~077 (sets the last 6 bits of n to zero) Illustration /* getbits: get n bits from position p */ unsigned my_getbits(unsigned x, int p, int n) { return (x >> (p+1-n)) & ~(~0 << n); }

15. 2.10 Assignment Operators and Expressions • Most binary operators have a corresponding assignment operator op=, where op is one of : + – * / % << >> & ^ | • If expr1 and expr2 are expressions, then expr1 op= expr2 is equivalent to expr1 = expr1 op (expr2) except that expr1 is computed only once • Assignment expression has the same value as the left expression of the assignment Example: while ((c = getchar()) != EOF) {…}

16. 2.11 Conditional Expressions • The conditional expression expr1 ? Expr2 : expr3 • provides an alternate way to write the if-else statement. • Note that the operator ?: has three operands. Such an operator is commonly called a ternary operator. • Example z = (a > b) ? a : b; /* z = max(a,b) */

17. 2.12 Precedence and Order of Evaluation • The rules for precedence and associativity of all operators are summarized in Table 2.1. • C, like most languages, does not specify the order in which the operands of an operator are evaluated. The exceptions are (with a guaranted left to right evaluation) : && || ?: , (comma operator) • Examples • In a statement like x = f() + g(); f may be evaluated before g or vice versa. • Logical expressions are evaluated from left to right and the evaluation is stopped as soon as the result TRUE or FALSE is established.

18. Table 2.1: Precedence and Associativity of Operators • Associativity Operators • left to right () [] -> . • right to left! ~ ++ -- + - * (type) sizeof left to right / % left to right+ - left to right<<>> left to right< <= > >= left to right== != left to right& left to right^ left to right| left to right&& left to right|| left to right ?: right to left= += -= *= /= %= &= ^= |= <<= >>= left to right , Remark. Unary & +, -, and * have higher precedence than the binary forms.