3.1 — Operator precedence and associativity

In mathematics, an operation is a mathematical calculation involving zero or more input values (called operands) that produces an output value. Common operations (such as addition) use special symbols (such as +) that denote the operation. These symbols are called operators. Operators in programming work the same way except the names may not always be a symbol. Operators work analogously to functions that take input parameters and return a value, except they are more concise. For example, 4 + 2 * 3 is much easier to read than add(4, mult(2, 3))!

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++, when the compiler encounters an expression, it must similarly analyze the expression and determine how it should be evaluated. To assist with this, 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 operator 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 17 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.
Prec/Ass Operator Description Pattern
1 None ::
Global scope (unary)
Class scope (binary)
2 L->R ()
Function call
Uniform initialization (C++11)
Functional cast
Functional cast (C++11)
Array subscript
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
type name(expression)
type name{expression}
typeid(type) or typeid(expression)
3 R->L +
Unary plus
Unary minus
Logical NOT
Bitwise NOT
C-style cast
Size in bytes
Address of
Dynamic memory allocation
Dynamic array allocation
Dynamic memory deletion
Dynamic array deletion
sizeof(type) or sizeof(expression)
new type
new type[expression]
delete pointer
delete[] pointer
4 L->R ->*
Member pointer selector
Member object selector
5 L->R *
expression * expression
expression / expression
expression % expression
6 L->R +
expression + expression
expression - expression
7 L->R <<
Bitwise shift left
Bitwise shift right
expression << expression
expression >> expression
8 L->R <
Comparison less than
Comparison less than or equals
Comparison greater than
Comparison greater than or equals
expression < expression
expression <= expression
expression > expression
expression >= expression
9 L->R ==
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 (see note below)
Multiplication assignment
Division assignment
Modulus assignment
Addition assignment
Subtraction assignment
Bitwise shift left assignment
Bitwise shift right assignment
Bitwise AND assignment
Bitwise OR assignment
Bitwise XOR assignment
expression ? expression : expression
lvalue = expression
lvalue *= expression
lvalue /= expression
lvalue %= expression
lvalue += expression
lvalue -= expression
lvalue <<= expression
lvalue >>= expression
lvalue &= expression
lvalue |= expression
lvalue ^= expression
16 R->L throw Throw expression throw expression
17 L->R , Comma operator expression, expression

Note: The expression in the middle of the conditional operator ?: is evaluated as if it were parenthesized.

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.

That said, if you have an expression that uses operators of different types, it is a best practice to use parenthesis to explicitly disambiguate the order of evaluation.

Rule: If your expression uses different operators, use parenthesis to make it clear how the expression should evaluate, even if they are technically unnecessary.

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:

Note that the parameters and return value of pow are of type double. Note that due to rounding errors in floating point numbers, the results of pow() may not be precise (slightly smaller or larger than what you’d expect).

If you want to do integer exponents, you’re best off just using your own function to do so, like this one (that uses the “exponentiation by squaring” algorithm for efficiency):

Don’t worry if you don’t understand all of the parts of this function yet. Just beware of overflowing your integer result, which can happen very quickly if either argument is large.


1) You know from everyday mathematics that expressions inside of parentheses 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 parentheses. 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;


1) Show Solution

3.2 -- Arithmetic operators
2.10 -- Chapter 2 comprehensive quiz

