Arithmetic Operators and Expressions

Most statements you write in a program will contain expressions. An expression is a combination of values and operations that produces a result. The simplest expression might be just a single number, like 5, but more commonly you will combine numbers with operators to perform calculations. When you write 2 + 3, you are creating an expression that adds two numbers together.

An expression can be broken down into two fundamental parts: operators and operands. An operand is a value (such as a number) that the operator acts upon. An operator is a symbol that tells the program what action to perform on the operands. In the expression 2 + 3, the numbers 2 and 3 are operands, and the plus sign (+) is the operator.

To understand how expressions work, it helps to see exactly what each part does. Consider the expression 2 + 3. This expression has a clear structure: a left operand (2), an operator (+), and a right operand (3). When evaluated, this expression produces the value 5.

The same structure applies to more complex expressions. In 10 - 4, the operands are 10 and 4, and the operator is the minus sign (-). In 6 * 7, the operands are 6 and 7, and the operator is the asterisk (*). Every arithmetic expression follows this pattern: operand, operator, operand.

Programming languages support several basic arithmetic operators. Each one performs a specific mathematical operation on its operands. Understanding what each operator does is the foundation for writing correct expressions.

When an expression contains only one operator, evaluation is straightforward. But what happens when you write an expression like 2 + 3 * 4? Should the addition happen first, or the multiplication? Your knowledge of mathematics tells you that multiplication should be done first, giving you 2 + 12 = 14, not 5 * 4 = 20. This rule comes from operator precedence: the priority that determines which operators are evaluated first.

The precedence hierarchy for arithmetic operators, from highest to lowest, is: exponentiation (**), then multiplication (*), division (/), integer division (//), and modulus (%), and finally addition (+) and subtraction (-). This means that in any expression, exponentiation is evaluated first, then multiplication and division operations (left to right), and finally addition and subtraction (left to right).

Let us trace through the evaluation of 2 + 3 * 4 to see precedence in action. This expression contains two operators: addition and multiplication. According to precedence rules, multiplication has higher priority, so it is evaluated first, even though it appears to the right in the expression.

Notice that we did not evaluate the expression left to right. Even though the addition appears first in the expression, the multiplication was evaluated first because of its higher precedence. This is a crucial distinction that many beginners miss.

What happens when an expression contains two operators with the same precedence? For example, in 10 - 5 - 2, both operators are subtraction, so they have equal precedence. In this case, we use associativity to determine the order. Associativity is the rule that specifies whether operators of equal precedence are evaluated left to right or right to left.

If subtraction were right-associative, we would evaluate 5 - 2 first to get 3, then 10 - 3 to get 7. But because subtraction is left-associative, we get 3. This distinction matters, especially with operations like division and exponentiation.

Now let us apply both precedence and associativity rules to a more complex expression. Consider 2 + 3 * 4 - 5 / 2. This expression contains four operators: addition, multiplication, subtraction, and division. To evaluate it correctly, we must apply precedence first, then associativity.

Sometimes you want to evaluate an expression in a different order than the default precedence rules dictate. You can use parentheses to override precedence and force certain operations to be evaluated first. Operations inside parentheses are always evaluated before operations outside them.

For example, if you want to add 2 and 3 first, then multiply by 4, you would write (2 + 3) * 4. Without the parentheses, 2 + 3 * 4 would multiply 3 and 4 first, giving 14. With the parentheses, you get 5 * 4 = 20. Parentheses make your intention clear and can prevent bugs caused by unexpected evaluation order.