Content:

Reading: Textbook Chapter 3

Lecture 4:

Expressions

Precedence and Associativity

Lecture 5:

Mixed type expressions

Statements and Expressions

Program Style

Lecture 4

Expressions

fig. 3-1

• A sequence of operands and operators that reduces to a single value. E.g. 2 + 5 is an expression whose value is 7. The value can be any type other than void.
• An operator requires an action to be taken. E.g. + indicates that 2 numbers are to be added.
• An operand receives an operator's action. For any given operator, there may be one, two, or more operands. E.g. 2 and 5 are the operands of +.
• Primary expressions:

  Most elementary type of expression.

  Can be a variable, a constant, or an expression in parenthesis.

  E.g. a, b12, price, calc, INT_MAX, SIZE

  E.g. 5, 123.98, 'A', "Welcome"

  E.g. (2 * 3 + 4), (a = 23 + b * 6)

• Binary expressions:

  Formed by operand-operator-operand (infix) combination.

  Most common type of expression.

  Multiplicative expressions:

• • Highest priority among binary expressions.
  • Operators include *, /, %.
  • *: multiply.  If both operands are integers, then the result is an integer, otherwise the result is in the type of the higher format of the operands (float, double, or long double).

    E.g. 10 * 15

  • /: divide. If both operands are integers, then the result is the integer part of the quotient, otherwise the result is in the type of the higher format of the operands (float, double, or long double).

    E.g. 5 / 2 is 2,

    E.g. 5.0 / 2 is 2.5.

  • %: modulus. Both operands must be of integer type. The result is the remainder of division in integer type.

    E.g. 5 % 2 is 1,

    E.g. 5 % 3 is 2.

     

    Integer		Float
    Expression	Value	Expression	Value
    3 * 5	15	3.0 * 5	15.0
    20 / 6	3	20.0 / 6	3.333333
    20 % 6	2	N. A.	N. A.

  Additive expressions:

• • Operators include + and -.
  • +: addition.

    E.g. 2 + 3 is 5.

    E.g. a + 7

  • -: subtraction.

    E.g. 3 - 2 is 1.

    E.g. b - 11

  Assignment expressions:

• Operator is =.

• Simple assignment:

E.g. a = 5

E.g. b = x + 1

E.g. i = i + 1

• Evaluates expression on the right side of = and places its value in the variable on the left.
• The value of the whole expression is the value of the expression on the right of the = operator.
• The left operand must be a single variable.

• Compound assignment:

  Shorthand notation for simple assignment. Requires left operand be repeated as a part of the right expression.

  Five operators: *=, /=, %=, +=, -=.

   

  Compound expression	Equivalent simple expression
  x *= y	x = x * y
  x /= y	x = x / y
  x %= y	x = x % y
  x += y	x = x + y
  x -= y	x = x - y

   

  Expression	x	y	Expr. Value	Expr. result
  x *= y	10	5	50	x = 50
  x /= y	10	5	2	x = 2
  x %= y	10	5	0	x = 0
  x += y	10	5	15	x = 15
  x -= y	10	5	5	x = 5

   

• Unary expressions:

      One operator and one operand.

  • Sizeof:
    • Operator which tells you the size in bytes of the type specified.

      E.g. sizeof (int),

      E.g. sizeof (-345.23),

      E.g. sizeof (x),

      the results may vary from computer to computer.

       

  • Unary plus / minus:
    • The unary plus has no effect on the variable.
    • The unary minus changes the sign of the variable as the value of the expression, but has no effect on the variable itself.
    • E.g. +a, -a.

      Expression	Value of a	Value of expression
      +a	3	3
      -a	3	-3

     

  • Prefix increment / decrement:
    • fig. 3-3

    

    E.g. ++i means to increment i by 1, the effect is equivalent to i = i + 1, and the value of the expression is i after the increment. i.e. the effect takes place before the evaluation.

    The operand of a prefix increment/decrement operator must be a variable, not an expression or a constant.

    Expression	value of a before	value of a after	expression value
    ++a	10	11	11
    a = a + 1	10	11	11
    --a	10	9	9
    a = a - 1	10	9	9

• Postfix expressions:

      Operator placed after all operands.

• Postfix increment / decrement:

fig.3-2

• E.g. i++ means to increment i by 1, the effect is equivalent to i = i + 1, but the value of the expression is i before the increment! i.e. the effect takes place after the evaluation.
• Similarly, i-- means to decrement i by 1.
• The operand of a postfix increment/decrement operator must be a variable, not an expression or a constant

Precedence and Associativity

• • In the absence of parentheses, precedence and associativity determine the grouping that will be used for evaluating the expression.  The groups of operators are arranged in order of decreasing precedence as shown in the inside cover of the textbook;   the associativity for each group of operators is given in the right-hand column of the table.
  • Normally, the evaluation order follows the precedence order, with the exception of postfix increment and decrement.

