Expressions and Assignment Statements Introduction

• 
  Expressions are the fundamental means of specifying computations in a programming language
  
• 
  To understand expression evaluation, need to be familiar with the orders of operator and operand evaluation
  
• 
  Essence of imperative languages is dominant role of assignment statements
  
• 
  The purpose of an assignment statement is to change the value of a variable.
  

• 
  Arithmetic evaluation was one of the motivations for the development of the first programming languages
  
• 
  Arithmetic expressions consist of operators, operands, parentheses, and function calls
  

• 
  Design issues for arithmetic expressions
  
  • 
    operator precedence rules
    
  • 
    operator associativity rules
    
  • 
    order of operand evaluation
    
  • 
    operand evaluation side effects
    
  • 
    operator overloading
    
  • 
    mode mixing expressions
    

• 
  A unary operator has one operand
  
• 
  A Unary addition is called the identity operator, has no affect of its operand. In Java, unary plus or minus actually does have an effect when its operand is short or byte, it causes an implicit conversion of that operand to int type.
  
• 
  Unary minus operator can appear at the beginning or anywhere, as long as it is parenthesized. Ex: A+(-B) *C
  
• 
  A binary operator has two operands. (Infix in most languages, prefix in some operators of Perl).
  
• 
  A ternary operator has three operands ? : , included in the C-based languages.
  

• 
  The operator precedence rules for expression evaluation define the order in which “adjacent” operators of different precedence levels are evaluated
  
• 
  Typical precedence levels
  
  • 
    parentheses
    
  • 
    unary operators
    
  • 
    ** (if the language supports it)
    
  • 
    *, /
    
  • 
    +, -
    
• 
  The precedence of the arithmetic operators of a few common programming languages are as follows: (sorted from the highest to the lowest)
  

Fortran	C-based	Ada
**	Postfix ++, --	**, abs
*, /	Prefix ++, --, unary +, -	*, /, mod, rem
All +, - Binary +, -	*, /, %	Unary +, -
	Binary +, -	Binary +, -

• 
  The (**) operator is exponentiation. The (%) operator of C is exactly like the (rem) of Ada, it takes two integer operands and yield the reminder of 1^st divided by 2^nd.
  
• 
  The Ada (mod) operator is identical to (rem) when both operands are positive, but can be different when one or both are negative.
  
• 
  The (abs) od Ada is a unary operator that yields the absolute value of its operand.
  

• 
  The operator associativity rules for expression evaluation define the order in which adjacent operators with the same precedence level are evaluated
  
• 
  Typical associativity rules
  
  • 
    Left to right, except **, which is right to left
    
  • 
    Sometimes unary operators associate right to left (e.g., in FORTRAN) A**B**C. The right operator is evaluated 1^st.
    
  • 
    In Ada, exponentiation is non associative, which means that the expression A**B**C is illegal. The expression must be parenthesized to show the desired order. (A**B)**C or A**(B**C)
    
  • 
    In VB the exponentiation (^) is left associative.
    
  • 
    Fortran unary and binary minus operators have the same precedence, but in Ada and most other common languages, unary minus have precedence over binary minus.
    

Consider the following –A/B , -A*B The relative precedence of the unary minus and binary operators are irrelevant. i.e. the order of evalustion of the two operators has no effect on the value of the expression.

But, -A**B, has an effect. Fortran, VB and Ada are the oly languages exponentiation operator.In these languages the exponentiation has higher precedence over unary minus. So, -A**B  -(A**B)

If the unary operator appears at positions other than at the left of the expression, it must be parenthesized, in order to give it highest precedence.

There is one situation where the precedence of a unary operator can be confusing. N Ada, the precedence of unary minus is lower than that of (mod),so expression -17 mod 5 is equivalent to –(17 mod 5) which evaluated to -2, rather than 3, which would be the result if unary minus had higher precedence than (mod), as it does in C-based languages. (A mod B= (A+k*B) mod B)

• 
  Associativity rules for some imperative languages
  

