当前位置：网站首页>详解操作符

int main()
{
	int a = 10;    //00000000000000000000000000001010
	int b = a << 1;//00000000000000000000000000010100
	printf("a=%d,b=%d",a, b);
	return 0;
}

这是我们的移位结果，其作用相当于将a乘以2。

值得我们注意的是虽然我们对a进行了移位操作但是a本身没有变我们可以看到a的值还是10。

>> 右移操作符

移位规则：

首先右移运算分两种：

1. 逻辑移位：左边用0填充，右边丢弃。

2. 算术移位：左边用原该值的符号位填充，右边丢弃。

具体是左移还是右移要看具体的机器，在我们的VS2022中是用的算数右移。

int main()
{
	int a = -10;   //1111 1111 1111 1111 1111 1111 1111 0110
	int b = a >> 1;//1111 1111 1111 1111 1111 1111 1111 1011
	printf("a=%d,b=%d", a, b);
	return 0;
}

这里我们可以看到右移操作相当于除2的功能（当是负数是会在除2的基础上-1）。

注意：对于移位运算符，不要移动负数位，这个是标准未定义的。

位操作符

& //按位与
| //按位或
^ //按位异或
注：他们的操作数必须是整数。

& 按位与

运算规则：按位于的运算法则就是在两个数的二进制表示中如果有一个是0那么其结果就是0，只有两个对应位全是1，其结果才是1。

| 按位或

运算规则：按位于的运算法则就是在两个数的二进制表示中如果有一个是1那么其结果就是1，只有两个对应位全是0，其结果才是0。

^ 按位异或

运算规则：按位于的运算法则就是在两个数的二进制表示中如果两个对应位相同则为0，对应位不同则为1。

int main()
{
	int a = 1;//00000000000000000000000000000001
	int b = 2;//00000000000000000000000000000010
	int c = 0;
	printf("%d\n", a & b); //00000000000000000000000000000000
	printf("%d\n", a | b); //00000000000000000000000000000011
	printf("%d\n", a ^ b); //00000000000000000000000000000011
	return 0;
}

位移操作符以及位操作符的实战运用

不能创建临时变量（第三个变量），实现两个数的交换

int main()
{
	int a = 10;//00001010
	int b = 20;//00010100
	printf("交换前：a=%d,b=%d\n", a, b);
	a = a ^ b;// 00011110
	b = a ^ b;// 00001010
	a = a ^ b;// 00010100
	printf("交换后：a=%d,b=%d\n", a, b);
	return 0;
}

统计二进制中1的个数

int main()
{
	int a = 0;
	int count = 0;
	int flag = 1;
	printf("请输入：");
	scanf("%d", &a);
	while (flag<=32)
	{
		if (((a >> flag) & 1) == 1)
			count++;
		flag++;
	}
	printf("%d的二进制形式中1的个数为%d", a, count);
	return 0;
}

两个int（32位）整数m和n的二进制表达中，有多少个位(bit)不同

int main()
{
	int a = 0;
	int b = 0;
	int count = 0;
	int flag = 1;
	printf("请输入：");
	scanf("%d %d", &a, &b);
	while (flag <= 32)
	{
		if (((a >> flag) & 1) != ((b >> flag) & 1))
			count++;
		flag++;
	}
	printf("共%d个bit位不同", count);
	return 0;
}

赋值操作符

赋值操作符是一个很棒的操作符，他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值。

int main()
{
    int weight = 120;//体重
    weight = 89;//不满意就赋值
    double salary = 10000.0;
    salary = 20000.0;
    //赋值操作符可以连续使用，比如：
    int a = 10;
    int x = 0;
    int y = 20; a = x = y+1;//连续赋值
    //这样的代码感觉怎么样？
    //那同样的语义，你看看：
    x = y+1; a = x;
    //这样的写法是不是更加清晰爽朗而且易于调试。

    return 0;
}

复合赋值符

>>=

<<=

这些运算符都可以写成复合的效果

int x = 10;
x = x+10;
x += 10;//复合赋值
//其他运算符一样的道理。这样写更加简洁。

单目操作符

! 逻辑反操作

- 负值

+ 正值

& 取地址

sizeof 操作数的类型长度（以字节为单位）

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

-- 前置、后置--

++ 前置、后置++

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

(类型) 强制类型转换

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(int));
	printf("%d\n", sizeof a);//这样写行不行？
	//printf("%d\n", sizeof int);//这样写行不行？
	return 0;
}