82 comments to 3.1 — Operator precedence and associativity

  • Scott

    Hey there!
    I just wanted to say I’m going through your tutorials and I’m loving them! I also have a question about the Quiz part d, and this might be that I really don’t understand how those operators work yet… could that series of conditions be simplified to just b && c? If I’m following it right, once b && c is true, then the remaining questions are also true, right? This isn’t a question about the answer, I’m just wanting to know if I am following how that works. Thanks!

    • Alex

      > could that series of conditions be simplified to just b && c


      > If I’m following it right, once b && c is true, then the remaining questions are also true, right?

      Yes, but we can’t assume b && c will evaluate to true.

  • SotanahT

    Hey there!
    Seems to be an error:
    On answer a), you write that the "+" sign is left to right but on the sheet mention it’s right to left.
    EDIT: I was confused by the + for the unary plus, my bad

    Also I agree with Ole and Happilicious

    Beside these minus stuff, Great work so far

  • Andrew

    Hi everybody. I have a question, but there is something that is driving me crazy.

    How is this evaluated?

    while (exp)
    I’ve seen whiles with statements such as x=>10 or x<=50, but not with only a variable. How is this while triggered?

    • Alex

      exp is implicitly converted to a boolean value and that is evaluated. In general, a value of 0, 0.0, or nullptr will evaluate to false, and everything else will evaluate to true.

  • TOVK

    Great tutorials so far: simple & engaging. Currently on my first read-through. However I’d suggest compiling all the reference tables from all the different tutorial pages into a single (& overly long) reference page/glossary. One could use the CRTL + F search function to find the information that they are looking for. It’d be more convenient than searching the information from different pages & then keeping several tabs opened at the same time. It would be a good & supplementary addition to these tutorials and new programmers could keep the reference page open while debugging their code. Well, at least I would.

  • danny

    why doesn’t the single colon have a precedence?

  • Rayon

    I know that a few sentences in this program are not in English ,but i don’t think it matters that much because the error i keep getting is that sqrt was not declared.Do you know what the problem is?

    #include <iostream>
    using namespace std;

    int main()
        int a,b,c,D;
        float x1,x2;
        cout<<"Vnesi gi a, b i c od kvadratnata ravenka: ";
        if(D<0) cout<<"Ravenkata nema resenie za ovie koeficienti!";
        if(D==0) cout<<"Ravenkata ima edno resenie: "<<-b/2*a;
        if(D>0) {
            cout<<"Kvadratnata ravenka: "<<a<<"x^2+"<<b<<"x+"<<c<<"=0 ima dve resenija\nx1="<<x1<<"\nx2="<<x2;
        return 0;

  • functionLover

    here is a recursive definition for pow, just for fun:

  • Turya

    Hi Alex,
    Can you please explain b) question in quiz? ‘=’ is L-> R operator, so shouldn’t it be (x=y)=z?

  • Nyap

    Is it worth remembering the different operator precedence levels and their associativity rules, or should you just be aware that precedence and associativity exist?

    • Alex

      You don’t need to memorize these. For the most part, things work as expected, and the tutorials that cover these operators will generally point out when something might be non-intuitive in this regard.

      New programmers tend to have the most issues with the precedence of || vs && (assuming they are the same, when && is higher), and when using * as a dereference operator when mixed with member access operators . or -> (. and -> take precedence over *).

  • Sean

    In one of your early examples of operator precedence, the grouping used by the compiler is irrelevant.

    3 * 4 / 2 takes the form a * b / c, which = (a * b) / c = a * (b / c).

    Your use of brackets shows the precedence used clearly, but a non-trivial example may be more illustrative to some.

    Nice tutorials, by the way.

    • Alex

      I see what you’re saying, but at this point we haven’t covered what most of these operators actually do yet. So my pool to draw from for an example is somewhat limited.

      A good alternate example would be:

      3 * 4 % 3, which evaluates as (3 * 4) % 3, which equals 0 (whereas 3 * (4 % 3) equals 3). But I haven’t covered what operator % does yet.

  • Pierre

    Could you explain in a bit more detail what the exponent function you propose does? I don’t get the `if (exp & 1)` or the `exp >>= 1` and I don’t think these operators have been covered yet?


  • Patrick

    Hi Alex,

    should {} be added as part of level 2 in the Prec/Ass column of the table? Initialization  type name{expression} (C++11)

    P.s. awesome site and look forward to quizes in all tutorial chapters down the road.

  • Elpidius

    Hi Alex, in sub-chapter 3.4 — Sizeof, comma, and conditional operators, you mention that assignment has even lower precedence than the ?: operator. However I cannot see the assignment operator listed in the "Table of Operators". Could you please list it?

    Thanks in advance.

  • Grevozin

    Using pow() for computing exponents of integers and straightforward casting is an unsafe method. String like this will probably output some numbers consisting of nines only:

    • Alex

      Yes, which is why I noted that it was only okay to do if you know the arguments to pow() are small.

      • Grevozin

        This is not an overflow problem: this string gives output like "1, 10, 99, 1000, 9999,…". The problem is precision of pow() can cause the result to be 10^2=99.9999999 and then floor rounding by static_cast makes the output 10^2=99 which is totally incorrect. This problem should be avoided by using rounding to the nearest integer rather than direct static_cast or by writing your own pow() for integers (this will also work faster).

        • Alex

          I see what you’re getting at, and what you say is true. I’ve updated the article to provide an integer implementation for pow(). It’s simpler than trying to deal with all the edge cases of the double version.

  • Muhammad Kamal

    Hello… I don’t understand the associativity of special operators, in my case, static_cast…! (I’m talking about when it’s sitting alone, not with similar operators in the same statment) does left to right mean that it takes the type "int" and apply it to the expression rather than getting the expression first and then applying the type int? It’s confusing 🙁

    • Alex

      The left to right is only applicable when mixed with operators at the same level of precedence.

      • Muhammad Kamal

        But isn’t it applied on operators sitting alone like the assignment operator? It’s right to left, means it takes the rvalue and assigns it to lvalue…?! Or I’m missing something here…

        • Alex

          I’m not sure I understand what you’re asking. Assignment is an operator with a lower precedence, so the static cast is resolved first, and then an assignment is made.

          The L->R and R->L tell you which directions things resolve if multiple operators have the same precedence. For example, 3 + 4 - 5 resolves as (3 + 4) - 5. With operators of different precedence levels, the ones with more precedence go first.

          • Muhammad Kamal

            That’s not what I meant… I mean that the direction (rule) referred to by the associativity of an operator, well most of the times, makes sense if we apply that "rule" to a single operator sitting alone if it’s binary, without having to exist more than once… I noticed this "theory", that my mind picked up, in some operators like the assignment one that I mentioned, the compiler would go from righ to left with respect to every operand as in

            after it detects the two assignment operators it’d go for the rightmost assignment operator (that’s what you mean, I guess), but what I mean is that after it aims at the rightmost operator, it also looks for the rightmost (in this case it’s the only right) operand then assigns it to the left operand, like its associativity is how generally the operator operands the operands.

            Another example would probably be the bitwise shift left (or right), it has left to right associativity, thus in

            after the compiler detects the presence of the operator, it would look at its left operand and then adds the value of the right operand to it

            I dunno how would you look at this (personally I found that my point became silly after explaining it xd), but for the sake of knowledge… Maybe D:

  • Although nothing serious, the notes say «level 18 is the lowest», but the table lists only 17 levels, however.

  • Shiva

    Hi Alex, there is something that I don’t understand. Please look at the following code:

    As per the above table both pre- and post-increment ++ operators have higher precedence than the << operator. Then why, in the first case in the above code, does the value of y (which is initially 1) get printed before it is incremented? I thought y++ should be evaluated first and then sent to std::cout by the << operator and get printed. This happens in the second case, where the operator is pre-increment. Why is this so?

    • Shiva

      Okay I found the answer in the Comments section of Module ‘3.3 — Increment/decrement operators, and side effects’. If anyone has the same doubt, refer Alex’s reply to zhiwei’s question among the comments on that module. Hope this might be useful to someone. 🙂

      And Alex, thanks for these great tutorials. They are awesome! 🙂

    • Alex

      This is due to the way y++ evaluates. Since post-increment has higher precedence than <<, it evaluates first. Variable y initially has the value of 1. y++ evaluates to the current value of y (1), and then y is incremented. That value of 1 is then sent to be printed, even though y has now been changed.

  • hussein

    thanks for your useful website
    the precedence and associativity table has one problem:
    ternary conditional is put above assignment in precedence order while it is not. they should both be put at level 15.
    please see this address:

    • Alex

      You are correct. This changed between C and C++, and much of the reference material out there is incorrect (including Microsoft’s C++ precedence table for Visual Studio!). I’ve updated the table. Thanks for the tip.

  • takise

    Thanks a lot. Pre- is level 3 btw in table provided, but I got it now. My thinking was if + and ++ are both in level 3 and level 3 is R->L it should be z *= ((++(y + 5))) but lol at me now I see the difference in + in level 3 ( unary ) and + in level 6 ( addition ). All clear now 🙂 Great tutorial!

  • takise

    Hi, Alex, I can’t understand c) in your quiz. ++/- are both in level 2 and level 3. What is the difference? I assumed that if one in level 2 is called post- and one in level 3 is called pre- it matters on which side of operator they are. But in solution is z *= ((++y) + 5) so it seems ++y is level 2. How is it? Can you explain it little more?

  • Mr D

    Is it considered acceptable to use parenthesis often when in doubt about this issue, or would the purists poo-poo it and say it should be done without parenthesis and according to the rules in the above table? I, for one, doubt i’ll ever memorize all that stuff!

    • Alex

      You can never have too many parenthesis in my opinion. Parenthesis make it clear what your intent is, and reduce precedence mistakes. Use them liberally!

  • Hello,
    I encountered a really strange thing with ++ and -- operators!
    look at this snipped :

    I expected that the result (result of m) of above code should be 10 (even when I compiled it in the php the result was 10) but in C++ the result was 9!
    how is that possible!?
    an other question >

    result(m) of following code in code::blocks : 19
    result(m) of following code in borland C++ : 20

    How is that possible!?

    • Alex

      This kind of inconsistency usually results from compilers evaluating things in a different order. The C++ specification doesn’t specify the order that parameters should be evaluated, for example.

      Generally speaking, in C++ you should never use a variable that has a side effect applied to it more than once in a given expression. Doing so is asking for trouble.

  • R4Z3R

    what is the difference between :

    which one is recommended ?

  • Alex

    It’s totally acceptable.

    My personal rule of thumb is that if the exponent is both an integer and 3 or less, I just do the multiplication by hand (it’s easy enough to understand, and it saves me from having to #include the math header. If the exponent is 4 or more, or a floating point number, then I’ll favor pow().

  • Smokeycow

    I found the pow() function interesting so incorporated it into the quiz from the previous lesson. You can see where I changed "* seconds * seconds" to the pow() function. My question is, is this considered acceptable and/or recommended use? Thanks v much.

  • techsavvy....aye

    Thanks a ton.

  • techsavvy....aye

    I wanted to know if it is necessary to learn the entire table for the correct sequence of these operators. Or there are some specific operators needed for daily programming.
    Thank you.

    • Alex

      It’s not really necessary to memorize all of the precedence levels, as most of them are pretty intuitive, and you can always look them up if something isn’t working like it should. If you have any doubts, you can always disambiguate using parenthesis.

  • Abdelkarim

    hi Alex! good job keep it up (y)
    i have a question, i’m wondering! is those tutorials are all about console programs?!

    • Alex


      It’s possible to create other kinds of applications in C++, such as windowed applications or graphical applications, but I don’t cover those here, as doing so requires operating system specific functionality or add-ons.

      • Abdelkarim

        For someone who wants to learn GUI programming, is it worth it to continue with all those tutorials or should i start over with maybe other tutorials or books …!

        • Alex

          Much of the GUI stuff builds on the fundamentals you’ll learn here. If you finish these tutorials, you’ll have a great foundation for anything you want to do later.

  • Name (required)

    Hey I have a question 🙂
    What does the % operator do?

  • Kirill

    Hi there, Alex!

    Am I getting right that "+" operator (#6 Table) would be evaluated before "*" operator (#5 in Table) due to precedence level?

    But mathematically "*" should be done first…

    • Alex

      No, operator* is evaluated before operator+. I’ll try to make this more clear in the table.

      • John

        "In C++, all operators are assigned a level of precedence. Those with the highest precedence are evaluated first."

        So, + [Addition 6 L->R] is evaluated before * [Multiplication 5 L-> R] ?

        • Alex


          > Precedence level 1 is the highest precedence level, and level 17 is the lowest. Operators with a higher precedence level get evaluated first.

  • Jonathan

    Hello Alex,

    Thank you for this very well made tutorial.

    I’d like to suggest you to put 3.2 (arithmetic operators) before 3.1 (operator precedence and associativity), I think it will be easier to understand the quizz as unary arithmetic operators (+x and -x) has higher precedence than binary operators (x + y and x - y) which make this a bit confusing.

  • msk

    The quiz is really unclear in this one. I don’t understand even a bit of it.

  • Wintur

    Hey Alex,

    I cannot seem to find the exponent operator, ^. Am I missing it, or was it not included.


  • John

    just a suggestion; if you could make the chart in to an image file as well so people could save it and pull it up at any time it might be easier for referencing in the future.

  • Ole

    Just a suggestion towards readability and clarity. The R->L and L->R could maybe be changed into R -> L and R <- L ?

Leave a Comment

Put C++ code inside [code][/code] tags to use the syntax highlighter