Transcript 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.

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
0
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
1
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
2
Signed integer (1/3)
0
1
2
3
-0
-1
-2
-3
000
001
010
011
100
101
110
111
Signed magnitude
• The leftmost bit is the sign bit
0
1
2
3
-3
-2
-1
-0
000
001
010
011
100
101
110
111
One’s complement
• To negate a number, replace each 1 by 0 and each 0 by 1
3
Signed integer (2/3)
000
111
-1
110
001
0
1
-2
2
-3
101
010
3
-4
Two’s complement
100
• First step: as one’s complement
• Second step: add one to the result
011
4
Signed integer (3/3)
000
111
-3
3
110
2
-2
1
101
2m-1
001
-4
010
-1
0
011
100
Excess
• a number is stored as its true value plus 2m-1
5
2.3 Constants
1234
123456789L
1234U
123456789UL
01234
0X1234
: integer constant
: long constant
: unsigned constant
: unsigned long
: octal (with a leading zero)
: hexadecimal
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)
‘x’ : character constant
(The value of ‘x’ is the numeric value of x
in the machine’s character set)
Be careful : ‘x’ is a character constant and “x”
is string constant
‘\ooo’
‘\xhh’
Enumeration constant :
enum booelean { NO, YES }
enum escape { BELL = ‘\a’, TAB = ‘\t }
: ooo is one to three octal digits
: hh is 1 or 2 hexadecimal digits
6
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[]);
7
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.
8
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)
9
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)
10
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
11
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)
12
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) {…}
13
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) */
14
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
&&
||
?:
,
15