Priority level |
Operator |
Name or meaning |
Use form |
Combination direction |
Description |
1 |
[] |
Array subscript |
array name [constant expression] |
Left to right |
|
() |
Parentheses |
(expression)/function name (formal parameter list) = |
|
|
. |
Member selection (object) |
Object. Member name |
|
|
|
- |
Member selection (pointer) |
Object pointers, member names |
|
|
2 |
- |
Minus sign operator |
-expression |
Right to Left |
Monocular operator |
Type |
Forcing type conversions |
(data type) expression |
|
|
++ |
Self-increment operator |
+ + variable name/variable name + + |
|
Monocular operator |
|
-- |
Self-decrement operator |
--Variable name/variable name-- |
|
Monocular operator |
|
* |
Value operator |
* Pointer variable |
|
Monocular operator |
|
& |
Fetch address operator |
& Variable Name |
|
Monocular operator |
|
! |
Logical non-operator |
! An expression |
|
Monocular operator |
|
~ |
Bitwise inverse operator |
~ Expression |
|
Monocular operator |
|
sizeof |
Length operator |
sizeof (expression) |
|
|
3 |
/ |
Except |
An expression/expression |
Left to right |
Binocular operator |
* |
By |
Expression-expression * |
Binocular operator |
|
% |
Remainder (modulo) |
Integer expression/integer expression |
|
Binocular operator |
4 |
+ |
Add |
An expression + an expression |
Left to right |
Binocular operator |
- |
Reducing |
Expression-expression |
Binocular operator |
5 |
<< |
Move left |
Variables << expressions |
Left to right |
Binocular operator |
>> |
Move right |
Variables >> expressions |
Binocular operator |
6 |
> |
Greater than |
Expressions > expressions |
Left to right |
Binocular operator |
>= |
Greater than or equal |
Expression->= expression |
Binocular operator |
|
< |
Less than |
Expressions < expressions |
|
Binocular operator |
|
<= |
Less than or equal |
Expression-<= expression |
|
Binocular operator |
7 |
== |
Equals |
Expression-= = Expression |
Left to right |
Binocular operator |
!= |
Not equal to |
Expression! = Expression |
Binocular operator |
8 |
& |
Bitwise-AND |
Expressions & Expressions |
Left to right |
Binocular operator |
9 |
^ |
Bitwise XOR OR |
An expression ^ expression |
Left to right |
Binocular operator |
10 |
| |
Bitwise OR |
Expression-expression |
Left to right |
Binocular operator |
11 |
&& |
Logic and |
Expressions && Expressions |
Left to right |
Binocular operator |
12 |
|| |
Logical OR |
An expression | | An expression |
Left to right |
Binocular operator |
13 |
?: |
Conditional operators |
Expression 1? Expression 2: Expression 3 |
Right to Left |
Trinocular operator |
14 |
= |
Assignment operators |
variable = expression |
Right to Left |
|
/= |
Assign value after addition |
Variable-/= expression |
|
|
*= |
Multiply post-Assign value |
Variable-*= expression |
|
|
|
%= |
Assign value after modulo |
Variable-%= expression |
|
|
|
+= |
Add after Assignment |
Variable + = expression |
|
|
|
-= |
Reduced-value Assignment |
Variable-= expression |
|
|
|
<<= |
Assign value after left shift |
Variable-<<= expression |
|
|
|
>>= |
Move right Post-Assignment value |
Variable->>= expression |
|
|
|
&= |
Bitwise AND post-assigned values |
Variable-&= expression |
|
|
|
^= |
Bitwise XOR or post-assignment |
Variable-^= expression |
|
|
|
|= |
Bitwise OR post-assigned value |
Variable-|= expression |
|
|
15 |
, |
Comma operator |
expression, expression,... |
Left to right |
Left-to-right sequential operation |
Description
Operators of the same precedence, the order of operations is determined by the binding direction.
Because of the number of operators in the C language, the complexity of precedence, difficult to remember, for the above operators, we can be summed up into several formulas to facilitate memory:
Priority formula
parenthesis member first; parentheses operator [] () member operator. -
All monocular second; All monocular operators such as + + + (positive)-(negative) pointer operation *&
Multiplication Yozo, plus minus four; this "remainder" means the residual operation is%
Shift five, relationship six, shift operator:<< >>, relationship:> < >= <=, etc.
Equals (and) unequal row seventh; = = = = =
Bits and Xor and bits or; these are bitwise operations: Bits and (&) XOR (^) bits or (|)
"Three points of the world" eighty or ninety;
logical or heel; logical Operator: | | and &&
12 and 11; Note order: Priority (| |) bottom-to-priority (&&)
The condition is higher than the assignment, the three-mesh operator precedence is ranked to 13-bit only than the assignment operator and the "," high
Lowest comma operation level! The comma operator has the lowest precedence
Coercion type conversion operator (data type)//++--Self-increment decrement operator//arithmetic operator: */% +-//relational operator: > >= < <= = =!=//logical operator: && | |!//conditional operator (Trinocular operator)?:/ /assignment Operator: =/= *=%= + =-=//comma operator:,//Expression: an equation consisting of an operator, a constant, a variable, or an expression that has a deterministic data type with a value of # include <stdio.h>int main (int argc, const char * argv[]) { printf ("%.2f\n", 3.14*5*5); printf ("%d\n", 56*67); int a=10; int b=; printf ("a+b =%d\n", a+b); return 0;}
The self-increment decrement operator//++--int main (int argc,const char *argv[]) { int a=10; int b=20; printf ("A=%d b=%d\n", a++,b--);//a++ <==> a=a+1 //After the statement execution is complete, change the value of a B to printf ("a =%d B =%d\n", A, b); Before the statement is executed, change the value of a, B, printf ("A=%d b=%d\n", ++a,--b); printf ("A=%d b=%d\n", (++a + a++),--b); The value of//a is undefined, and the value of the variable cannot be modified more than once in a C-language statement //printf ("b =%d\n",--b +--b); return 0;}
Arithmetic operators: */% +-int main (int argc,const char *argv[]) { int a=10, b=20; printf ("a*b =%d\n", a*b); printf ("A/b =%d\n", A/b); printf ("a%%b =%d\n", a%b);//%d%f%ld percent output one% of the first% is used to escape printf ("a+b =%d\n", a+b); printf ("A-B =%d\n", A-a); printf ("value =%d\n", a%b*a); return 0;}
Relational operators: > >= < <= = =!=int Main (int argc,const char *argv[]) { int a = ten, b=; printf ("val =%d\n", a>b); printf ("val =%d\n", a<b); printf ("(a>=b) =%d\n", a>=b); printf ("(a<=b) =%d\n", a<=b); printf ("(a==b) =%d\n", a==b); printf ("(a!=b) =%d\n", a!=b); return 0;}
Logical operators: && | |!//&& (logical AND logical multiplication)//expression 1 expression 2 ... Expression n Entire expression//true true//False true/ /True false//False false// Conclusion: For logical AND, an expression in an expression is false, Then the value of the entire expression is False//| | (Logical OR logical plus)//expression 1 expression 2 entire expression//true True//False True// true fake//False false //conclusion: For logic Plus, as long as an expression is true, the value of the entire expression is true//! (logical non)//0 is False !0 is true//expression entire expression//true false//False true int main (int argc, const char *argv[]) { int a= 0; int b=; printf ("a&&b =%d\n", a&&b); printf ("a| | b =%d\n ", a| | b); printf ("!a =%d\n",!a); return 0;}
Conditional operator (trinocular operator)?:/ /expression? Expression 1: Expression 2//If the value of the expression is true, the value of the entire expression is the value of expression 1 otherwise the value of expression 2//macro defines a function # # min (A, B) ((A<B)? ( A):(B)) #define MAX (A, A, (a) (A>b) ( A):(B)) #define MIN2 (A,b,c) (((A<b) ( A):(B)) <c)? ((a<b)? (a):(B)): c) int main (int argc, const char *argv[]) { int a=5; int b=20; int c=10; printf ("val =%d\n", a<b?a:b); printf ("min =%d\n", Min (A, b)); printf ("max =%d\n", Max (A, b)); printf ("min2 =%d\n", Min2 (A, B, c)); return 0;}
Assignment operator: =/= *=%= + =-=int Main (int argc,const char *argv[]) { int a=20;// int b=10; A = ten; printf ("A=%d\n", a); printf ("(a/=b) =%d\n", a/=b);//<==> a = A/b //a=2 printf ("(a*=b) =%d\n", a*=b);//<==> a= a*b // A=20 printf ("(a%%=b) =%d\n", a%=b);//<==> a= a%b; a=0; printf ("(a+=b) =%d\n", a+=b);//<==> a= a+b; a=; printf ("(a-=b) =%d\n", a-=b); <==> a= A-B; return 0;}
Comma operator:,//Expression 1, expression 2, expression 3, expression 4,....... The expression n//the entire expression value is the value of the expression n int main (int argc,const char *argv[]) { int a=20; int b=10; int c=30; int d=40; printf ("val =%d\n", (c=a+b,d=a-b,a*b)); return 0;}
Operator precedence//parentheses > Monocular operators > Arithmetic operators (*/% greater than +-) > Relational operators (> >= < <= greater than = = =) > && >| | > Conditional operator > Assignment operator > Comma operator//parentheses increase the priority of an expression int main (int argc,const char *argv[]) { int a=10; float f=3.14; printf ("val =%f\n", a+f);//Implicit conversion printf ("val =%d\n", A + (int) f);//Truncate printf ("val =%d\n", (int) (A+F));//Display conversion ( Forced type conversion) char ch = -34; int num = 2045678; printf ("value =%d \ n", ch + num),//char -to-int//bit-extension for positive, high 0, 1 return 0 for negative highs;} Conclusion: 1. Floating-point type data is followed by integer data, and the integer data is promoted to floating-point type data//2. For integer data char short to int long long long type//3. Only char short type data operations, char short to int type//4.float to double long dou ble type on par//5. Signed type data is aligned to unsigned type data
C-language operator excerpt