C语言操作符详解(上)-阿里云开发者社区

前言

一、算术操作符 + - * / %(运算符)

除法注意点:/ 除法得到的是商

1.除法操作符的两个操作数都是整数的话,执行的是整数除法.用%d打印

2.除法操作符的两个操作数只要有一个浮点点数,执行的是小数除法.用%lf打印

% 取模(取余) 得到的是余数:

1.取模操作符的两个操作数必须是整数,返回的是整除之后的余数.

2.除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main() {
  //printf("%lf\n", 10 / 3);   //不能这么写,因为两个操作数都是整数,应该用%d
  printf("%lf\n", 10 / 3.0);
  printf("%d\n", 10 / 3);
}

二、移位操作符(操作数只能是整数)

移位操作符移动的是二进制的位

左移操作符: 左边丢弃,右边补0

数值的表示形式:

2进制,8进制,10进制,16进制

10进制的数据中,都是0-9的数字组成的

2进制的数据中,0-1的数字组成的

8进制的数据中,0-7的数字组成的

16进制的每一位是:

0~15

0 1 2 3 4 5 6 7 8 9 a b c d e f

比如:

表示数值10

1010----2进制

12-------8进制

10-------10进制

a---------16进制

数据的二进制表示:

整数的二进制表示形式有三种: 原码反,码,补码

原码:

把一个数按照正负直接翻译成二进制就是原码

最高位表示符号位,0表示正数,1表示负数

正整数的原码反码补码相同,

负整数的原码反码补码是要计算的

反码:

原码的符号位不变,其他位按位取反就是反码

补码:

反码+1

举例说明:

5,-5是整数,整数是存放在整型变量中的

一个整型变量是4个字节~32比特位

原码 00000000000000000000000000000101

反码 00000000000000000000000000000101

补码 00000000000000000000000000000101

-5:

原码10000000000000000000000000000101

反码 11111111 11111111 11111111 11111010

补码 11111111 11111111 11111111 11111011

整数在内存中存储的是:二进制补码

4个比特位可以作为一个16进制数

例如:-5

补码 11111111 11111111 11111111 11111011

4个一组表示成16进制:

FF FF FF FB

正整数左移操作符举例说明:

3的二进制位:

00000000 00000000 00000000 00000011

向左移动一位,左边丢弃,右边补0

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main() {
  int a = 3;
  //3的二进制位:(正数的原码反码补码相同)
  //00000000 00000000 00000000 00000011
  int b=a << 1;
  //向左移动一位,左边丢弃,右边补0
  //b是正数,原码反码补码相同
  //00000000 00000000 00000000 00000110  
  //b也就是6
  printf("%d\n", b);
  printf("%d\n", a);
  return 0;
}

负整数左移操作符举例说明:

原码------>补码:取反+1

补码------>原码:-1,取反或者取反+1

-3的二进制位左移一位:

由于整数在内存中存储的是补码,左移的时候实际上是将补码左移一位,右边补0.

首先求出-3的补码,左移补0之后得到的是结果的补码,还需要转换成原码,最后通过原码得出结果是多少

int main() {
  int a =-3;
  /*-3的二进制位:
  10000000 00000000 00000000 00000011   -3的原码
  11111111 11111111 11111111 11111100   -3的反码
  11111111 11111111 11111111 11111101   -3的补码*/
  // 
  int b=a << 1;
  //-3的补码向左移动一位,左边丢弃,右边补0得到结果的补码
  //11111111 11111111 11111111 11111010   b的补码      
  //11111111 11111111 11111111 11111001   b的反码
  //10000000 00000000 00000000 00000110   b的原码 -6
  printf("%d\n", b);
  printf("%d\n", a);
  return 0;
}

右移操作符:

1.>> 算术右移:

右边丢弃,左边用原来的符号来填充

2.>> 逻辑右移:

右边丢弃,左边直接用0来填充

右移的时候,到底采用的是算术右移还是逻辑右移,是取决于编译器的!!

由下面的代码可以看出,vs2019编译器采用的是算术右移.

int main() {
  int a = -5;
  int b = a >> 1;
  //10000000 00000000 00000000 00000101
  //11111111 11111111 11111111 11111010
  //11111111 11111111 11111111 11111011
  printf("b=%d\n", b);
  //算术右移
  //11111111 11111111 11111111 11111101
  //10000000 00000000 00000000 00000010
  //10000000 00000000 00000000 00000011     -3
  printf("a=%d\n", a);
  return 0;
}

三、位操作符(操作数必须是整数)

位:指的是二进制位

