下面的表格列出了C++运算符的优先级和相关性。运算符列表从上到下，优先级逐步降低。
|
Precedence
|
Operator
|
Description
|
Associativity
|
|
1
|
::
|
Scope resolution
|
Left-to-right →
|
|
2
|
a++ a--
|
Suffix/postfix increment and decrement
|
|
|
type() type{}
|
Functional cast
|
||
|
a()
|
Function call
|
||
|
a[]
|
Subscript
|
||
|
. ->
|
Member access
|
||
|
3
|
++a --a
|
Prefix increment and decrement
|
Right-to-left ←
|
|
+a -a
|
Unary plus and minus
|
||
|
! ~
|
Logical NOT and bitwise NOT
|
||
|
(type)
|
C-style cast
|
||
|
*a
|
Indirection (dereference)
|
||
|
&a
|
Address-of
|
||
|
sizeof
|
Size-of
|
||
|
co_await
|
await-expression (C++20)
|
||
|
new new[]
|
Dynamic memory allocation
|
||
|
delete delete[]
|
Dynamic memory deallocation
|
||
|
4
|
.* ->*
|
Pointer-to-member
|
Left-to-right →
|
|
5
|
a*b a/b a%b
|
Multiplication, division, and remainder
|
|
|
6
|
a+b a-b
|
Addition and subtraction
|
|
|
7
|
<< >>
|
Bitwise left shift and right shift
|
|
|
8
|
<=>
|
Three-way comparison operator (since C++20)
|
|
|
9
|
< <= > >=
|
For relational operators < and ≤ and > and ≥ respectively
|
|
|
10
|
== !=
|
For equality operators = and ≠ respectively
|
|
|
11
|
a&b
|
Bitwise AND
|
|
|
12
|
^
|
Bitwise XOR (exclusive or)
|
|
|
13
|
|
|
Bitwise OR (inclusive or)
|
|
|
14
|
&&
|
Logical AND
|
|
|
15
|
||
|
Logical OR
|
|
|
16
|
a?b:c
|
Ternary conditional
|
Right-to-left ←
|
|
throw
|
throw operator
|
||
|
co_yield
|
yield-expression (C++20)
|
||
|
=
|
Direct assignment (provided by default for C++ classes)
|
||
|
+= -=
|
Compound assignment by sum and difference
|
||
|
*= /= %=
|
Compound assignment by product, quotient, and remainder
|
||
|
<<= >>=
|
Compound assignment by bitwise left shift and right shift
|
||
|
&= ^= |=
|
Compound assignment by bitwise AND, XOR, and OR
|
||
|
17
|
,
|
Comma
|
Left-to-right →
|
备注：
1，sizeof 的操作数不能是 C 风格的类型转换：表达式 sizeof (int) * p 可以明确地解释为 (sizeof(int)) * p，但不能解释为 sizeof((int)*p) 。* 而不是 sizeof((int)*p)。
(The operand of sizeof can't be a C-style type cast: the expression sizeof (int) * p is unambiguously interpreted as (sizeof(int)) * p, but not sizeof((int)*p).)
2，条件运算符中间（?和:之间）的表达式被当作括号来解析：它相对于?:的优先级被忽略。
(The expression in the middle of the conditional operator (between ? and :) is parsed as if parenthesized: its precedence relative to ?: is ignored.)
在解析表达式时，列在上表某一行的优先级操作符与其参数的绑定（就像用括号绑定一样）将比列在下一行的优先级操作符更紧密。例如，表达式 std::cout << a & b 和 *p++ 被解析为 (std::cout << a) & b 和 *(p++)，而不是 std::cout << (a & b) 或 (*p)++。 (When parsing an expression, an operator which is listed on some row of the table above with a precedence will be bound tighter (as if by parentheses) to its arguments than any operator that is listed on a row further below it with a lower precedence. For example, the expressions std::cout << a & b and *p++ are parsed as (std::cout << a) & b and *(p++), and not as std::cout << (a & b) or (*p)++.)
具有相同优先级的运算符按关联方向与参数绑定。例如，表达式 a = b = c 被解析为 a = (b = c)，而不是 (a = b) = c，这是因为赋值具有从右到左的关联性，但 a + b - c 被解析为 (a + b) - c，而不是 a + (b - c)，这是因为加法和减法具有从左到右的关联性。 (Operators that have the same precedence are bound to their arguments in the direction of their associativity. For example, the expression a = b = c is parsed as a = (b = c), and not as (a = b) = c because of right-to-left associativity of assignment, but a + b - c is parsed (a + b) - c and not a + (b - c) because of left-to-right associativity of addition and subtraction.)
关联性规范对于一元运算符来说是多余的，只是为了完整才显示出来：一元前缀运算符总是从右向左关联（delete ++*p 是 delete(++(*p))），而一元后缀运算符总是从左向右关联（a[1][2]++ 是 ((a[1])[2])++ ）。请注意，关联性对于成员访问运算符是有意义的，即使它们与一元后缀运算符组合在一起：a.b++ 的解析结果是 (a.b)++ 而不是 a.(b++)。 （Associativity specification is redundant for unary operators and is only shown for completeness: unary prefix operators always associate right-to-left (delete ++*p is delete(++(*p))) and unary postfix operators always associate left-to-right (a[1][2]++ is ((a[1])[2])++). Note that the associativity is meaningful for member access operators, even though they are grouped with unary postfix operators: a.b++ is parsed (a.b)++ and not a.(b++).）
操作符优先级不受操作符重载的影响。例如，std::cout << a ? b : c;解析为 (std::cout << a) ? b : c;，因为算术左移的优先级高于条件运算符。 (Operator precedence is unaffected by operator overloading. For example, std::cout << a ? b : c; parses as (std::cout << a) ? b : c; because the precedence of arithmetic left shift is higher than the conditional operator.)
说明(Notes)
优先级和关联性是编译时概念，与运算时概念的运算顺序无关。（Precedence and associativity are compile-time concepts and are independent from order of evaluation, which is a runtime concept.）
标准本身并没有规定优先级。它们是从语法中推导出来的。(The standard itself doesn't specify precedence levels. They are derived from the grammar.)
const_cast、static_cast、dynamic_cast、reinterpret_cast、typeid、sizeof...、noexcept 和 alignof 不包括在上面的优先级列表内，因为它们不会产生歧义。(const_cast, static_cast, dynamic_cast, reinterpret_cast, typeid, sizeof..., noexcept and alignof are not included since they are never ambiguous.)
有些运算符有不同的拼写（例如，and 表示 &&，or 表示 ||，not 表示 !，等等）。 (Some of the operators have alternate spellings (e.g., and for &&, or for ||, not for !, etc.).)
在 C 语言中，三元条件运算符的优先级高于赋值运算符。因此，表达式 e = a < d ? a++ : a = d，在 C++ 中解析为 e = ((a < d) ? (a++) : (a = d)），但在 C中由于语法或语义的限制，该表达式将无法编译。详见相应的C文档。 （In C, the ternary conditional operator has higher precedence than assignment operators. Therefore, the expression e = a < d ? a++ : a = d, which is parsed in C++ as e = ((a < d) ? (a++) : (a = d)), will fail to compile in C due to grammatical or semantic constraints in C. See the corresponding C page for details.）
常用操作符(Common operators)
|
Common operators
|
||||||
|
assignment
|
increment
decrement
|
arithmetic
|
logical
|
comparison
|
member
access
|
other
|
|
a = b
a += b
a -= b
a *= b
a /= b
a %= b
a &= b
a |= b
a ^= b
a <<= b
a >>= b
|
++a
--a
a++
a--
|
+a
-a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b
|
!a
a && b
a || b
|
a == b
a != b
a < b
a > b
a <= b
a >= b
a <=> b
|
a[...]
*a
&a
a->b
a.b
a->*b
a.*b
|
function call
|
|
a(...)
|
||||||
|
comma
|
||||||
|
a, b
|
||||||
|
conditional
|
||||||
|
a ? b : c
|
||||||
特殊操作符(Special operators)
|
Special operators
|
||||||
|
static_cast converts one type to another related type
dynamic_cast converts within inheritance hierarchies
const_cast adds or removes cv-qualifiers
reinterpret_cast converts type to unrelated type
C-style cast converts one type to another by a mix of static_cast, const_cast, and reinterpret_cast
new creates objects with dynamic storage duration
delete destructs objects previously created by the new expression and releases obtained memory area
sizeof queries the size of a type
sizeof... queries the size of a parameter pack (since C++11)
typeid queries the type information of a type
noexcept checks if an expression can throw an exception (since C++11) alignof queries alignment requirements of a type (since C++11) |
参考：
1，C++ Operator Precedence