Computer Programming (4) - Operators and Expressions

administrivia

Web Page - http://www.cs.tau.ac.il/~efif/courses/ComputerProgramming

what’s an operator?

something that acts on a variable or an expression
does something
- computes or retrieves a value
- changes an object

types of operators

arithmetic operators
increment/decrement operators
assignment operators
relational operators
equality operators
logical operators
there are others...

expressions

a complex topic, really
for our purposes today:
- an operator and its operands
- a variable
expressions can be nested

expression operator operand(s)
(a + b) * c * (a+b), c
(a+b) () a+b
a+b + a, b
a
b

expression	operator	operand(s)
`(a + b) * c`	`*`	`(a+b)`, `c`
`(a+b)`	`()`	`a+b`
`a+b`	`+`	`a`, `b`
a
b

expression concepts

lvalues
A reference to a location, an expression which can appear as the destination of an assignment operator indicating where a value should be stored. For example, a variable or an array element are lvalues but the constant 42 and the expression i+1 are not.
conversions
operator precedence

lvalue

this is a tough concept - but necessary!
some expressions refer to real memory (objects)
- can have a value assigned
- these are sometimes called lvalues
  - because they can be on the left side of an equals sign
some expressions are just values
- calculated, used, then thrown away

examples

given the declaration
int i;
- i is an lvalue
  - so it is legal to say:
    i = 1;
- i + 1 is not an lvalue
  - because you can’t assign a value to i + 1
  - i + 1 is just a computed value, it has no permanent memory associated with it
- 1 is not an lvalue
  - you can’t assign a value to a constant

why do we care?

some operators require lvalue operands
- for example
  
  legal: i = 1
  illegal: i + 1 = 2
this concept will come up again and again

conversions

what happens here?
- remember the computer does integer and floating-point math differently
- how does it mix the two?

conversions

it finds an acceptable type, and converts whatever is necessary.
- in this example
  int a = 1; double b = 7.35; double c; c = a + b;
- a is converted into a double and a+b is evaluated using floating-point addition

some caveats

conversions follow certain rules
- depends on the operator involved
the old variable isn’t changed
- a new object is created temporarily, you never really see it
- thus, the converted value is not an lvalue
  - this isn’t an issue in the simple cases we’ve seen so far
  - but it can be in some things we have yet to see

usual arithmetic conversions

standard conversions applied to operands to enforce type agreement.
most binary operators require operands of the same type
usually widen, not narrow, an operand

conversion rules

informally
- if either operand is a long double, convert the other to long double
- otherwise, if either operand is a double, convert the other to double
- otherwise, if either operand is float, convert the other to float
- otherwise, convert char and short to int
- then, if either operand is long, convert the other to long

conversion example

/* lower: convert character to lower case (ASCII only!) */

int lower (int c)
{
   if (c >= 'A' && c <= 'Z')
     return c + 'a' - 'A';
   else
     return c;
}

ASCII character set

operator precedence and associativity

each expression operator in C has a precedence and associativity rule
in a compound expression in the absence of parentheses, sometimes interpretation is ambiguous
a + b * c
rules of precedence and associativity clarify such situations

precedence

each operator has a precedence level
specifies how operands are grouped with operators in ambiguous situations
example:
a + b * c
* has higher precedence than +, so this expression is evaluated as
a + (b * c)

associativity

some operators have the same precedence
in that case, associativity rules come into play
associativity specifies in what order operators with equal precedence are evaluated

associativity example

a / b * c
* and / have the same precedence
* and / are left-associative
- which means left-to-right evaluation:
  (a / b) * c
- common sense in this simple example, but less obvious sometimes

arithmetic operators

+, -, *, /, %
most of these are straightforward and intuitive
these all compute values, have no side-effects
/
- works differently for integers, real numbers: for integers, result is truncated
  - the expression 9/10 will have the value 0

the modulus operator

%
int a, b, c; c = a % b;
computes the remainder of the division
both operands must be integers

precedence and associativity

Precedence	Associativity	Operator
13	left	*, /, %
12	left	+, -

arithmetic operator example

leap year determination
- a year is a leap year if it is divisible by 4 but not by 100, except for years divisible by 400.
- let’s ignore all, but the “divisible by 4” rule…
  if (year % 4 == 0) printf ("%d is a leap year\n", year); else printf ("%d is not a leap year\n", year);