int main() {
  int a = 3;
  int b = -5;
  int c = a & b;
  //00000000 00000000 00000000 00000011  3的补码
  //10000000 00000000 00000000 00000101  -5的原码
  //11111111 11111111 11111111 11111010  -5的反码
  //11111111 11111111 11111111 11111011  -5的补码
  //00000000 00000000 00000000 00000011  3的补码
  //11111111 11111111 11111111 11111011  -5的补码
  //00000000 00000000 00000000 00000011   a&b的补码,由于是正整数,原码也是这个
  printf("%d\n", c);  //3
  int d = a | b;  //按位或
  //00000000 00000000 00000000 00000011  3的补码
  //11111111 11111111 11111111 11111011  -5的补码
  //11111111 11111111 11111111 11111011  a|b的补码,可以发现与-5的补码一样,所以他的原码数值等于-5
  printf("%d\n", d);
  int e = a ^ b;  //按位异或--对应的二进制位相同为0,相异为1
  //00000000 00000000 00000000 00000011  3的补码
  //11111111 11111111 11111111 11111011  -5的补码
  //11111111 11111111 11111111 11111000  a^b的补码
  //11111111 11111111 11111111 11110111  补码-1
  //00000000 00000000 00000000 00001000  取反得到原码,结果为-8
  printf("%d\n", e);
}

交换a和b的值:

方法一:创建临时变量

int main() {
  int a = 3;
  int b = 5;
  printf("交换前:a=%d b=%d\n", a, b);
  int tmp = 0;
  tmp = 0;
  tmp = a;
  a = b;
  b = tmp;
  printf("交换后:a=%d b=%d\n", a, b);
}

方法二:不创建临时变量

存在潜在风险,当数字过大时,加和之后可能超出整数的最大范围,有一定局限性

int main() {
  int a = 3;
  int b = 5;
  printf("交换前:a=%d b=%d\n", a, b);
  a = a + b;
  b = a - b;
  a = a - b;
  printf("交换后:a=%d b=%d\n", a, b);
  return 0;
}

方法三:使用异或操作符,不创建临时变量

注意两个公式:
a^a=0
0^a=a

3^ 3^5=5

011 3

000 3^3

101 5

101 3^ 3^5结果5

3⁵3=5

异或支持交换律的

异或只能用于整数操作

异或只会产生0和1,不会进位出现2,所以永远不会溢出

int main() {
  int a = 3;
  int b = 5;
  printf("交换前:a=%d b=%d\n", a, b);
  a = a ^ b;  
  b = a ^ b;      //b=a^b^b=a^0=a
  a = a ^ b;      //a=a^a^b=0^b=b   
  printf("交换后:a=%d b=%d\n", a, b);
}

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

思路点拨:

int main() {
  int a = 11;
  a & 1;
  //一个整数存储在内存中的二进制中1的个数
  //只要每次右移,每次和1按位与得到最后一位看一下是不是1
  a = a >> 1;
  //00000000 00000000 00000000 00001011
  //00000000 00000000 00000000 00000001
  //发现:最低位和1按位与,还是原来的数字
  //如果想要得到这个数的最低位是几,只要和1按位与就可以了
  //结果
  //00000000 00000000 00000000 00000001
}

四、赋值操作符

=

复合操作符

int main() {
  int a = 3;
  a = a + 3;
  a += 3;
  a = a ^ 5;
  a ^= 5;
  a = a >> 3;
  a >>= 3;
}

区分赋值和初始化:

int main() {
  int a = 3;//创建并初始化
  a = 5;//赋值
  return 0;
}

六、单目操作符

!的应用场景:

int main() {
  int flag = 5;
  if (flag) {  //flag为真做什么
  }
  if (!flag) {   //flag为假做什么
  }
  return 0;
}

&取地址操作符

int main() {
  int a = 10;
  &a;//&取地址操作符
  int arr[10];
  &arr;//取出数组的地址
}

解引用操作符(间接访问操作符)

int main() {
  int a = 10;
  int* p=&a;  //取地址操作符  p里面存的是a的地址
  *p = 20;   //解引用操作符(间接访问操作符)
  int arr[10];
  &arr;   //取出数组的地址
  return 0;
}

sizeof

int main() {
  int a = 10;
  printf("%d\n", sizeof(a));
  printf("%d\n", sizeof a);   //变量求长度时的小括号可以不写,但是int必须写
  printf("%d\n", sizeof(int));
  int arr[10] = { 0 };
  printf("%d\n", sizeof(arr));     //数组的长度
  printf("%d\n", sizeof(arr[0]));   //数组元素的长度
  int sz = sizeof(arr) / sizeof(arr[0]);    //数组元素的个数
  printf("%d\n", sz);
  return 0;
}

~的用法

对一个数的二进制位按位取反

int main() {
  int a = 0;
  //00000000 00000000 00000000 00000000
  //~a:按位取反
  //11111111 11111111 11111111 11111111 补码(内存里面的字都是补码)
  //11111111 11111111 11111111 11111110 反码
  //00000000 00000000 00000000 00000001  原码  -1
  printf("%d\n", ~a);   //-1
}

下面举例灵活应用单目操作符:

