Operator Precedence in C++

Most of the work a C++ program does with numbers comes down to a handful of symbols placed between two values. Plus, minus, star, slash, and percent handle arithmetic. Double equals, the less-than sign, and their relatives handle comparison. Each line of a program asks the computer for one result and prints it. When a printed line surprises you, the cause is almost always a small mismatch between what you expected the operator to do and what it actually does with the operands you gave it.

The source lists five binary arithmetic operators: plus for addition, minus for subtraction, multiply, divide, and the modulus operator for remainder. Each sits between two operands, as in x+y or x%y. Which operator you get and what it returns both depend on the types of the values on each side. The percent operator belongs to the integer world: it reports the remainder, or modulus, for integers.

Division is where most early surprises happen. When both operands are integers, the result is also an integer. The fractional portion is discarded, so the quotient is truncated toward zero. The remainder operator recovers the part that was thrown away. For positive operands, the two operators are linked by the relation below, where 3 is the quotient and 2 is the remainder. Keeping this relation in mind makes it much easier to predict what the percent operator will produce.

Comparison operators do not produce a new number the way arithmetic does. They compare two values and report whether a relationship holds. The source lists six of them: equal (==), not equal (!=), less than (<), greater than (>), less than or equal (<=), and greater than or equal (>=). Because a comparison answers a yes-or-no question, its result is a truth value. The arithmetic operators, by contrast, take two numbers and return a new numeric value.

The source describes a group it calls logical operators and recommends separating it into two clearly different tools. One tool works on the individual bits inside a value. The other works on whole conditions and returns true or false. The bit-level operators are bitwise and (&), bitwise or (|), bitwise exclusive or (^), and bitwise complement (~). Bitwise operators act on each bit of their operands and return a result of the operand type.

Each bit position is combined on its own. For the & operator, the result bit is 1 only when both operands have a 1 in that position. For the | operator, the result bit is 1 when either operand has a 1 there. Consider 6 and 3. In binary, 6 is 110 and 3 is 011. Lining the positions up gives the following.

The bitwise exclusive or (^) returns 1 in a position only when exactly one of the two operands has a 1 there. The complement (~) flips each bit of a single operand. The source identifies these as the four bit-level operators and describes them as acting on each bit, so the position of each bit is what determines the outcome.

Logical operators treat each whole operand as true or false, and they return true or false. The source lists two of them: logical and (&&) and logical or (||). Bitwise operators inspect the individual bits of the same values. This means the same numbers can produce very different results depending on which family you choose, and the two families are not interchangeable.

When a program prints something you did not expect, locate the first line whose output differs from your prediction. Work through the statements one at a time, writing down the value of each variable as you go. Then check the operator family, the operand types, and the number of symbols in the expression. Most surprising outputs come from using the wrong family, the wrong operand type, or the wrong number of symbols.