【C语言】操作符

欢迎来到Cefler的博客😁
🕌博客主页：那个传说中的man的主页
🏠个人专栏：题目解析
🌎推荐文章：题目大解析(更新ing)

👉🏻算术操作符

算术操作符一般有+ - * / %

加减乘的用法比较简单，但是/和%使用的时候需要注意几点：
1.我们知道，整数/整数==整数，但是若一个整数/浮点数或浮点数/整数，只要有一个浮点数参加计算，此时的运行的计算就是小数除法，也就是此时得到的结果会是小数，若下图👇🏻

2.取模的时候（%），操作数必须为整数

👉🏻移位操作符

1.<<:左移操作符
2.>>:右移操作符
移位操作符移动的是二进制的位，所以在开始讲解移位操作符前，先普及一下二进制的一些知识

整数的二进制表示形式：原码，反码，补码

• 原码：把一个数按照正负直接翻译成二进制就是原码，比如10的二进制表示就是1010，但是在内存当中，一个整数所占大小是4个字节，也就是32个比特位，我们在内存当中要用32个比特位来表达，也就是00000000000000000000000000001010，这个就是10的原码
• 反码：正数的反码是其本身，负数原码的符号位不变，其他位按位取反就是反码,如10的原码取反得到的反码就是 01111111111111111111111111110101(正负由首位符号决定，1为负，0为整数)
• 补码：正数的反码是其本身，负数反码-1，10的反码-1得到的就是01111111111111111111111111110100
  而整数在内存中的存储形式是——反码

1.<<:左移操作符：将原码向向左移动，左移右补0，就比如10的原码左移1位

而这个时候，值发生了什么变化了呢？00000000000000000000000000010100转化为10进制的结果是20，所以此时的结果变为了20

2.>>:右移操作符
右移操作符有两种：

• 逻辑移位：右移，左边的用0来填充
• 算术移位：右移，左边的用原来的符号位填充
  至于实现的是哪种移位得取决于编译器，VS2019使用的是算术移位，且大部分编译器一般都是算术移位

👉🏻单目操作符

1.! : 逻辑反操作
2. - : 负值
3.+ : 正值
4.& : 取地址
5.sizeof : 操作数的类型长度（以字节为单位）
6.~ : 对一个数的二进制按位取反
7.-- : 前置、后置–
8.++ : 前置、后置++
9.* : 间接访问操作符(解引用操作符)
10.(类型) : 强制类型转换

👉🏻关系操作符

1.>
2.>=
3.<
4.<=
5.!= 用于测试“不相等”
6.== 用于测试“相等”

👉🏻逻辑操作符

1.&& 逻辑与
2.|| 逻辑或

#include <stdio.h>
int main()
{
    int i = 0,a=0,b=2,c =3,d=4;
    i = a++ && ++b && d++;
    //i = a++||++b||d++;
    printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
    return 0;
}
//程序输出的结果是什么？

因为a++是后置++,所以i先被赋值了a=0,因为0是假的，因此整个语句都是假的，所以&&后面的表达式就不会再去计算，所以最后输出的结果是1 2 3 4

👉🏻条件操作符

exp1?exp2:exp3

若表达式1为真，则输出表达式2，若为假，则输出表达式3

👉🏻逗号表达式

exp1,exp2,exp3……
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。

👉🏻下标引用、函数调用和结构成员

下标引用

[]为下标引用操作符
数组名和索引值为操作数

函数调用

()函数调用操作符
操作数为函数名和参数

结构成员

• . :结构体.结构成员
  结构体(struct)初始化是用{}
  
• ->: 结构体指针->成员名
  

👉🏻位操作符

& ： 按位与 ， 全1则1，一0则0
| ： 按位或 ， 一1则1，全0为0
^ ： 按位异或 ， 相同为0，相异为1
这是什么意思呢？这是怎么用的呢？
比如，随便取2个整数10和1，对它们进行按位与，10&1的过程就是将10的补码与1的补码互相对应的比特位进行对比，如果都为1，则输出的结果为1，若二者只有一个1，则输出的结果就是0

由图可以看到10&1最后的二进制位为00000000000000000000000000000000，所以十进制值为0

同理|，^的用法也如是

^ ： 按位异或操作符具体实例运用

题目，要求不创建第三变量，实现两个变量之间的互换
^ ： 按位异或操作符求解👇🏻

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

	return 0;
}

这是什么原理呢？我们可以通过两个结论来理解

a^a=0
a^0=a

