• C基础-操作符详解

    操作符分类：

    算数操作符：+ - * / %

    1. //算数操作符
    2. // int main()
    3. // {
    4. //     //   /除法 1.整数除法(除号两端都是整数)  2浮点数除法，除号的两端只要有一个小数就执行小数除法
    5. //     // 除法中，除数为0
    6. //     int a = 7 / 2;
    7. //     printf("%d\n",a); //3
    8. //     double b = 7 / 2;
    9. //     printf("%lf\n",b); //3.000000
    10. //     double c = 7 / 2.0;
    11. //     printf("%lf\n",c); //3.500000
    12. //     int d = 0;
    13. //     int e = 5 / d; //除数不可为0，编译器会报错
    14.  
    15. //     printf("%d\n",e);
    16.  
    17. //     return 0;
    18. // }
    19.  
    20. int main()
    21. {
    22.     int a = 17 % 8; //% 得到数整数的余数
    23.     //int b = 17.0 % 8.0; // %取模操作符的两个操作数必须都是整数才行
    24.     printf("%d\n",a);
    25.  
    26.     return 0;
    27. }

    移位操作符：<< >>

    1. //移位操作符
    2. //  <<左移操作符
    3. //  >>右移操作符
    4. //注意：以为操作符的操作数只能是整数  移动的是二进制
    5. int main()
    6. {
    7.     //int a = 15;//00000000000000000000000000001111 -原码   //00000000000000000000000000001111 -反码 //00000000000000000000000000001111 -补码
    8.     //int c = -15; //10000000000000000000000000001111 -原码 //11111111111111111111111111110000 -反码(原码的符号位不变，其他位按位取反) 11111111111111111111111111110001 -补码(反码+1就是补码)
    9.     //int b = a >> 1;//移动的就是a中的二进制信息 //0000000000000000000000000000111 -  7
    10.     //右移：算术右移（右边丢弃，左边直接补原来的符号位）  逻辑右移（右边丢弃，左边直接补0）
    11.     // C语言没有明确规定是算术右移还是逻辑右移
    12.     //int c = a << 1;//00000000000000000000000000011110
    13.     //整数的二进制表示形式 ： 原码 反码 补码 
    14.     //正整数的原码、反码、补码是相同的
    15.     //负的整数原码、反码、补码是要计算的
    16.     //首先不管是正整数还是负整数都可以写出二进制原码  1.根据正负直接写出的二进制序列就是原码
    17.     //1个整型是4个字节 = 32bit位
    18.     //整数在内存中存储的是补码
    19.     //计算的时候也是使用补码计算的
    20.     // printf("%d\n",b); //7
    21.     // printf("%d\n",c); //30
    22.  
    23.     // int d = -15; //10000000000000000000000000001111
    24.     // int e = d >> 1;//11111111111111111111111111110001  ->  11111111111111111111111111111000 -> 11111111111111111111111111110111   ->00000000000000000000000000001000
    25.     // printf("%d\n",e);
    26.  
    27.     //！移位操作符不要移负数哦
    28.     int a = 6;// 110
    29.     int b = a << 1;//1100
    30.     printf("%d\n",b); //12
    31.  
    32.     return 0;
    33. }

    位操作符：& | ^

    1. //位操作符
    2. //也是操作二进制位
    3. // &
    4. // int main()
    5. // {
    6. //     int a = 3; //00000000000000000000000000000011
    7. //     int b = -5;//10000000000000000000000000000101  11111111111111111111111111111010 补码11111111111111111111111111111011
    8. //     int c = a & b;
    9. //     // & --  对应二进制位，有0则为0，两个同时为1才是1
    10. //     //00000000000000000000000000000011
    11. //     //11111111111111111111111111111011
    12. //     //00000000000000000000000000000011  -补码
    13.  
    14. //     printf("%d\n",c); //3
    15.  
    16. //     return 0;
    17. // }
    18.  
    19.  
    20. //|
    21. // int main()
    22. // {
    23. //     int a = 3; //00000000000000000000000000000011
    24. //     int b = -5;//10000000000000000000000000000101  11111111111111111111111111111010 补码11111111111111111111111111111011
    25. //     int c = a | b;
    26. //     // ｜ --  对应二进制位，有1则为1，两个同时为0才是0
    27. //     //00000000000000000000000000000011
    28. //     //11111111111111111111111111111011
    29. //     //11111111111111111111111111111011  -补码
    30. //     //11111111111111111111111111111010
    31. //     //10000000000000000000000000000101 -5
    32. //     printf("%d\n",c); //-5
    33.  
    34. //     return 0;
    35. // }
    36.  
    37. //^
    38. int main()
    39. {
    40.     int a = 3; //00000000000000000000000000000011
    41.     int b = -5;//10000000000000000000000000000101  11111111111111111111111111111010 补码11111111111111111111111111111011
    42.     int c = a ^ b;
    43.     // ^ --  对应二进制位，相同为0，相异为1
    44.     //00000000000000000000000000000011
    45.     //11111111111111111111111111111011
    46.     //11111111111111111111111111111000  -补码
    47.     //11111111111111111111111111110111
    48.     //10000000000000000000000000001000
    49.     printf("%d\n",c); //-8
    50.  
    51.     return 0;
    52. }
    53.  
    54. //不能创建临时变量，实现两个整数的交换
    55. int main()
    56. {
    57.     int a = 3;
    58.     int b = 5;
    59.     printf("交换前: a=%d b=%d\n",a,b);
    60.     // int tmp = a;
    61.     // a = b;
    62.     // b = tmp;
    63.  
    64.     // a = a + b;
    65.     // b = a - b;
    66.     // a = a - b;   超过整形最大存储则不行
    67.  
    68.     //a ^ a -> 0
    69.     //a ^ 0 = a
    70.     // 异或是支持交换律的
    71.     //a ^ b ^ a = 5
    72.     //a ^ a ^ b = 5
    73.     a = a ^ b;
    74.     b = a ^ b; // b = a ^ b ^ b = a
    75.     a = a ^ b;// a = a ^ b ^ a = b
    76.     printf("交换后: a=%d b=%d\n",a,b);
    77.  
    78.  
    79.     return 0;
    80. }

    编写代码实现：求一个整数存储在内存中的二进制中1的个数

    1. //编写代码实现：求一个整数存储在内存中的二进制中1的个数
    2. //方法1
    3. // int main()
    4. // {
    5. //     //整数有32个bit位
    6. //     //获得32个bit位的每一位，
    7. //     //判断这一位是否为1
    8. //     //是1就是记数器+1
    9. //     int num = 10;
    10. //     int count = 0;
    11.  
    12. //     while (num)
    13. //     {
    14. //         if (num%2 == 1)
    15. //         {
    16. //             count++;
    17. //         }
    18. //         num = num/2;
    19.         
    20. //     }
    21. //     printf("二进制中1的个数 = %d\n",count);
    22.     
    23. //     return 0;
    24. // }
    25.  
    26. //方法2
    27. int main()
    28. {
    29.     int num = 10;
    30.     int i = 0;
    31.     int count = 0;
    32.     for(i=0;i<32;i++)
    33.     {
    34.         if (num & (1 << i))
    35.         {
    36.             count++;
    37.         }
    38.     }
    39.     printf("二进制中1的个数 = %d\n",count);
    40.     return 0;
    41. }

    赋值操作符: = +=  -=  *= /= ....

    1. //赋值操作符
    2.  
    3. int main()
    4. {
    5.     int weight = 120;//体重
    6.     weight = 89;  //不满意就赋值
    7.     double salary = 10000.0;
    8.     salary = 20000.0;
    9.  
    10.     int a = 10;
    11.     int x = 0;
    12.     int y = 20;
    13.     a = x = y+1;//连续复制
    14.  
    15.  
    16.     return 0;
    17. }

    单目操作符: ! sizeof + -  ~ & *

    1. //单目操作符
    2. // int main()
    3. // {
    4. //     int flag = 5;
    5. //     if(flag == 0)
    6. //     {
    7. //         printf("hehe\n");
    8. //     }
    9. //     if(!flag) //flag为假打印hehe
    10. //     {
    11. //         printf("hehe\n");
    12. //     }
    13. //     if(flag)
    14. //     {
    15. //         printf("haha\n");
    16. //     }
    17.  
    18. //     return 0;
    19. // }
    20.  
    21. //单目操作符只有一个操作数
    22. // int main()
    23. // {
    24. //     int a = 5;
    25. //     int b = -a;
    26. //     printf("%d\n",b);
    27.  
    28. //     return 0;
    29. // }
    30.  
    31. //& * 应用于指针
    32. // int main()
    33. // {
    34. //     int a = 10;
    35. //     //pa是指针变量
    36. //     int* pa = &a; // &-取地址操作符  取出a的地址
    37. //     *pa = 20;  //解引用操作符(间接访问操作符)-单目操作符-通过pa中存放的地址，找到指向的空间（内容）
    38. //     int c = *pa;
    39. //     printf("%d\n",c);
    40.  
    41. //     return 0;
    42. // }
    43.  
    44. //sizeof 不是函数，是操作符号
    45. //sizeof 计算的是类型创建变量的大小，单位是字节
    46. // int main()
    47. // {
    48. //     int a = 10;
    49. //     double b = 10.0;
    50. //     printf("%d\n",sizeof(int));//4
    51. //     printf("%d\n",sizeof(a));//4
    52. //     printf("%d\n",sizeof(b));//8
    53. //     return 0;
    54.  
    55. // }
    56.  
    57. // int main()
    58. // {
    59. //     int arr1[10];
    60. //     printf("%d\n",sizeof(arr1)); //40  计算整个数组的大小，单位字节
    61. //     printf("%d\n",sizeof(int [10])); //40
    62. //     int arr2[20];
    63. //     printf("%d\n",sizeof(arr2));//80
    64.     
    65. //     return 0;
    66. // }
    67.  
    68. // ~ 按位取反   按补码二进制位取反
    69. // int main()
    70. // {
    71. //     int a = 0;
    72. //     printf("%d\n", ~a);
    73. //     //00000000000000000000000000000000
    74. //     //11111111111111111111111111111111  -补码
    75. //     //11111111111111111111111111111110
    76. //     //10000000000000000000000000000001   -1
    77. //     return 0;
    78. // }
    79.  
    80. // int main()
    81. // {
    82. //     int a = 13;
    83. //     //00000000000000000000000000001101
    84. //     //00000000000000000000000000010000
    85. //     a |= (1<<4);
    86. //     //00000000000000000000000000011101
    87. //     //11111111111111111111111111101111
    88. //     //00000000000000000000000000001101
    89. //     printf("%d\n",a); //29
    90.  
    91. //     a &= (~(1 << 4));
    92. //     printf("%d\n",a);
    93. //     return 0;
    94. // }
    95.  
    96. // int main()
    97. // {
    98. //     int a = 0;
    99. //     //scanf  读取失败返回的是EOF
    100. //     //假设scanf读取失败了，返回了EOF ---> -1
    101. //     //while (scanf("%d",&a) != EOF)
    102. //     while(~scanf("%d",&a))  //~ -1为false
    103. //     {
    104. //         printf("%d\n",a);
    105. //     }
    106.  
    107. //     return 0;
    108. // }
    109.  
    110. // --前置、后置--
    111. //++前置 、后置++
    112. // int main()
    113. // {
    114. //     int a = 1;
    115. //     int b = a++;  //后置++，先使用，后++
    116. //     //int c = ++a; //先置++ ，先++在使用
    117. //     printf("b=%d a=%d\n",b,a);
    118.  
    119. //     int c = 1;
    120. //     int e = c--; //后置--，先使用，后--
    121. //     printf("e=%d c=%d\n",e,c);
    122.  
    123. //     return 0;
    124. // }
    125.  
    126. //强制类型转换
    127. int main()
    128. {
    129.     int a = (int)3.14;  //强制转换
    130.     printf("%d\n",a);
    131.     // int a = int(3.14) //err
    132.  
    133.     return 0;
    134. }
    135.  
    136.  
    137. void test1(int arr[])   //int*    4/8个字节
    138. {
    139.     printf("%d\n",sizeof(arr));
    140. }
    141. void test2(char  ch[])   //char*    4/8个字节
    142. {
    143.     printf("%d\n",sizeof(ch));
    144. }
    145. int main()
    146. {
    147.     int arr[10] = {0};
    148.     char ch[10] = {0};
    149.     printf("%d\n",sizeof(arr)); //40
    150.     printf("%d\n",sizeof(ch)); // 10
    151.     test1(arr); // x86上是4 ，x64上是8
    152.     test2(ch);  // x86上是4 ，x64上是8
    153.  
    154.  
    155.     return 0;
    156. }

    关系操作符: > < >= <= =.  !=.    关系操作符只能应用到适合的类型上

    1. int main()
    2. {
    3.     int a = 0;
    4.     int b = 0;
    5.     scanf("%d %d",&a ,&b);
    6.     if(a == 5 && b ==5)
    7.     {
    8.         printf("hehe\n");
    9.     }
    10.  
    11.     if(a == 5 || b ==5)
    12.     {
    13.         printf("haha\n");
    14.     }
    15.  
    16.     return 0;
    17. }
    18.  
    19. int main()
    20. {
    21.     int y = 0;
    22.     scanf("%d",&y);
    23.     //判断是否是闰年   1.能被4整除，并且不能被100整除
    24.     //2 .能被400整除是闰年
    25.     if(((y%4==0) && (y%100!=0)) || (y%400==0))
    26.     {
    27.         printf("y=%d是闰年\n",y);
    28.     }
    29.     else
    30.     {
    31.         printf("不是闰年");
    32.     }
    33.  
    34.     return 0;
    35. }

    逻辑操作符:&& 逻辑与 并且   || 逻辑或 或者

    1. int main()
    2. {
    3.     int i = 0, a = 0, b = 2, c = 3, d =4;
    4.     //i = a++ && ++b && d++;
    5.     //printf("a = %d\n b = %d\n c = %d\n d = %d\n",a,b,c,d);//1 2 3 4
    6.     i = a++ || ++b ||d++;
    7.     printf("a = %d\n b = %d\n c = %d\n d = %d\n",a,b,c,d);//1 3 3 4
    8.  
    9.     return 0;
    10. }

    条件操作符:? :

    1. //条件操作符也叫三目操作符   有三个操作数    exp1 ？ exp2 : exp3
    2. //双目操作符   a+b 
    3. //单目操作符 !a
    4.  
    5. // int main()
    6. // {
    7. //     int a = 0;
    8. //     int b = 0;
    9. //     // if (a > 5)
    10. //     // {
    11. //     //     b = 3;
    12. //     // } else
    13. //     // {
    14. //     //     b = -3;
    15. //     // }
    16.  
    17. //     //(a > 5) ? (b = 3) : (b = -3);
    18.  
    19. //     b = (a > 5) ? 3 : -3;
    20. //     printf("%d\n",b);
    21.  
    22. //     return 0;
    23. // }
    24.  
    25. int main()
    26. {
    27.     int a = 0;
    28.     int b = 0;
    29.     scanf("%d %d",&a,&b);
    30.     int m = (a > b) ? a : b;
    31.     printf("%d\n",m);
    32.  
    33.     return 0;
    34. }

    逗号表达式 :    ,

    1. //exp1,exp2,exp3,....expN
    2. //逗号表达式 ： 从左向右计算，整个表达式的结果是最后一个表达式的结果
    3. // int main()
    4. // {
    5. //     int a = 1;
    6. //     int b = 2;
    7. //     int c = (a>b, a = b+10 ,a,b=a+1); //13
    8. //     printf("%d\n",a); //12
    9. //     printf("%d\n",b); //13
    10. //     printf("%d\n",c); //13
    11. //     return 0;
    12. // }
    13.  
    14. // int main()
    15. // {
    16. //     // a = get_val();
    17. //     // count_val(a);
    18.  
    19. //     // while (a > 0)
    20. //     // {
    21. //     //     //业务处理
    22. //     //     a = get_val();
    23. //     //     count_val(a);
    24. //     // }
    25.  
    26. //     //使用逗号表达式
    27. //     while (a = get_val(),count_val(a), a>0)
    28. //     {
    29. //         //业务处理
    30. //     }
    31.     
    32.  
    33.  
    34. //     return 0;
    35. // }

    下标引用，函数调用和结构成员:  []. ().  .  ->  

    [] 下标引用操作符

    操作数：一个数组名+一个索引值

    1. //[] 下标引用操作符
    2. // int main()
    3. // {
    4. //     int arr[10] = {1,2,3,4};
    5. //     //数组的起始是有下标的，下标是从0开始的
    6. //     printf("%d\n",arr[2]); //arr 和 2是[]的两个操作数
    7.  
    8.  
    9. //     return 0;
    10. // }
    11.

    ()函数调用操作符

    接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数

    1. //     return 0;
    2. // }
    3.  
    4. int Add(int x,int y)
    5. {
    6.     return x + y;
    7. }
    8. //函数调用操作符
    9. int main()
    10. {
    11.     int len = strlen("abc"); //()函数调用操作符
    12.     //()的操作数是：strlen 函数名   "abc" 实参
    13.     printf("%d\n",len);
    14.  
    15.     int c = Add(3,5);
    16.     printf("%d\n",c);
    17.     //对于函数调用操作符来说，最少有1个操作数
    18.  
    19.     return 0;
    20. }

    访问一个结构的成员

    . 结构体，成员名

    -> 结构体指针 -> 成员名

    结构体 -复杂类型  -自定义类型

    1. //可变参数列表 -参数的个数是变化的 -探索
    2. struct Book
    3. {
    4.     char name[30];
    5.     char author[20];
    6.     float price;
    7. };
    8.  
    9. void Print(struct Book * p)
    10. {
    11.     //printf("%s %s %f\n",(*p).name,(*p).author,(*p).price);
    12.     printf("%s %s %f\n",p->name,p->author,p->price);
    13.     // ->   
    14.     //结构指针->成员名   p->name
    15. }
    16.  
    17. int main()
    18. {
    19.     struct Book b1 = {"C语言","ccc",66.8f};//书
    20.     struct Book b2 = {"Java入门","jjj",55.8f}; //书
    21.     Print(&b1);
    22.     //printf("%s %s %f\n",b1.name,b1.author,b1.price);
    23.     //printf("%s %s %.1f\n",b2.name,b2.author,b2.price);
    24.     //结构体变量，成员名
    25.  
    26.     return 0;
    27.     
    28. }

    表达式求值

    表达式求值的顺序一部分是由操作符的优先级和结核性决定。

    同样，有些表达式的操作数在求值的过程中困难需要转化为其他类型

    1. //表达式求值
    2. //1表达式在计算的过程中，有哪些类型转换？
    3. //2表达式的求值顺序是怎么样的
    4. //类型转换   1整型提升   2算术转换 
    5. //整形提升 C的整型算术运算总是至少一缺省整型类型的精度来进行的  为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升
    6.  
    7. int main()
    8. {
    9.     char c1 = 5;
    10.     //00000000000000000000000000000101
    11.     //00000101 - c1
    12.     char c2 = 127;
    13.     //00000000000000000000000001111111
    14.     char c3 = c1 + c2;  // -124
    15.     //00000000000000000000000000000101
    16.     //00000000000000000000000001111111
    17.     //00000000000000000000000010000100
    18.  
    19.     //%d - 10进制的形式打印有符号的整数
    20.     //11111111111111111111111110000100
    21.     //10000000000000000000000001111100    -124
    22.     printf("%d\n",c3);
    23.  
    24.     return 0;
    25. }

    1. // %u 打印10进制的形式无符号的整数
    2. // int main()
    3. // {
    4. //     char c = 1;
    5. //     printf("%u\n",sizeof(c)); //1
    6. //     printf("%u\n",sizeof(+c)); //1
    7. //     printf("%u\n",sizeof(-c)); //1
    8.  
    9.  
    10. //     return 0;
    11. // }
    12.  
    13. // int main()
    14. // {
    15. //     float f = 3.14;
    16. //     int a = 10;
    17.     
    18. //     char b = a + f; // 13
    19. //     int c = a + f; // 13
    20.  
    21. //     printf("%d\n",b);
    22. //     printf("%d\n",c);
    23.  
    24.  
    25. //     return 0;
    26. // }
    27.  
    28. //相邻操作符优先级高的先算，低低后算
    29. //相邻操作符的优先级相同的情况下，结合性起作业
    30. // int main()
    31. // {
    32. //     int a = 2 + 3 * 5;
    33.  
    34. //     return 0;
    35. // }
    36.  
    37. // int main()
    38. // {
    39. //     int i = 10;
    40. //     i = i-- - --i * (i = -3) * i++ + ++i;
    41. //     printf("i = %d\n", i);
    42.  
    43. //     return 0;
    44. // }
    45.  
    46. int fun()
    47. {
    48.     static int count = 1;
    49.     return ++count;
    50. }
    51.  
    52. int main()
    53. {
    54.     int answer;
    55.     answer = fun() - fun() * fun(); //  2 - 3*4    -10
    56.     printf("%d\n",answer); //输出多少
    57.  
    58.     return 0;
    59.  
    60. }

  • 相关阅读:
    element plus Message方法手动关闭，close方法使用
    无良软件测试培训机构，退退退
    Java使用lowagie根据模版动态生成PDF（无需额外设置系统字体）
    Vulnhub_Noob
    赴日IT培训 日本IT行业为啥吃香？
    SpaceX间接「颠覆」了手机？星链如何直连手机通信？
    异常排查 | 重复Cookie访问导致HTTP请求引发空指针异常
    Java开源工具库使用之Lombok
    7-4 USB接口的定义 (10分）
    [题]宝物筛选 #单调队列优化
  • 原文地址：https://blog.csdn.net/qq_61658398/article/details/132829799