Language	Associativity rules
Fortran	Left: *, /, +, - Right: **
C-based	Left: *, /, %, binary +, binary – Right: ++, --, unary -, unary +
Ada	Left: all except ** Nonassociative **

• 
  APL is different; all operators have equal precedence and all operators associate right to left
  

• 
  Precedence and associativity rules can be overriden with parentheses. Ex: (A+B)*C
  

• 
  Conditional Expressions (?:) ternary operator
  
  • 
    C-based languages (e.g., C, C++) expression_1? expression_2: expression_3
    
  • 
    An example:
    

• 
  Evaluates as if written like
  

• 
  Operand evaluation order
  
  1. 
     Variables: fetch the value from memory
     
  2. 
     Constants: sometimes a fetch from memory; sometimes the constant is in the machine language instruction and not require a memory fetch.
     
  3. 
     If an operand is parenthesized expression, then all operators it contains must be evaluated before its value can be used as an operand.
     

• 
  Functional side effects: occurs when a function changes a two-way parameter or a non-local variable (non-local is a global variable declared outside the function but is accessible in the function).
  
• 
  Consider the expression a+fun(a) if fun does not have the side effect of changing a, then the order of evaluation of the two operands, a and fun(a), has no effect on the value of the expression.
  
• 
  If fun changes a, there I an effect.
  
• 
  Ex: suppose fun returns the value of its argument divided by 2, and changes the value of its parameter to 20.
  

a=10;

if the value of a is fetched first (in the expression evaluation process), its value is 10 and the value of the expression is 15. But if the 2^nd operand is evaluated 1^st, then the value of the first operand is 20 (because it is changed by the function), and the value of the expression is 25.

• 
  Two possible solutions to the problem of operand evaluation order.
  
  1. 
     Write the language definition to disallow functional side effects
     
     • 
       No two-way parameters in functions
       
     • 
       No non-local references in functions
       
     • 
       Advantage: it works!
       
     • 
       Disadvantage: inflexibility of two-way parameters and non-local references
       
     • 
       Consider the case of C and C++, which have only functions.
       
     • 
       To eliminate the side effects of two-way parameters and still provide subprograms that return more than one value, a new subprogram type that is similar to the procedures of the other imperative languages would be required.
       
     • 
       When efficiency is important, using access to global variables to avoid parameter passing is an important method of increasing execution speed. Ex: In compilers, access to data such as the symbol table is commonplace.
       
  2. 
     Write the language definition to demand that operand evaluation order be fixed
     
     • 
       Disadvantage: limits some compiler optimizations
       
     • 
       In Java language definition guarantees that operands appear to be evaluated in left-to-right order, eliminating the problem of side effects.
       

• 
  Use of an operator for more than one purpose is called operator overloading
  
• 
  Some are common (e.g., + for int and float Java use it for string catenation. It is accessible, as long as readability and reliability are not suffer)).
  
• 
  Some are potential trouble (e.g., * in C and C++, & if it is binary operator, specifies a bitwise logical AND operation. As a unary operator with a variable as its operand, means address of that variable (address-of-operator)).
  
  • 
    Loss of compiler error detection (omission of an operand should be a detectable error). Ex: simple keying error of leaving out 1^st operand for a bitwise AND operation can go undetected by the compiler, because it is interpreted as an address-of operator.
    
  • 
    Some loss of readability (same symbol for two completely unrelated operations).
    
  • 
    Can be avoided by introduction of new symbols (e.g., Pascal’s div for integer division)
    
• 
  C++, Ada, Fortran95, and C# allow user-defined overloaded operators
  
• 
  Potential problems:
  
  • 
    Users can define nonsense operations
    
  • 
    Readability may suffer, even when the operators make sense
    

• 
  A narrowing conversion converts a value to a type that cannot store even approximation of all of the values of the original type.
  

• 
  A widening conversion converts a value to a type that can include at least approximation of all f the values of the original type.
  

• 
  Widening conversions are nearly always safe, whereas narrowing conversions are not.
  
