本文共 3283 字,大约阅读时间需要 10 分钟。
The following table lists the precedence and associativity of C++ operators. Operators are listed top to bottom, in descending precedence.
Precedence | Operator | Description | Associativity |
---|---|---|---|
1 | :: | Left-to-right | |
2 | ++ -- | Suffix/postfix | |
type() type{} | |||
() | |||
[] | |||
. -> | |||
3 | ++ -- | Prefix | Right-to-left |
+ - | Unary | ||
! ~ | and | ||
(type) | |||
* | (dereference) | ||
& | |||
sizeof | |||
new new[] | |||
delete delete[] | |||
4 | .* ->* | Left-to-right | |
5 | * / % | ||
6 | + - | ||
7 | << >> | Bitwise | |
8 | < <= | For < and ≤ respectively | |
> >= | For > and ≥ respectively | ||
9 | == != | For = and ≠ respectively | |
10 | & | ||
11 | ^ | (exclusive or) | |
12 | | | (inclusive or) | |
13 | && | ||
14 | || | ||
15 | ?: | Right-to-left | |
throw | |||
= | (provided by default for C++ classes) | ||
+= -= | by sum and difference | ||
*= /= %= | by product, quotient, and remainder | ||
<<= >>= | by bitwise left shift and right shift | ||
&= ^= |= | by bitwise AND, XOR, and OR | ||
16 | , | Left-to-right |
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)
.?
and :
) is parsed as if parenthesized: its precedence relative to ?:
is ignored.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 << a & b and *p++ are parsed as ( << a) & b and *(p++), and not as << (a & b) or (*p)++.
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.
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++))
Operator precedence is unaffected by .
Precedence and associativity are compile-time concepts and are independent from , which is a runtime concept.
The standard itself doesn't specify precedence levels. They are derived from the grammar.
, , , , , , and are not included since they are never ambiguous.
Some of the operators have (e.g., and for &&
, or for ||
, not for !
, etc.).
Relative precedence of the ternary conditional and assignment operators differs between C and C++: in C, assignment is not allowed on the right-hand side of a ternary conditional operator, so e = a < d ? a++ : a = dcannot be parsed. Many C compilers use a modified grammar where ?:
has higher precedence than =
, which parses that as e = ( ((a < d) ? (a++) : a) = d ) (which then fails to compile because ?:
is never lvalue in C and =
requires lvalue on the left). In C++, ?:
and =
have equal precedence and group right-to-left, so that e = a < d ? a++ : a = d parses as e = ((a < d) ? (a++) : (a = d)).
转载地址:http://ptiqb.baihongyu.com/