This article continues to introduce operators
6. Monocular operator
6.1 introduction to monocular operators
Operator | function |
---|---|
! | Logical reverse operation |
- | negative |
+ | positive |
& | Take address |
sizeof | The type length of the operand in bytes |
~ | The binary bit negation of a number |
- - | Front, rear -- |
++ | Front, rear++ |
* | Indirect access operator |
(type) | Cast type |
Code demonstration:
#include<stdio.h> int main() { int a = -10; int* p = NULL; printf("%d\n", !2); printf("%d\n", !0); a = -a; p = &a; printf("%d\n",sizeof(a)); printf("%d\n", sizeof a); printf("%d\n", sizeof(int)); //printf("%d\n", sizeof int); report errors return 0; }
Operation results:
It can be seen that the length of int type is 4 bytes
Code demonstration:
#include<stdio.h> int main() { int a = -10; printf("%d\n", sizeof a); printf("%d\n", sizeof int);//report errors return 0; }
Note: if an error is reported on the seventh line, the expression printf ('% d \ n', sizeof (int)); should be entered;, Only a single character can be entered without parentheses
6.2 sizeof and array
Code demonstration:
#include <stdio.h> int main() { int a = 0; int arr[3] = {1,2,3}; char str[] = "hello"; int length=sizeof(arr)/sizeof(int); int len_a = sizeof(a); int len_arr = sizeof(arr); int len_str = sizeof(str); printf("len_a=%d\n",len_a); printf("len_arr=%d\n", len_arr); printf("len_str=%d\n", len_str); printf("length=%d\n",length); return 0; }
Operation results:
It can be seen that: array length = memory space occupied by the array / space occupied by a single element
6.3 + + and -- operators
Pre + + and --
Code demonstration:
#include <stdio.h> int main() { int a = 0; int x = ++a; int y = --a; printf("%d\n",x); printf("%d\n",y); return 0; }
Operation results:
analysis:
In int x = + A; In, first self increment a, and then use a, that is, the value of the expression is the value after the self increment of A. similarly, int y = --a; In, a is reduced first and then used
Post + + and --
Use a first and then add. That is, in the above example, int x = + A; In, first use a = 0, and then increase a = 1, that is, x = 0, y = 1
7. Relational operators
name | function |
---|---|
> | |
>= | |
< | |
<= | |
!= | Used to test "inequality" |
== | Used to test "equal" |
Note: in the process of programming = = and = are written incorrectly, resulting in errors
8. Logical operators
&&Logic and
||Logical or
Logical and: if one of the two values is false, it is judged to be false
Logical or: if one of the two values is true, it is judged to be true
Distinguish logical and bitwise AND
Distinguish between logical or and bitwise OR
1&2----->0
1&&2---->1
1|2----->3
1||2---->1
9. Conditional operator
exp1 ? exp2 : exp3
Code demonstration:
#include <stdio.h> int main() { int a = 10; int b = 0; int c = 0; if (a > b) b = 3; else b = -3; c = (a > b ? 3 : -3); printf("%d %d\n", b, c); return 0; }
Operation results:
analysis:
exp1 ? exp2 : exp3
If expression 1 is true, then expression 2 is evaluated, and the result of expression 2 is the result of the whole formula
If expression 1 is false, expression 3 is evaluated, and the result of expression 3 is the result of the whole formula
Conditional operators are more concise than conditional statements
10. Comma expression
exp1, exp2, exp3, ...expN
Comma expressions are multiple expressions separated by commas
#include <stdio.h> int main() { int a = 1; int b = 2; int c = (a > b, a = b + 10, a, b = a + 1);//comma expression printf("%d\n", c); return 0; }
Operation results:
Analysis: comma expression is executed from left to right. The result of the whole expression is the result of the last expression
11. Subscript references, function calls and structure members
11.1 subscript reference
[] subscript reference operator operand: an array name + an index value
int arr[10]; Create array
arr[9] =10; Practical subscript reference operator
The two operands of [] are arr and 9.
11.2 function call
() function call operator
Code demonstration:
#include <stdio.h> void test1() { printf("haha\n"); } void test2(const char* str) { printf("%s\n", str); } int main() { test1(); //Utility () as a function call operator. test2("hello world!"); //Utility () as a function call operator. return 0; }
Operation results:
Analysis: accept one or more operands: the first operand is the function name, and the remaining operands are the parameters passed to the function.
11.3 accessing members of a structure
Access method:
. structure member name
->Structure pointer - > member name
Code demonstration:
#include <stdio.h> //student struct Stu { //member char name[20]; int age; char sex[10]; char tele[12]; }; void print(struct Stu* ps) { printf("%s %d %s %s\n", (*ps).name, (*ps).age, (*ps).sex, (*ps).tele); //-> //Structure pointer variable - > member name printf("%s %d %s %s\n", ps->name, ps->age, ps->sex, ps->tele); } int main() { struct Stu s = {"zhangsan", 20, "nan", "15596668862"}; //Structure object member name printf("%s %d %s %s\n", s.name, s.age, s.sex, s.tele); print(&s); return 0; }
Operation results:
summary
This concludes the introduction of operators in these two issues. Thank you very much for pointing out any wrong comments!! Finally, if this article is helpful to you, please connect it three times. Thank you for your support.