• 
  Type conversions can be either explicit or implicit.
  

• 
  A mixed-mode expression is one that has operands of different types.
  
• 
  Languages that allow such expressions, much define conventions for implicit operand type conversions because computers usually do not have binary operations that take operands of different types.
  
• 
  A coercion is an implicit type conversion initiated by the compiler.
  
• 
  Disadvantage of coercions:
  
  • 
    They decrease in the type error detection ability of the compiler
    

int a;

…

d=b*a;

Suppose that the second operand of (*) meant to be (c), but wrongly typed (a). because Java allows mixed-mode, compiler would not detect as an error. Simply insert code to coerce int operand (a) to float. If the previous case was in Ada, it would be error.

• 
  In most languages, all numeric types are coerced in expressions, using widening conversions
  

…

A=b+c;

The values of (b) and (c) are coerced to int and an int addition is performed, then the sum is converted to byte and put in (a).

• 
  In Ada, there are virtually no coercions in expressions
  

• 
  Explicit Type Conversions could be widening or narrowing warning message could be issued when explicit narrowing conversion results in significant change to the value of the object being converted.
  
• 
  Called casting in C-based language
  
• 
  Examples
  
  • 
    C: (int) angle
    
  • 
    Ada: Float (sum)
    

• 
  Causes due to
  
  • 
    Inherent limitations of arithmetic e.g., division by zero is disallowed
    
  • 
    Limitations of computer arithmetic e.g. overflow or underflow, where the result of an operation cannot be represented in the memory cell where it must be stored (either too large or too small).
    
• 
  Often ignored by the run-time system because it consider exceptions and programs can detect and deal with it.
  