这里我们可以看到当sizeof后面是类型的时候则必须加上括号。

在这里我们讲一下按位取反的运用~

有两个问题一个是把一个数字的二进制的n位置为1和把一个数字的二进制的n位置为0

int main()
{
	int a = 10;
	int n = 0;
	scanf("%d", &n);
	//把a的第n位置为1
	a = a | (1 << (n-1));
	printf("a=%d\n", a);

	//把a的第n位置为0
	a = a & ~(1 << (n - 1));
	printf("a=%d\n", a);

	//00000000000000000000000000001010
	//00000000000000000000000000010000
	//1<<2;
	//00000000000000000000000000011010
	//11111111111111111111111111101111
	//00000000000000000000000000010000
	//00000000000000000000000000001010
	return 0;
}

这里我们刚好结合着按位与和按位或解决了这个问题。

下面给大家简单介绍一个易错点

int main()
{
	short s = 10;
	int a = 2;
	s = a + 5;

	printf("%zu\n", sizeof(s = a + 5));

	printf("%d\n", s);
	return 0;
}

上面程序的结果是什么呢？（%zu是输出的无符号整型）

我们可以看到是2 7，s是short所以占两个字节但是s不是+5了吗为什么不是12呢？

因为sizeof()括号里面的表达式我们是不计算的。

关系操作符

!= 用于测试“不相等”

== 用于测试“相等”

逻辑操作符

&& 逻辑与

|| 逻辑或

#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变了，其他的为啥没有变化呢，这里是因为当我们a=0通过&&的判断后面无论是真还是假，这个整体的结果都是假，所以后面的自增操作没有进行。

条件操作符

exp1 ? exp2 : exp3

如果问号前的表达式的值为真，那么整个表达式的结果就是exp2,否则就是exp3。

逗号表达式

exp1, exp2, exp3, …

逗号表达式，就是用逗号隔开的多个表达式。

逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。

//代码3 a = get_val();
count_val(a);
while (a > 0) 
{
    a = get_val();
    count_val(a);
}

这里我们会觉得代码有些冗余

while (a = get_val(), count_val(a), a>0) {
         //业务处理
}

改成这样大家会发现代码明显就精简了一些。

隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。

为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

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

//实例1
char a,b,c;
...
a = b + c;

b和c的值被提升为普通整型，然后再执行加法运算。

加法运算完成之后，结果将被截断，然后再存储于a中。

如何进行整体提升呢？

整形提升是按照变量的数据类型的符号位来提升的

//负数的整形提升
char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111
//正数的整形提升
char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001
//无符号整形提升，高位补0

int main()
{
 char a = 0xb6;
 short b = 0xb600;
 int c = 0xb6000000;
 if(a==0xb6)
 printf("a");
 if(b==0xb600)
 printf("b");
 if(c==0xb6000000)
 printf("c");
 return 0; }

这里的char和short都是小于4个字节所以要进行整型提升，所以就不相等。

int main()
{
	char c = 1;
	printf("%u\n", sizeof(c));
	printf("%u\n", sizeof(+c));
	printf("%u\n", sizeof(-c));
	return 0;
}

这里的c在+-操作符之后也会整型提升，所以都是4个字节。

算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。

long double
double
float
unsigned long int
long int
unsigned int
int

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。

警告：

但是算术转换要合理，要不然会有一些潜在的问题，如精度会丢失。

操作符的属性

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

1. 操作符的优先级

2. 操作符的结合性

3. 是否控制求值顺序。

两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。

操作符优先级

问题表达式

int fun()
{
	static int count = 1;
	return ++count;
}
int main()
{
	int answer;
	answer = fun() - fun() * fun();
	printf("%d\n", answer);//输出多少？
	return 0;
}

虽然我们知道执行的顺序先*后-但是我们不知道到底哪个fun先准备的，所以这是一个问题的表达式，在不同的编译器下结果是不一样的。

int main()
{
 int i = 1;
 int ret = (++i) + (++i) + (++i);
 printf("%d\n", ret);
 printf("%d\n", i);
 return 0; }

这段代码中的第一个 + 在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级和结合性是无法决定第一个 + 和第三个前置 ++ 的先后顺序。

总结：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。

原网站

版权声明
本文为[~小明学编程]所创，转载请带上原文链接，感谢
https://blog.csdn.net/m0_56911284/article/details/126061459