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 Session 2 - 25 March 2003

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 if, else, int, float, 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, while signed chars between -128 and 127 (in a two’s complement machine) • long double • Standard Header Files • <limits.h> and <float.h> contain symbolic constants for all these sizes

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 0 -1 1 110 -2 2 010 -3 3 -4 101 011 100 Signed integer (2/3) • 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 • a number is stored as its true value plus 2m-1

7. 1234 : integer constant 123456789L : long constant 1234U : unsigned constant 123456789UL : unsigned long 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) ‘\ooo’ : ooo is one to three octal digits ‘\xhh’ : hh is 1 or 2 hexadecimal digits Complete set of escape sequences: \a \b \f \n \r \t \v \\ \? \’ \” \ooo \xhh “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 string constant Enumeration constant : enum booelean { NO, YES } enum escape { BELL = ‘\a’, TAB = ‘\t } 2.3 Constants

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.5 Arithmetic Operators • +, -, *, /, % • The integer division / truncates any fractional part • The expresssion x % y, which reads “x modulus y”, produces the remainder when x is divided by y • Machine dependance for negative operands • The direction of truncation for / • The sign of the result for % • The action taken on overflow or underflow • 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.

10. 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)

11. 2.7 Type Conversation • When an operator has operands of different types, they are converted to a common type according to a small “natural” number of rules • Hierarchy • short int -> int -> long -> float -> double -> long double • Remark • char is a (signed or unsigned) short int (!!!) • Explicit type conversions : cast unary operator • (type-name) expression • Example: sqrt((double) n)

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

13. 2.9 Bitwise Operators • & bitwise AND • | bitwise inclusive OR • ^ bitwise exclusive OR • << left shift • >> right shift • ~ one’s complement (unary) • Examples • n = n & 01777 (sets to zero all but the low-order 7 bits of n) • n = n & ~077 (sets the last 6 bits of n to zero)

14. 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) {…}

15. 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) */

16. 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 && || ?: ,