- 3.1. Introduction
- 3.2. A Simple C# App: Displaying a Line of Text
- 3.3. Creating a Simple App in Visual Studio
- 3.4. Modifying Your Simple C# App
- 3.5. Formatting Text with Console.Write and Console.WriteLine
- 3.6. Another C# App: Adding Integers
- 3.7. Arithmetic
- 3.8. Decision Making: Equality and Relational Operators
- 3.9. Wrap-Up

## 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`.

Fig. 3.15 Arithmetic operators.

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 `float`s, `double`s, and `decimal`s.

### 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}

Fig. 3.16 Precedence of arithmetic operators.

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.