Precedence

• Refer to precedence table at the inside cover of textbook.
• Adjacent operators in an expression is competing for operand between them, the operator with higher precedence winning the disputed operand. 
• E.g. 2 + 3 * 4 will be grouped as 2 + (3 * 4), the operators + and * compete for the operand 3, because the * has the higher precedence, it wins the 3.

Associativity

• Refer to precedence table at inside cover of textbook.
• Assiciativity determines whether operators with the same precedence will be grouped from left to right or from right to left.
• Left associativity groups expression from left to right and vice versa for right associativity.

fig. 3-5

• E.g. 3 * 8 / 4 % 4 * 5 will be grouped as

        (((3 * 8) / 4) % 4) * 5

since the operators have the same precedence and have left associativity.

fig. 3-6

• E.g. a += b *= c -= 5 will be grouped as

        a += (b *= (c -= 5))

since the operators have the same precedence and have right associativity. The above is then expanded to

        a = a + (b = b * (c = c – 5)).

Lecture 5

Mixed type expressions

• • Expressions that involve data not of the same type.
  • For an assignment expression, the final expression value will have the same type as the variable before the =.
  • Implicit type conversion:

    C will automatically convert intermediate values of an expression to the proper type so that the expression can be evaluated. This is called implicit type conversion.

    Implicit type conversions will always be made to the more general type of the operands.

    fig. 3-7

    

    The promotion order is: char, short, int, unsigned int, long int, unsigned long int, float, double, long double, the last one being the most general one.

    E.g. For an expression with operands of the following types: (short + long) / float, the compiler will first covert the short to long before the addition, and then from long to float before the division. The result will be in float.

     

    Expression	Intermediate type
    char + float	float
    int – long	long
    int * double	double
    float / long double	long double
    (short + long) / float	long then float

     

  • Explicit type conversion:

    You can convert data from one type to another yourself, using the cast expression operator. This is called explicit type conversion.

    E.g. (float) a will convert an integer, a, to a float.

    E.g. (float) (x + y) will convert the integer expression into a float value. Note the pair of parentheses.

    E.g. (float) a / 10 will convert a to float explicitly and the 10 to float implicitly, resulting in a float result. Note that the result will be different if parentheses are used.

    You should always make an explicit type conversion for demotion.

    E.g.    int i;

              float x =2.5;

              i = (int) (f*5);

Statements and Expressions

• • A statement causes an action to be performed by the program.

  fig. 3-8

  

  • In ANSI C, there are 6 kinds of statement: expression statement, compound statement, labeled statement, selection statement, iteration statement, jump statement. We will only cover the first two now.

   

  • Expression statements:

    An expression is turned into a statement by placing a semi-colon (;) after it.

    The semi-colon (;) is a statement terminator which tells the compiler that the statement is finished.

    When a (;) is encountered, any pending side effect (action that will be performed by the expression) is completed, the expression value is discarded, and control is passed to the following statement.

    E.g. For the statement a = 2; , the value 2 will be stored in the variable a (side effect of the expression), and the value of the expression (which is 2) will be discarded before going on to the next statement.

    E.g. For the statement a++; , if the original value of a is 5, then after executing the statement, the value will be 6, and the value of the expression (which is 5) will be discarded.

    E.g. For the statement b; , since there is no side effect, and the value of b will be discarded, this statement has no use at all.

  • Compound statements:

    Also known as block.

    Unit of code consisting of 0 or more statements.

    Allows a group of statements to become one single entity.

    Consists of an opening brace ({), an optional declaration and definition section, and an optional statement section, followed by a closing brace (}).

• All C functions has a compound statement as the function body. We have already came across a compound statement of the main function.

  Note that no semi-colon is required after the closing brace.

Predefined Constants

• Predefined constants can be defined using preprocessor directives:

Such as:

• The C preprocessor uses a simple text replacement of the name with whatever expression follows, i.e. whenever it sees the TAX_RATE, it replaces it with 0.15.

• One common mistake:

To place a semicolon ":" at the end of the command,

#define TAX_RATE 0.15;

then, for the following statement:

        salaryTax = TAX_RATE * income;

the statement after replacement becomes:

        salaryTax = 0.15; * income;

Program Style

• • The goal is to write clear and understandable code.
  • KISS (Keep It Simple and Short):

    Solve the problem in the simplest possible way.

    Always make the code easy to read and unambiguous.

    Simplify the problem by breaking it down into small, easily understood parts. Blocks of code should be no longer than one screen (about 20 lines).

  • Parentheses:

    Use parentheses even when necessary to make sure that no misunderstanding of the precedence and associativity rules will happen.

  • User Communication:

    Make sure that the user understands what the program wants and can interpret the results correctly.

    Give enough instructions in the program to users.

- End of Lectures 4 and 5-