1 / 22

Introduction to Arithmetic Expressions and Assignment Statements

Learn about arithmetic expressions and assignment statements in programming languages, including operator precedence, operand evaluation, type mismatches, short-circuit evaluation, and mixed-mode assignment.

fernandezr
Download Presentation

Introduction to Arithmetic Expressions and Assignment Statements

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Chapter 7 Expressions and Assignment Statements

  2. Introduction Arithmetic Expressions Overloaded Operators Type Conversions Relational and Boolean Expressions Short-Circuit Evaluation Assignment Statements Mixed-Mode Assignment

  3. - Expressions are the fundamental means of specifying computations in a programming language - To understand expression evaluation, we need to be familiar with the orders of operator and operand evaluation - The essence of imperative languages is the dominant role of assignment statements

  4. Introduction • Issues • Order of evaluation • Type mismatch and coercions • Short circuit evaluation • Assignment statement • Used in imperative languages to change the value of a variable • Contains an expression to be evaluated and a target location for the answer.

  5. Arithmetic Expressions • Most of the characteristics of arithmetic expressions in programming languages were inherited from conventions that had evolved in mathematics. • The purpose of an arithmetic expression is to specify an arithmetic computation. The two actions of this are: • fetching the operands, usually from memory, • executing the arithmetic operations on those operands • In programming languages, arithmetic expressions consist of operators, operands, parentheses, and function calls. • The operators can be unary, meaning they have a single operand, or binary, meaning they have two operands. • C, C++, and Java include a ternary operator, which has three operands.

  6. Arithmetic Expressions (continued) • Design issues for arithmetic expressions • What are the operator precedence (priority) rules? • What are the operator associativity rules? • What is the order of operand evaluation? • Are there restrictions on operand evaluation side effects? • Does the language allow user-defined operator overloading? • What mode mixing is allowed in expressions?

  7. Arithmetic Expressions (continued) • Number of operands for an operator • A unary operator has one operand • A binary operator has two operands • A ternary operator has three operands • 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) • *, /, % • +, -

  8. Arithmetic Expressions (continued) • The order of an expression depends on the order of evaluation of the operators • The operator precedence rules for expression evaluation define the order in which operators of different precedence levels are evaluated. These rules are based on the hierarchy of operator priorities. • Unary addition is called identity operator because it usually has no associated operation and thus has no effect on its operand.

  9. Arithmetic Expressions (continued) • 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., FORTRAN) • APL is different; all operators have equal precedence and all operators associate right to left • Precedence and associativity rules can be overriden with parentheses • Operand evaluation order The process: • Variables: just fetch the value • Constants: sometimes a fetch from memory; sometimes the constant is in the machine language instruction • Parenthesized expressions: evaluate all operands and operators first • Function references: The case of most interest! • Order of evaluation is crucial

  10. Arithmetic Expressions (continued) • Functional side effects - when a function changes a two-way parameter or a nonlocal variable • The problem with functional side effects: • When a function referenced in an expression alters another operand of the expression e.g., for a parameter change: a = 10; b = a + fun(&a); /* Assume that fun changes its parameter */ • Same problem with global variables

  11. Arithmetic Expressions (continued) • Two Possible Solutions to the Problem: • Write the language definition to disallow functional side effects • No two-way parameters in functions • No nonlocal references in functions • Advantage: it works! • Disadvantage: Programmers want the flexibility of two-way parameters (what about Java?) and nonlocal references • Write the language definition to demand that operand evaluation order be fixed • Disadvantage: limits some compiler optimizations • Conditional Expressions • C, C++, and Java (?:) e.g. average = (count == 0)? 0 : sum / count;

  12. Overloaded Operators • Operator overloading is the multiple use of operators. • Example, the “+” is used for addition and for string concatenation in Java. • The “&’’ in C is a problem and overloading the – and + operator is also a problem. • Loss of compiler • Loss of readability • Can be avoided by introducing new symbols • C++ and Ada allow user-defined overloaded operators • Potential problem if user defines ”nonsense” operators like using + to mean multiply

  13. Type Conversions • A narrowingconversion is one that converts an object to a type that cannot include all of the values of the original type e.g., float to int • A wideningconversion is one in which an object is converted to a type that can include at least approximations to all of the values of the original type e.g., int to float • A mixed-mode expression is one that has operands of different types • A coercion is an implicit type conversion, either during compilation or during run time. A typical example would be an expression mixing integer and floating point numbers (like 5 + 0.1), where the integers are normally converted into the latter • The disadvantage of coercions: • They decrease the type error detection ability of the compiler • In most languages, all numeric types are coerced in expressions, using widening conversions • In Ada, there are virtually no coercions in expressions

  14. Type Conversions (cont.) • Explicit Type Conversions • Often called casts e.g. • Ada: FLOAT(INDEX) -- INDEX is INTEGER type • Java: (int)speed /* speed is float type */ • Errors in Expressions • Caused by: • Inherent limitations of arithmetic e.g. division by zero • Limitations of computer arithmetic e.g. overflow • Such errors are often ignored by the run-time system

  15. Relational and Boolean Expressions • Relational Expressions: • Use relational operators and operands of various types • Evaluate to some Boolean representation • Operator symbols used vary somewhat among languages (!=, /=, .NE., <>, #) • Boolean Expressions: • Operands are Boolean and the result is Boolean • Operators: FORTRAN 90 Java C Ada and & && and or | || or not ! ! not ^ xor • 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

  16. Relational and Boolean Expressions (continued) • The precedence of the arithmetic, relational, and Boolean operators in the C-based languages is as follows: postfix ++, -- unary +, -, prefix ++, --, ! *, /, % binary +, - <, >, <=, >= ==, != && || • C, C++, and Java have over 40 operators and least 14 different levels of precedence

  17. Short Circuit Evaluation • A short-circuit evaluation of an expression is one in which the result is determined without evaluating all of the operands and/or operators. • Ex., (13 * A) * (B / 13 – 1) is independent of the value (B / 13 – 1) if a is 0. Because 0*x = 0 for any x. So if A is 0 there is no need to evaluate (B / 13 – 1). • Short-circuit evaluation of expressions exposes the problem of allowing side effects in expressions. • C, C++, and Java: use short-circuit evaluation for the usual Boolean operators (&& and ||). • Short-circuit evaluation exposes the potential problem of side effects in expressions e.g. (a > b) || (b++ / 3)

  18. Assignment Statements • The operator symbol: = FORTRAN, BASIC, PL/I, C, C++, Java := ALGOLs, Pascal, Ada = Can be bad if it is overloaded for the relational operator for equality • e.g. (PL/I) A = B = C; A is set to the Boolean value for the result of B = C • In the C statement A = B = C, the value of C is assigned to B, and the value of B is assigned to A.

  19. Assignment Statements (continued) • More complicated assignments: • Multiple targets (PL/I) A, B = 10 • Conditional targets (C, C++, and Java) if(flag) count1 = 0; else count2 = 0; • Compound assignment operators (C, C++, and Java) sum += next; • Unary assignment operators (C, C++, and Java) a++; • C, C++, and Java treat = as an arithmetic binary operator • e.g. a = b * (c = d * 2 + 1) + 1 • This is inherited from ALGOL 68

  20. Assignment Statements (continued) • Assignment as an Expression • In C, C++, and Java, the assignment statement produces a result • So, they can be used as operands in expressions e.g. while ((ch = getchar()) != EOF) { ... } • Disadvantage • Another kind of expression side effect of changing its left operand.

  21. Mixed-Mode Assignment • In FORTRAN, C, and C++, any numeric value can be assigned to any numeric scalar variable; whatever conversion is necessary is done • In Pascal, integers can be assigned to reals, but reals cannot be assigned to integers (the programmer must specify whether the conversion from real to integer is truncated or rounded) • In Java, only widening assignment coercions are done • In Ada, there is no assignment coercion

  22. Summary • Expressions • Operator precedence and associativity • Operator overloading • Mixed-type expressions • Various forms of assignment

More Related