int main() {
  int b = 3;
  //00000000 00000000 00000000 00000011     b
  //如何把上面的数字倒数第四位变成1?
  //00000000 00000000 00000000 00000011      b
  //用b|
  //00000000 00000000 00000000 00001000     (1 << 3)
  b |= (1 << 3);
  //00000000 00000000 00000000 00001011     b=11
  printf("%d\n", b);  //11
  //如何将下面的数字
  //00000000 00000000 00000000 00001011
  //倒数第四位还原成0??
  //
  // 0&1=0 1&1=1
  // 所以将原数字与下面的数字按位与,就可以将倒数第四位还原成0
  //11111111 11111111 11111111 11110111  这个数字怎么表示呢?
  //我们发现它刚好是00000000 00000000 00000000 00001000     (1 << 3)取反可以得到
  //
  b &= (~(1 << 3));
  printf("%d\n", b);  //3
  return 0;
}

小知识点:

scanf读取失败的时候返回-1

原码

10000000 00000000 00000000 00000001

反码

11111111 11111111 11111111 11111110

补码

11111111 11111111 11111111 11111111

~按位取反之后:全0

00000000 00000000 00000000 00000000

此时就变成:

while(0)不进入循环,scanf读取失败

前置++ --:在使用之前++ - -
后置++ --:在使用之后++ - -

int main() {
  int a = 10;
  int b = a++;
  printf("%d\n", a);    
  printf("%d\n", b);  //后置++,先使用,再++
  //相当于int b=a;a=a+1;
}

后置++

int main() {
  int a = 10;
  printf("%d\n", a++);//先使用,后++
  printf("%d\n", a);
}

前置++

int main() {
  int a = 10;
  printf("%d\n", ++a);  //先++,再使用
  printf("%d\n", a);
}

前置- -和后置- -同上面一个道理

(类型) 强制类型转换

仅仅是临时改变数据类型的一个状态

int main() {
  float a = 3.14f;
  int b = (int)a;  //强制性类型转换
  return 0;
}

sizeof()和数组

1.sizeof()内部单独放一个数组名,表示整个数组,所以(1)(3)处的值为40,10

2.注意:数组在传参的时候,实际上是传过去首元素的地址

void test1(int arr[])  //整形的地址放到整形的指针里面,int本质是int*,存放地址,指针变量的大小都是四个字节或者八个字节
{
  printf("%d\n", sizeof(arr));//(2)X86环境下指针的大小是4,X64环境下指针的大小是8
}
void test2(char ch[])   //char本质是char*,存放地址
{
  printf("%d\n", sizeof(ch));//(4)X86环境下指针的大小是4,X64环境下指针的大小是8
}
int main()
{
  int arr[10] = { 0 };
  char ch[10] = { 0 };
  printf("%d\n", sizeof(arr));//(1)  计算的是整个数组的大小:40
  printf("%d\n", sizeof(ch));//(3)   计算char类型的数组大小:10
  test1(arr);
  test2(ch);
  return 0;
}

七、关系操作符

在编程中注意==和=不要使用错误

八、逻辑操作符

&& 逻辑与并且的意思只关注真假
| | 逻辑或或者的意思只关注真假

& 按位与二进制位进行计算

| 按位或二进制位进行计算

int main() {
  int a = 3 && 5;
  int b = 3 && 0;
  printf("%d\n", a);
  printf("%d\n", b);
  int c = 1 || 0;
  int d = 0 || 0;
  printf("%d\n", c);
  printf("%d\n", d);
  return 0;
}

&& 操作符左边为假,右边不再计算
| | 操作符左边为真,右边不再计算

举例说明:

int main() {
  int i = 0, a = 0, b = 2, c = 3, d = 4;
  i = a++ && ++b && d++;  //0&&...a=0,后面不用计算
  printf("a=%d\nb=%d\nc=%d\nd=%d\n", a, b, c, d);
  return 0;
}

int main() {
  int i = 0, a = 1, b = 2, c = 3, d = 4;
  i = a++ && ++b && d++;  //1&&3&&4
  printf("a=%d\nb=%d\nc=%d\nd=%d\n", a, b, c, d);//2 3 3 5
  return 0;
}

int main() {
  int i = 0, a = 1, b = 2, c = 3, d = 4;
  i = a++ || ++b || d++;  //1||...或运算,左边有一个1,右边不用计算
  printf("a=%d\nb=%d\nc=%d\nd=%d\n", a, b, c, d);//2 2 3 4
  return 0;
}

int main() {
  int i = 0, a = 0, b = 2, c = 3, d = 4;
  i = a++ || ++b || d++;   //0||2...右边不用计算
  printf("a=%d\nb=%d\nc=%d\nd=%d\n", a, b, c, d);//1 3 3 4
  return 0;
}

这篇文章的内容你是否有所收获呢?小伙伴们,记得点赞收藏博客,关注后续的C语言操作符(下)内容哦~😉😉💕

C语言操作符详解(上)

前言

一、算术操作符 + - * / %(运算符)

二、移位操作符(操作数只能是整数)

三、位操作符(操作数必须是整数)

四、赋值操作符

=

复合操作符

六、单目操作符

七、关系操作符

八、逻辑操作符

热门文章

最新文章

相关课程

相关电子书

相关实验场景