• 
  Relational Expressions
  
  • 
    Use relational operators and operands of various types (simple like integer, or complex like character string ) ( numeric, string, ordinal types)
    
  • 
    Evaluate to some Boolean representation
    
  • 
    Operator symbols used vary somewhat among languages (!=, /=, .NE., <>, #)
    
  • 
    The relational operators always have lower precedence than arithmetic operators.
    

• 
  Boolean Expressions consist of Boolean variables, Boolean constants, relational expressions, and Boolean operators.
  
  • 
    Operands are Boolean and the result is Boolean
    
  • 
    Example operators: logical operators
    

.AND. and && and

.OR. or || or

.NOT. not ! not

xor (exclusive OR)

Ada: AND and OR operators have equal precedence.

C-based: AND has higher precedence than OR.

Relational and Boolean Expressions: No Boolean Type in C

• 
  C has no Boolean type--it uses int type with 0 for false and nonzero for true
  
• 
  One odd characteristic of C’s expressions: a < b < c is a legal expression, but the result is not what you might expect:
  
  • 
    Left most operator is evaluated, producing 0 or 1
    
  • 
    The evaluation result is then compared with the third operand (i.e., c). there is never a comparison between b and c in this expression.
    

• 
  Precedence of C-based operators (arithmetic, relational, Boolean).
  

unary +, -, prefix ++, --, !

*,/,%

binary +, -

=, !=

Lowest ||

• 
  An expression in which the result is determined without evaluating all of the operands and/or operators
  
• 
  Example: (13*a) * (b/13–1)
  

The value of the Boolean expression

(a>=0) && (b<10) if the 1^st relational expression is false, no need to evaluate the 2^nd.easily discovered during execution.

• 
  Problem with non-short-circuit evaluation
  

Both relational expressions are evaluated.

• 
  When index=length, LIST [index] will cause an indexing problem (assuming LIST has length -1 elements)
  

• 
  C, C++, and Java: use short-circuit evaluation for the usual Boolean operators (&& and ||), but also provide bitwise Boolean operators that are not short circuit (& and |)
  
• 
  Ada: programmer can specify either (short-circuit is specified with and then and or else)
  
• 
  Ex: assume List is declared 1..Listlen, the Ada code
  

Will not cause an error when Key is not in List and Index becomes larger than Listlen.

• 
  Short-circuit evaluation exposes the potential problem of side effects in expressions.
  
• 
  Suppose short-circuit evaluation is used on an expression and part of the expression that contains a side effect is not evaluated; then the side effect only occur in complete evaluation of the whole expression. If program correctness depends on the side effect, short-circuit evaluation can result in a serious error.
  e.g. (a > b) || ((b++) / 3)
  
• 
  In this expression, b is changed only when a<=b. if the programmer assumed b would be changed every time this expression is evaluated during execution, and the program’s correctness depends on it, the program will fail.
  

• 
  Assignment statements provides the mechanism by which the user can dynamically change the bindings of values to variables.
  
• 
  The general syntax
  

The assignment operator

= FORTRAN, BASIC, PL/I, C, C++, Java

:= ALGOLs, Pascal, Ada

= can be bad when it is overloaded for the relational operator for equality

Instead of typing if(x==y)….we typed if (x=y)…

This si a loss of error detection in the C design of the assignment operation that leads to program errors.

Example of safety deficiencies of C and C++ programs.

Assignment Statements: Conditional Targets

• 
  Conditional targets (C, C++, and Java)
  (flag)? total : subtotal = 0
  

Which is equivalent to

if (flag)

total = 0

else

subtotal = 0

Assignment Statements: Compound Operators

Compound Assignment operator

• 
  A shorthand method of specifying a commonly needed form of assignment
  
• 
  Introduced in ALGOL; adopted by C
  
• 
  Example
  

a = a + b

is written as

a += b
Assignment Statements: Unary Assignment Operators

• 
  Unary assignment operators in C-based languages combine increment and decrement operations with assignment
  
• 
  Examples
  

sum = ++count (count incremented, then assigned to sum) count=count+1;

sum=count;

sum = count++ (Assignment of the value of count to some occurs 1^st, then count is incremented, added to sum) sum=count;

count=count+1;

Using of unary increment operator to form a complete assignment statement.

count++ (count incremented)

When two Unary operators apply to the same operands, the association is right

-count++ (count incremented then negated) equivalent to –(count++)

Assignment as an Expression

• 
  In C, C++, and Java, the assignment statement produces a result and can be used as operands.
  
• 
  This design treats the assignment operator much like any other binary operators, except that it has te side effect of changing its left operand.
  
• 
  An example: in C
  

while ((ch = getchar())!= EOF){…}

= has lower precedence of relational operator, this why we put ch=getchar() in parenthesis.

ch = getchar() is carried out; the result (assigned to ch) is used as a conditional value for the while statement.

Disadvantages of allowing assignment statement to be operands in expressions, it provides another kind of expression side effect. Makes expressions difficult to read and understand.

Mixed-Mode Assignment

• 
  Assignment statements can also be mixed-mode, for example
  

int a, b;

float c;

c = a / b;

• 
  The coercion takes place only after the right side expression has been evaluated. One alternative will be to coerce all operands in the right side to the type of the target before evaluation as in the above example.
  
• 
  In Pascal, integer variables can be assigned to real variables, but real variables cannot be assigned to integers
  
• 
  In Java and C#, only widening assignment coercions are done. i.e. int value can be assigned to float variable, but not vice versa. This increases the reliability.
  
• 
  In Ada, there is no assignment coercion
  

Directory: academics
academics -> Table of Contents Economic Policy Causes and Consequences of the Subprime Crisis Brendan Dowling 11
academics -> Annotated Bibliography Grades 1-41
academics -> Rccw training 2014 History of Racism and Anti-Racist Activism in Lexington and Fayette County Kentucky
academics -> Welcome to surf 2016 The 23rd Annual Celebration of Achievements
academics -> Computer Basics What is a computer
academics -> University of Minnesota, Morris
academics -> Academic record 2010 – 2013 East Tennessee State University, Johnson City, tn
academics -> Rev. 10 Sep 2008 Ozark Hispanic Studies League
academics -> Editorial by Sarah Herrlein, Senior Retail Technology Analyst

Download 41.52 Kb.

Share with your friends: