 • Print
This chapter is from the book

## 3.7. Arithmetic

Most apps perform arithmetic calculations. The arithmetic operators are summarized in Fig. 3.15. Note the various special symbols not used in algebra. The asterisk (*) indicates multiplication, and the percent sign (%) is the remainder operator (called modulus in some languages), which we’ll discuss shortly. The arithmetic operators in Fig. 3.15 are binary operators—for example, the expression f + 7 contains the binary operator + and the two operands f and 7.

If both operands of the division operator (/) are integers, integer division is performed and the result is an integer—for example, the expression 7 / 4 evaluates to 1, and the expression 17 / 5 evaluates to 3. Any fractional part in integer division is simply truncated (i.e., discarded)—no rounding occurs. C# provides the remainder operator, %, which yields the remainder after division. The expression x % y yields the remainder after x is divided by y. Thus, 7 % 4 yields 3, and 17 % 5 yields 2. This operator is most commonly used with integer operands but can also be used with floats, doubles, and decimals.

### Arithmetic Expressions in Straight-Line Form

Arithmetic expressions must be written in straight-line form to facilitate entering apps into the computer. Thus, expressions such as “a divided by b” must be written as a / b, so that all constants, variables and operators appear in a straight line. The following algebraic notation is not acceptable to compilers:

### Parentheses for Grouping Subexpressions

Parentheses are used to group terms in C# expressions in the same manner as in algebraic expressions. For example, to multiply a times the quantity b + c, we write

``a * ( b + c )``

If an expression contains nested parentheses, such as

``( ( a + b ) * c )``

the expression in the innermost set of parentheses (a + b in this case) is evaluated first.

### Rules of Operator Precedence

C# applies the operators in arithmetic expressions in a precise sequence determined by the following rules of operator precedence, which are generally the same as those followed in algebra (Fig. 3.16). These rules enable C# to apply operators in the correct order.2

When we say that operators are applied from left to right, we’re referring to their associativity. You’ll see that some operators associate from right to left. Figure 3.16 summarizes these rules of operator precedence. The table will be expanded as additional operators are introduced. Appendix A provides the complete operator precedence chart.