increment/decrement operators

++, --
unusual operators: they change their operand (“side effect”) as well as return a value
single operand
2 flavors: pre- and post-
- preincrement/predecrement
  - value of expression is modified value
- postincrement/postdecrement
  - value of expression is value before modification
can be used as a statement by itself, to just modify the value

single operand

this is our first example of a unary operator
- that’s just a fancy name for an operator that takes only one operand

preincrement/predecrement

operator comes before value: ++i
value of expression is incremented/decremented value
example:
int i = 12; int j; j = ++i;
- final value of i is 13, j is 13

postincrement/postdecrement

operator comes after value: i++
value of expression is the original value, before it was modified.
example:
int i = 12; int j; j = i++;
- final value of i is 13, j is 12

increment/decrement operators (cont.)

overflow for signed integer types is undefined
- “overflow” means going beyond the range the type can hold
- “undefined” means the ANSI standard doesn’t constrain what must happen
- it depends on the machine/compiler you are using
overflow for unsigned integer types “wraps around”
unsigned int i = 0; i--;
i is now 4 billion and something.

precedence and associativity

Precedence	Associativity	Operator
15	left	++, -- (post)
14	right	++, -- (pre)
13	left	*, /, %
12	left	+, -

this means the expression:
i - j++
is interpreted as:
i - (j++)
and not as:
(i - j)++

increment example

int numCalls = 0;
int count (void)
{
  return numCalls++;
}

this is a function that returns a number
- every time it’s called, the number is one greater than the last time

simple assignment operator

=
sets the value of the lefthand operand to that of the right (after conversions)
left operand must be an lvalue
value of expression is the new value of the lefthand operand
- i.e., the converted value

value of assignment expression

what does this mean?
- remember that expressions can have both a value and an effect
- with the = operator, the effect is the primary reason for its existence
  - it sets the value of an object
- however, the whole expression has a value
  - which is the new value of the lefthand operand
- this means the following statement is legal
  i = j = k = 37;

compound assignment operators

+=, -=, *=, /=, %=
binary operators
a op= b is equivalent to a = a op b

a += b a = a + b

a -= b a = a - b

a *= b a = a * b

a /= b a = a / b
a %= b a = a % b
operand types are restricted as for the normal arithmetic operators

precedence and associativity

Precedence	Associativity	Operator
15	left	++, -- (post)
14	right	++, -- (pre)
13	left	*, /, %
12	left	+, -
2	right	=, +=, -=, *=, /=, %=

the assignment operators are almost the lowest precedence
- we want to evaluate everything to the right of the = before assigning the value to the lefthand operand
  i = j + 75;

assignment issues

right associativity means that
a = b = c = d + 7
is equivalent to
a = (b = (c = d + 7))
and
x *= y = z
is equivalent to
x *= (y = z)

relational operators

>, >=, <, <=
all binary operators
- take two operands
all yield an int, with a value of 1 or 0 (true/false)
- in C, there is no true/false value.
- it’s always 0 or not-0

relational operators

these are used to compare values, usually when making decisions
- since they yield a value, you could use them in an equation
- but that would be weird
  int i = 10, j = 64; int k; k = (i < j) * 38;
  versus
  int i = 10, j = 64; int k = 0; if (i < j) k = 38;

precedence and associativity

Precedence	Associativity	Operator
15	left	++, -- (post)
14	right	++, -- (pre)
13	left	*, /, %
12	left	+, -
10	left	<, >, <=, >=
2	right	=, +=, -=, *=, /=, %=

so something like this:
i < j + 3
will be interpreted as:
i < (j + 3)
and not
(i < j) + 3

relational operator issues

be careful with mixed types
example:
unsigned int i = 0; if (i > -1) { (some code …) }
- remember the two operands must be of the same type.
- C converts the –1 to an unsigned value
  - which is therefore a very big number
  - and (counterintuitively) the expression is actually false

Maintained by Efi Fogel. Last modified: November 12 2002.

`a += b`	`a = a + b`
`a -= b`	`a = a - b`
`a *= b`	`a = a * b`
`a /= b`	`a = a / b`
`a %= b`	`a = a % b`

legal:	`i = 1`
illegal:	`i + 1 = 2`