In order to properly evaluate an expression such as
4 + 2 * 3, we must understand both what the operators do, and the correct order to apply them. The order in which operators are evaluated in a compound expression is called operator precedence. Using normal mathematical precedence rules (which state that multiplication is resolved before addition), we know that the above expression should evaluate as
4 + (2 * 3) to produce the value 10.
In C++, all operators are assigned a level of precedence. Those with the highest precedence are evaluated first. You can see in the table below that multiplication and division (precedence level 5) have a higher precedence than addition and subtraction (precedence level 6). The compiler uses these levels to determine how to evaluate expressions it encounters.
Thus, 4 + 2 * 3 evaluates as 4 + (2 * 3) because multiplication has a higher level of precedence than addition.
If two operators with the same precedence level are adjacent to each other in an expression, the associativity rules tell the compiler whether to evaluate the operators from left to right or from right to left. For example, in the expression
3 * 4 / 2, the multiplication and division operators are both precedence level 5. Level 5 has an associativity of left to right, so the expression is resolved from left to right:
(3 * 4) / 2 = 6.
Table of operators
- Precedence level 1 is the highest precedence level, and level 18 is the lowest. Operators with a higher precedence level get evaluated first.
- L->R means left to right associativity.
- R->L means right to left associativity.
Global scope (unary)
Class scope (binary)
Member access from object
Member access from object ptr
Run-time type information
Cast away const
Run-time type-checked cast
Cast one type to another
Compile-time type-checked cast
typeid(type) or typeid(expression)
Size in bytes
Dynamic memory allocation
Dynamic array allocation
Dynamic memory deletion
Dynamic array deletion
sizeof(type) or sizeof(expression)
Member pointer selector
Member object selector
expression * expression
expression / expression
expression % expression
expression + expression
expression - expression
Bitwise shift left
Bitwise shift right
expression << expression
expression >> expression
Comparison less than
Comparison less than or equals
Comparison greater than
Comparison greater than or equals
expression < expression
expression <= expression
expression > expression
expression >= expression
expression == expression
expression != expression
|10 L->R||&||Bitwise AND||expression & expression|
|11 L->R||^||Bitwise XOR||expression ^ expression|
|12 L->R|||||Bitwise OR||expression | expression|
|13 L->R||&&||Logical AND||expression && expression|
|14 L->R||||||Logical OR||expression || expression|
|15 R->L||?:||Conditional||expression ? expression : expression|
Bitwise shift left assignment
Bitwise shift right assignment
Bitwise AND assignment
Bitwise OR assignment
Bitwise XOR assignment
lvalue = expression
lvalue *= expression
lvalue /= expression
lvalue %= expression
lvalue += expression
lvalue -= expression
lvalue <<= expression
lvalue >>= expression
lvalue &= expression
lvalue |= expression
lvalue ^= expression
|17 R->L||throw||Throw expression||throw expression|
|18 L->R||,||Comma operator||expression, expression|
A few operators you should already recognize: +, -, *, /, (), =, <, >, <=, and >=. These arithmetic and relational operators have the same meaning in C++ as they do in every-day usage.
However, unless you have experience with another programming language, it’s likely the majority of the operators in this table will be incomprehensible to you right now. That’s expected at this point. We’ll cover many of them in this chapter, and the rest will be introduced as there is a need for them.
The above table is primarily meant to be a reference chart that you can refer back to in the future to resolve any precedence or associativity questions you have.
How do I do exponents?
You’ll note that the ^ operator (commonly used to denote exponentiation in standard mathematical nomenclature) is a Bitwise XOR operation in C++. C++ does not include an exponent operator. To do exponents in C++, #include the <cmath> header, and use the pow() function:
double x = pow(3.0, 4.0); // 3 to the 4th power
Note that the parameters and return value of pow are of type double. If you try to assign the return value of pow() to an integer variable, you’ll likely get a compiler warning about a possible loss of data. The compiler is warning you that assigning a double value to an int will drop any fractional results.
If you’re okay with this (and in the case of taking 3 to the 4th power, you know the result will be an integer), you can use a static_cast
int x = static_cast<int>(pow(3.0, 4.0));
This tells the compiler you’re intentionally doing the conversion from double to int, and to stop making noise about it.
1) You know from everyday mathematics that expressions inside of parenthesis get evaluated first. For example, in the expression
(2 + 3) * 4, the
(2 + 3) part is evaluated first.
For this exercise, you are given a set of expressions that have no parenthesis. Using the operator precedence and associativity rules in the table above, add parentheses to each expression to make it clear how the compiler will evaluate the expression.
Hint: Use the pattern column in the table above to determine whether the operator is unary (has one operand) or binary (has two operands). Review section 1.5 -- A first look at operators if you need a refresher on what unary and binary operators are.
Sample problem: x = 2 + 3 % 4
Binary operator % has higher precedence than operator + or operator =, so it gets evaluated first:
x = 2 + (3 % 4)
Binary operator + has a higher precedence than operator =, so it gets evaluated next:
Final answer: x = (2 + (3 % 4))
We now no longer need the table above to understand how this expression will evaluate.
a) x = 3 + 4 + 5;
b) x = y = z;
c) z *= ++y + 5;
d) a || b && c || d;
|3.2 -- Arithmetic operators|
|2.10 -- Chapter 2 comprehensive quiz|