这样我们我就可以理解上述代码了，b=a^b= a ^b ^b=a ^0=a,这样a的值就成功转到了b中，下面以此类推

👉🏻表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。

隐式类型转换（整型提升）

C的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。
整型提升的意义:

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。
通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。

总而言之，像类型为short和char的变量进行计算时，要进行整型提升。
那么如何进行整型提升呢？有两种👇🏻👇🏻

• 正数整型提升

比如提升char int=3,它的有效比特位只有8位，00000011，现在要将其提升为整型，就要对其高位补位，用原本的符号位补位，因为3为正数，符号位为0，所以用0来补位，最终的补位结果就是00000000000000000000000000000011。

• 负数整型提升

与正数提升一样，也是用原来的符号位补位，负数的符号位为1，如-1补位前的有效8比特位为11111111，补位后为11111111111111111111111111111111。

如上图，就可以感受到整型提升的存在，因为+c和-c是表达式，c是char型，所以这个过程+c和-c是经过整型提升的，原来char型只有1个字节的空间，因为整型提升后变为了4个字节。

算术转换

1.long double
2.double
3.float
4.unsigned long int
5.long int
6.unsigned int
7.int
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。

就比如int型和float型的变量进行计算，最终结果会转换为float型，因为float的排名比int型高

👉🏻操作符的属性

复杂表达式的求值有三个影响的因素。

1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。

👉🏻练习题

统计二进制中1的个数

//法一：右移动遍历法
int count_one(int n)
{
	int i = 0;
	int count = 0;
	for (i = 0; i < 32; i++)
	{
		if (((n >> i) & 1) == 1)
		{
			count++;
		}
	}
	return count;
}
//法二：%2法
int count_two(unsigned int n)//类型改为unsigned是为了使计算机认为负数的补码就是原码
{
	int count = 0;
	while(n)
	{
		if (n % 2 == 1)
		{
			count++;
		}
		n /= 2;
	}

	return count;
}
//法三：结论法
//结论：n=n&(n-1)，每运行一次，原码中最右边的1都会消失
//所以我们计算在n=0之前运行了几次，则就有几个1
int count_three(int n)
{
	int count = 0;
	while (n)
	{
		n = n & (n - 1);
		count++;
	}
	return count;
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	int res = count_three(n);
	printf("%d\n", res);
	return 0;
}

打印整数二进制的奇数位和偶数位

//获取一个整数二进制序列中所有的偶数位和奇数位，分别打印出二进制序列

//法一：右移动到第一位打印法
void print_one(int n)
{
	//奇数位
	int i = 0;
	for (i = 0; i < 32; i += 2)
	{
		int res = (n >> i) & 1;
		printf("%d ", res);
	}
	printf("\n");
	//偶数位
	for (i = 1; i <= 32; i += 2)
	{
		int res = (n >> i) & 1;
		printf("%d ", res);
	}

}
int main()
{
	int n = 0;
	scanf("%d", &n);
	print_one(n);
	return 0;
}

求两个数二进制中不同位的个数

int compare_one(int n, int m)
{
	int i = 0;
	int count = 0;
	for (i = 0; i < 32; i++)
	{
		if(((n >> i) & 1)!=((m >> i) & 1))
			count++;
	}
	return count;
}
//^符号，相同为0，相异为1，将n与m^,再计数n^m后的1的个数，就是不同位的个数
int compare_two(int n, int m)
{
	int f = n ^ m;
	int count = 0;
	while (f)
	{
		f = f & (f - 1);
		count++;
	}
	return count;
}
int main()
{
	int n, m;
	scanf("%d %d", &n, &m);
	int res = compare_two(n, m);
	printf("%d\n", res);
	return 0;
}

判断是否是2的幂次方

//{
//	while (1)
//	{
//		int n = 0;
//		int flag = 1;
//		scanf("%d", &n);
//		while (n!=1)
//		{
//			if (n % 2 != 0)
//			{
//				flag = 0;
//				break;
//			}
//			n /= 2;
//		}
//		if (flag == 1)
//			printf("是\n");
//		else
//			printf("不是\n");
//	}
//	
//}

//法二
int judge(float n)
{
	int count1 = 0, count2 = 0;
	int res1 = n, res2 = n;
	while (res1)
	{
		res1 = res1 & (res1 - 1);
		count1++;
	}
	
	if (count1 == 1)
		return 1;
	else
		return 0;
}
int main()
{
	float n = 0;
	scanf("%f", &n);
	if (judge(n))
		printf("是\n");
	else
		printf("不是\n");

}