C++ Reference Material

Operators, with Precedence and Associativity

This page contains a table of all C++ operators, along with their precedence and their associativity.

Robert Sebesta, in *Programming the
World Wide Web, Second Edition*
(Addison-Wesley, 2002, p. 127) gives an
execellent summary of what the precedence
rules and associativity rules of a programming
language do for you. Here is his explanation, in
slightly different form:

First we need to undertand what is meant by the phrase
*adjacent operators*. It means two operators that are
separated by a single operand, such as the `+`

and `-`

in `a + b - c`

or the
`*`

and `++`

in `*p++`

.

The *precedence rules* of a language specify
which operator is evaluated first when two operators
with different precedence are adjacent in an expression.

The *associativity rules* of a language specify
which operator is evaluated first when two operators
with the same precedence are adjacent in an expression.

The table below is arranged from highest to lowest precedence as you go from top to bottom. Operators between dashed lines have the same "precedence level", of which you will note that there are 18. Associativity information is given in the center column, in which LR=Left-to-Right associativity and RL=Right-to-Left associativity).

Operators Assoc Description ---------------------------------------------------------------------- (expression) parentheses used for grouping :: RL (unary) global scope resolution operator :: LR class scope resolution operator ---------------------------------------------------------------------- () LR parentheses used for a function call () LR value construction, as in type(expression) . LR member selection via struct or class object -> LR member selection via pointer [] LR array element access const_cast LR specialized type cast dynamic_cast LR specialized type cast reinterpret_cast LR specialized type cast static_cast LR specialized type cast typeid LR type identification ++ -- LR postfix versions of increment/decrement ---------------------------------------------------------------------- All the operators in this section are unary (one argument) operators. ++ -- RL prefix versions of increment/decrement + - RL unary versions ! RL logical NOT ~ RL bitwise complement ("ones complement") & RL address of * RL dereference new RL allocates memory to dynamic object delete RL de-allocates memory allocated to dynamic object new [] RL allocates memory to dynamic array delete [] RL de-allocates memory allocated to dynamic array sizeof RL for computing storage size of data (type) RL cast (C-style type conversion) ---------------------------------------------------------------------- .* LR struct/union/object pointer (member dereference) ->* LR pointer to struct/union/object pointer (indirect member dereference) ---------------------------------------------------------------------- * / % LR multiplication and division ---------------------------------------------------------------------- + - LR addition and subtraction ---------------------------------------------------------------------- >> << LR input and output stream operators ---------------------------------------------------------------------- < <= > >= LR inequality relational ---------------------------------------------------------------------- == != LR equality relational ---------------------------------------------------------------------- & LR bitwise AND ---------------------------------------------------------------------- ^ LR bitwise XOR ---------------------------------------------------------------------- | LR bitwise OR ---------------------------------------------------------------------- && LR logical AND ---------------------------------------------------------------------- || LR logical OR ---------------------------------------------------------------------- ?: RL conditional ---------------------------------------------------------------------- = RL assignment *= RL multiplication and assignment /= RL division and assignment %= RL modulus (remainder) and assignment += RL addition and assignment -= RL subtraction and assignment ---------------------------------------------------------------------- throw LR throw exception ---------------------------------------------------------------------- , LR the operator, not the separator (combines two expressions into one) ----------------------------------------------------------------------

Precedence of operators is something that we sometimes take for granted, particularly if we are thoroughly familiar and comfortable with the standard precedence rules for the common arithmetic operators. But being too complaisant can put us at some peril, and particularly in a language like C++, which has such a variety of operators, it pays to be on our guard.

As a brief example, note from the table that the input/output operators (>> and <<) have a higher precedence than the relational operators but a lower precedence than the arithmetic operators. This means that a statement like

cout << 2 + 7;

"does the right thing" and displays a value of 9, while a statement like

cout << 2 < 7;

which you might expect to output 1 (or true), i.e., the value of the relational expression, in fact causes a syntax error, since the precedence of the operators involved means that parentheses are required as follows:

cout << (2 < 7);

The example is, of course, somewhat artificial (since how often do we really want to output the value of a conditional expression?), but it makes the point.