Operators and Expressions
Operator
Classification:
- Arithmetic operator
- Shift operators
- Bitwise operators
- Assignment operator
- unary operator
- Relational Operators
- Logical Operator
- Conditional Operator
- comma expression
- The structure members of the following table references, function calls
Arithmetic operator
+ - * / %
- All but%can be used for operations between integers and floating-point numbers
- Division operator'/': Performs an integer division if both operands are integers. As long as there are floating-point numbers in it to perform the operation, the whole expression is a division of floating-point numbers.
- The two operands of%must be integers.
Shift operators
<< Left shift >> Right Shift
Left Shift Left Discard Right Complement 0
Right Shift
- Arithmetic Right Shift
Right discard, left complement bit (*)
- Logical Right Shift
Discard on right, add 0 on left
Warning: For shift operators, do not move negative digits. This standard is undefined.
int num = 10; num>>-1;//FALSE
Bitwise operators
Bit operators:
& Bitwise and 0 is zero | Bitwise or One is one ^ xor Same as 0 but different as 1
The operand must be an integer.
Small exercises
int num1 = 1;
int num2 = 2;
printf("%d ",num1&num2);
printf("%d ",num1|num2);
printf("%d ",num1^num2);
Question: Exchange of two numbers without creating a temporary variable
Way of thinking (addition and subtraction may overflow)
code implementation
int a = 2; int b = 3; a = a+b; b = a-b; a = a-b;
Method two (thinking) a pair of numbers is the same number twice exclusive or back to itself. And Exclusive Or operations have the law of exchange
code implementation
int a = 2;
int b = 3;
a = a^b;
b = a^b;
a = a^b;
printf("%d ",a);
printf("%d ",b);
Practice:
The number of 1 integers stored in the memory binary.
Ideas: 1. The idea of short division. (Only positive numbers can be calculated).
- Calculating bitwise with 1 gives you what the last bit is, plus a right shift.
Code implementation:
int main(){
int number = 0;
int count = 0;
scanf("%d",&number);
//Negative numbers cannot be calculated
// while(number){
// if (number%2 == 1){
// count++;
// }
// number = number /2;
// }
for(i = 0;i<32;i++){ //32 because int is 32
if(1==((num>>i)&1))
count++;
}
printf("%d",count);
return 0;
}
Assignment Operator (=)
Initialization assignment, reassignment, continuous assignment.
Composite assignment operator
+= -= *= /= %= >>= <<= &= |= ^=
unary operator
| Operator | Effect |
|---|---|
| ! | Logical negation |
| - | negative |
| + | just |
| & | Take Address |
| sizeof | Type length of operand (in byte bit units) |
| ~ | Bitwise Reverse |
| – | Front and rear autosubtraction |
| ++ | Front and rear self-additions |
| * | Indirect access operator (dereference operator) |
| (type) | Forced Type Conversion |
Positive and negative are monotonic operators, and addition and subtraction are binary operators
1 is true but not necessarily 1.
Calculate Array Length= sizeof(arr)/sizeof(arr[0])
Puzzle:
int main(){
short s = 0;
int a = 10;
printf("%d\n",sizeof(s = a + 5));
printf("%d\n",s);
}
Resolution: The size of sizeof(s = a+5) ultimately depends on the type of S.
s==5 is because the expression in the sizeof operator is just an expression and does not really participate in the operation.
sizeof and array
void test1(int arr[]){
printf("%d ",sizeof(arr));//(3)
}
void test2(char ch[]){
printf("%d\n",sizeof(ch));//(4)
}
int main(){
int arr[10] = {0};
char ch[10] = {0};
printf("%d ",sizeof(arr));//(1)
printf("%d\n",sizeof(ch));//(2)
test1(arr);
test2(ch);
return 0;
}
Resolution:
(1) = sizeof(int)*10 = 40
(2) = sizeof(char)*10 = 10
(3) = sizeof(arr first element pointer) = 8 or 4 (64-bit computer and 32-bit computer)
(4) = sizeof (pointer to the first element of ch) = 8 or 4 (64-bit computer and 32-bit computer)
Relational Operators
Relational Operators
> >= < <= != ==
Logical Operator
&& ||
Distinguishing Logical And Bitwise And&And&
Distinguish Logical Or from Bitwise Or || and |
Logic is two, bitwise is one.
Written Test
What happens when the program runs?
int main(){
int i = 0,a=0,b=2,c=3,d=4;
i = a++ && ++b &&d++;
//i = a++||++b||d++;
printf("a=%d b=%d c=%d d=%d",a,b,c,d);
return 0;
}
The result is a=1 b=2 c=3 d=4
Parse: Logic and left false right side are not calculated. In a++, first use then operation. The first part of formula i is false.
What happens when the program runs?
int main(){
int i = 0,a=0,b=2,c=3,d=4;
i = a++||++b||d++;
printf("a=%d b=%d c=%d d=%d",a,b,c,d);
return 0;
}
Run result: a=1 b=3 c=3 d=4
Parse: Logical or left true. On the right there is no calculation. a++ runs false, ++ b runs true. d++ will not run.
Conditional Operator (Trinomial Operator)
Expression 1?Expression 2:Expression 3
comma expression
Expression 1,Expression 2,Expression 3,Expression 4...,Expression n
Calculate from left to right. The result of the entire expression is the result of the last expression.
int a = 1;
int b = 2;
int c = (a>b,a = b+10,a,b=a+1);
printf("%d",c);//The result is 13
The following table references, function calls, and structure members
1. [] Subscript reference operator
Operand: an array name + an index value
int arr[10];//Create Array arr[9] = 10;//Use subscript reference operator []The two operands are arr And 9.
2. () A function calls an operator and accepts one or more operands: the first operand is the function name, and the remaining operands are the parameters passed to the function.
3. Access members of a structure
Structural objects. member
->Structure Pointer->Member Name
//Creating a struct type called member in Stu C is similar to an object-oriented property
struct Stu{
char name[10];
int age;
char id[20];
};
int main(){
//A Student object is created using the struct Stu type of structure and initialized
struct Stu s1 = {"Zhang San",20,"201808520"};
printf("%s\n",s1.name);
printf("%d\n",s1.age);
printf("%s\n",s1.id);
struct Stu* ps = &s1;
printf("%s\n",ps->name);
printf("%d\n",ps->age);
printf("%s\n",ps->id);
return 0;
}
Expression evaluation
Part of the order in which expressions are evaluated is determined by the precedence and summation of operators.
Similarly, the operands of some expressions may need to be converted to other types during evaluation.
Implicit Type Conversion
C integer arithmetic operations are always performed with at least the precision of the default integer type.
To achieve this accuracy, the characters and short integer operands in the expression are converted to normal integers before they are used, a conversion called integer promotion.
The significance of integer promotion:
The integer operation of the expression is to be performed in CPU Executed within the corresponding operating device, CPU Inner Integer Operator(ALU)The byte length of an operand is usually int Its own length, but also CPU Length of the universal register. So, just in time for two char Type addition, in CPU Actually, you also need to convert to CPU The standard length of a memory integer operand. currency CPU It is difficult to directly add two 8-bit bytes(Although there may be instructions for this byte addition in machine instructions). So the lengths in the expression may be less than int Length integer value, must be converted to int or unsigned int，Then you can enter CPU To perform an operation.
Example:
Q: What is the result of the output?
char a = 3;
char b = 127;
char c = a + b;
printf("%d\n",c);
//Output-126
Resolution:
char a = 3;
//00000000000000000000000000000011
//Truncate -> 00000011 -> Save to a
char b = 127;
//00000000000000000000000001111111
//Truncate -> 01111111 -> Save to b
char c= a+b;
//a:00000011 integer promotion - > (by symbol bit promotion)
//00000000000000000000000000000011
//b:01111111 Integer Lift->
//00000000000000000000000001111111
//Addition
//00000000000000000000000010000010
//Truncate -> 10000010 -> Save to c
printf("%d\n",c);
//a:10000010 integer promotion - > (by symbol bit promotion)
//11111111111111111111111111110000010 - Complement
//11111111111111111111111111110000001 - Inverse Code
//10000000000000000000000001110 - Original
//Convert to decimal: -126
The values of b and c are promoted to normal integers and the addition is performed. After the addition operation is completed, the result is staged and stored in a.
So what is integer promotion?
Integer promotion is based on the symbol bits of the data type of the variable. The unsigned number can be directly preceded by 0.
# Integer promotion of negative numbers char a = -1; Integer Lift 11111111 (Complement Code) Complement Code-1-> Inverse Code Positive Number Invariant Negative Number Reverse # Integer promotion of positive numbers char = 1; Integer lift 00000001(Complement Code) Positive numbers have the same three codes
Example of integer promotion
//Case 1
int main(){
char a= 0xb6;//10110110
short b = 0xb600;
int c = 0xb6000000;
if(a==0xb6)
printf("a");
if(b==0xb600)
printf("b");
if(c==0xb6000000)
printf("c");
return 0;
}
Explains the existence of integer promotion.
Arithmetic Conversion
If each operand of an operator is of a different type, the operation cannot proceed unless one of the operands is converted to the type of the other. Normal arithmetic conversion.
long double double float unsigned long int long int unsigned int int
If the type of an operand ranks lower in the list above, the operation is performed after converting to the type of another operand.
Note: Arithmetic conversion should be done properly or there will be some potential problems.
float f = 3.14; int num = f;//Factor conversion, loss of precision.
Operator Properties
The evaluation of complex expressions has three factors.
- operator precedence
- Nuclearity of operators
- Whether to control the evaluation order
Which of the two adjacent operators does it hold first? Depends on priority. If the priority is the same, it depends on their combination.
operator precedence
Note: Pictures are quoted from [ https://blog.csdn.net/zhanghong056/article/details/76667298 ]
Problem code:
int main(){
int i = 1;
int ret = (++i) + (++i) +(++i);
printf("%d",ret);
printf("%d",i);
return 0;
}
//It is preliminary to decide whether the order of calculation is the addition of three numbers, but whether the first ++ i is stored before calculation or if the value is changed before calculation. This is ambiguous.
Focus:
Writing an expression is problematic if the only calculation path cannot be determined by the properties of the operator.