c语言优先级-CSDN博客

//z 2013-09-23 18:14:19 IS2120@BG57IV3 T1608511706.K.F1292029078[T4,L61,R1,V20]
1. c语言优先级详细表格

C Operator Precedence Table

This page lists C operators in order of precedence (highest to lowest). Their associativity indicates in what order operators of equal precedence in an expression are applied.

Operator	Description	Associativity
( ) [ ] . -> ++ --	Parentheses (function call) (see Note 1) Brackets (array subscript) Member selection via object name Member selection via pointer Postfix increment/decrement (see Note 2)	left-to-right
++ -- + - ! ~ (type) * & sizeof	Prefix increment/decrement Unary plus/minus Logical negation/bitwise complement Cast (convert value to temporary value of type) Dereference Address (of operand) Determine size in bytes on this implementation	right-to-left
* / %	Multiplication/division/modulus	left-to-right
+ -	Addition/subtraction	left-to-right
<< >>	Bitwise shift left, Bitwise shift right	left-to-right
< <= > >=	Relational less than/less than or equal to Relational greater than/greater than or equal to	left-to-right
== !=	Relational is equal to/is not equal to	left-to-right
&	Bitwise AND	left-to-right
^	Bitwise exclusive OR	left-to-right
\|	Bitwise inclusive OR	left-to-right
&&	Logical AND	left-to-right
\| \|	Logical OR	left-to-right
? :	Ternary conditional	right-to-left
= += -= *= /= %= &= ^= \|= <<= >>=	Assignment Addition/subtraction assignment Multiplication/division assignment Modulus/bitwise AND assignment Bitwise exclusive/inclusive OR assignment Bitwise shift left/right assignment	right-to-left
,	Comma (separate expressions)	left-to-right
Note 1: Parentheses are also used to group sub-expressions to force a different precedence; such parenthetical expressions can be nested and are evaluated from inner to outer. Note 2: Postfix increment/decrement have high precedence, but the actual increment or decrement of the operand is delayed (to be accomplished sometime before the statement completes execution). So in the statement y = x * z++; the current value of z is used to evaluate the expression (i.e., z++ evaluates to z) and z only incremented after all else is done.

//z 2013-09-23 18:14:19 IS2120@BG57IV3 T1608511706.K.F1292029078[T4,L61,R1,V20]

/* postinc.c -- 070223 (sjd)
      Demo precedence of post-increment
*/

#include <stdio.h>

int main()
{
   int i[] = {3, 5}; 
   int *p = i; 
   int j = --*p++; 
   
   printf("j = %d\n\n", j);
   system("pause");
   return 0;
}

//z 2013-09-23 18:22:39 IS2120@BG57IV3 T4026930875.K.F1292029078[T5,L62,R1,V23]
2. c++ 优先级操作符

C++ Operator Precedence

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	`::`	Scope resolution	Left-to-right
2	`++` `--`	Suffix/postfix increment and decrement
	`()`	Function call
	`[]`	Array subscripting
	`.`	Element selection by reference
	`->`	Element selection through pointer
3	`++` `--`	Prefix increment and decrement	Right-to-left
	`+` `−`	Unary plus and minus
	`!` `~`	Logical NOT and bitwise NOT
	`(type)`	Type cast
	`*`	Indirection (dereference)
	`&`	Address-of
	`sizeof`	Size-of
	`new`, `new[]`	Dynamic memory allocation
	`delete`, `delete[]`	Dynamic memory deallocation
4	`.` `->`	Pointer to member	Left-to-right
5	`*` `/` `%`	Multiplication, division, and remainder
6	`+` `−`	Addition and subtraction
7	`<<` `>>`	Bitwise left shift and right shift
8	`<` `<=`	For relational operators < and ≤ respectively
8	`>` `>=`	For relational operators > and ≥ respectively
9	`==` `!=`	For relational = and ≠ respectively
10	`&`	Bitwise AND
11	`^`	Bitwise XOR (exclusive or)
12	`\|`	Bitwise OR (inclusive or)
13	`&&`	Logical AND
14	`\|\|`	Logical OR
15	`?:`	Ternary conditional	Right-to-left
	`=`	Direct assignment (provided by default for C++ classes)
	`+=` `−=`	Assignment by sum and difference
	`*=` `/=` `%=`	Assignment by product, quotient, and remainder
	`<<=` `>>=`	Assignment by bitwise left shift and right shift
	`&=` `^=` `\|=`	Assignment by bitwise AND, XOR, and OR
16	`throw`	Throw operator (for exceptions)
17	`,`	Comma	Left-to-right

When parsing an expression, an operator which is listed on some row will be bound tighter (as if by parentheses) to its arguments than any operator that is listed on a row further below it. For example, the expressions std::cout<<a&band *p++ are parsed as (std::cout<<a)&b and *(p++), and not as std::cout<<(a&b) or (*p)++.

Operators that are in the same cell (there may be several rows of operators listed in a cell) are evaluated with the same precedence, in the given direction. 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.

An operator's precedence is unaffected by overloading.

Notes

The standard itself doesn't specify precedence levels. They are derived from the grammar.

const_cast, static_cast, dynamic_cast, reinterpret_cast and typeid are not included since they are never ambiguous.

Some of the operators have alternate spellings (e.g., and for &&, or for ||, not for !, etc.).

Common operators
assignment	increment decrement	arithmetic	logical	comparison	member access	other
a = b a = rvalue 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->b a.b a->b a.*b	a(...) a, b (type) a ? :
Special operators
`static_cast` converts one type to another compatible type `dynamic_cast` converts virtual base class to derived class `const_cast` converts type to compatible type with different cv qualifiers `reinterpret_cast` converts type to incompatible type `new` allocates memory `delete` deallocates memory `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)