The arithmetic operations of addition, subtraction, multiplication and division are familiar ones. However, when these operations are mixed within an expression, some mechanism must be used to determine which operation is to be performed first. This is important because the value of the expression can change, based on the order in which operators are applied.
To illustrate, consider the expression:
16 + 8 / 4 - 1Should we go left to right:
((16 + 8) / 4) - 1 = (24 / 4) - 1 = 6 - 1 = 5Should we go right to left:
16 + (8 / (4 - 1)) = 16 + (8 / 3) = 16 + 2 = 18Should we start in the middle:
16 + (8 / 4) - 1 = 16 + 2 - 1 = 17We get different answers depending on the order.
Modify your program to print the result of this expression without any parentheses. Compile and execute the program.
Question #3.6.1: Which of the orders listed above appears to be correct?
The choice is not arbitrary, but may seem a bit wierd. The order in which operators are applied is determined by a characteristic called operator precedence. Each C++ operator is given a precedence or priority level, and operators with higher precedence are applied before those with lower precedence. In C++, the precedence of the operators we have seen thus far are as follows:
So, from this list, we can see that
/ should be applied
-. That's why we should start in the
16+8/4-1; we're really starting with
It's irrelevant that it's in the middle. Wherever the division
appeared (with these operators), we'd always do it first.
As indicated at the top of the list, parentheses can be used to change the order in which operators are evaluated, with the operator in the inner-most parentheses being applied first. For example, in the expression
((9-1) * (1+1))the subtraction is performed first, then the addition, and finally the multiplication.
Compute, by hand, the value of the following expression:
1 / 2 * (3 - 4) * 5 + (6 % 7 - (8 - 9) / 8)
Question #3.6.2: What is the result?
Then modify your source program to check your answer.
Question #3.6.3: What result did your program print?
Operator precedence is the reason why it is necessary to parenthesize a relational expression within an output statement. Consider this: write:
cout << i == j << endl;The insertion operator has higher precedence than the equality operator, so the value of
iwould be inserted into
cout, then the equality operator would be applied to (essentially)
((cout << i) == j) << endl;Since an
ostreamand an integer cannot be compared, the compiler generates an error for these implicit parentheses.
Question #3.6.4: What is the exact error message when you try to compile the parenthesis-free output statement?
If we instead parenthesize the expression explicitly like so:
cout << (i == j) << endl;then the equality operator is applied first, producing a boolean value, then the leftmost insertion operator is applied, inserting that boolean value into
cout. The rightmost insertion operator is then applied, inserting