当前位置：网站首页>Detailed operator

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

Here is our shift result,Its role is equivalent to willa乘以2.

It is worth noting that although we are rightaA shift operation is performed howeveraThere is no change in itself as we can seea的值还是10.

>> 右移操作符

移位规则：

首先右移运算分两种：

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

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

Whether to move left or right depends on the specific machine,在我们的VS2022is used for arithmetic right shift.

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;
}

Here we can see that the right shift operation is equivalent to division2的功能（When it is negative, it will divide2的基础上-1）.

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

位操作符

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

& 按位与

运算规则：The algorithm by location is if one of the binary representations of two numbers is0那么其结果就是0,Only two corresponding bits are all1,其结果才是1.

| 按位或

运算规则：The algorithm by location is if one of the binary representations of two numbers is1那么其结果就是1,Only two corresponding bits are all0,其结果才是0.

^ 按位异或

运算规则：The algorithm by location is that in the binary representation of two numbers, if the two corresponding bits are the same0,对应位不同则为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;
}

Practical use of displacement operators and bitwise operators

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

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;
}

这里我们可以看到当sizeofWhen followed by a type, parentheses must be added.

Here we talk about the use of bitwise negation~

There are two problems one is putting a number in binaryn位置为1and put a number in binaryn位置为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;
}

Here we just combine bitwise AND and bitwise OR to solve the problem.

The following is a brief introduction to an error-prone point

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

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

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

What is the result of the above program？（%zuis the unsigned integer of the output）

我们可以看到是2 7,s是shortSo it takes two bytes buts不是+5why not12呢？

因为sizeof()Expressions in parentheses are not evaluated.

关系操作符

!= 用于测试“不相等”

== 用于测试“相等”

逻辑操作符

&& 逻辑与

|| 逻辑或

#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变了,Why haven't the others changed,Here is because when wea=0通过&&The judgment behind whether it is true or false,The overall result is false,Therefore, the subsequent auto-increment operation is not performed.

条件操作符

exp1 ? exp2 : exp3

If the expression before the question mark evaluates to true,那么整个表达式的结果就是exp2,否则就是exp3.

逗号表达式

exp1, exp2, exp3, …

逗号表达式,就是用逗号隔开的多个表达式.

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

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

Here we will feel that the code is a bit redundant

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

If you change it to this, you will find that the code is obviously simplified.

隐式类型转换

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都是小于4bytes so an integer promotion is required,So not equal.

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

这里的c在+-The operator is also followed by integer promotions,所以都是4个字节.

算术转换

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

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

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

警告：

但是算术转换要合理,要不然会有一些潜在的问题,Such as precision will be lost.

操作符的属性

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

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;
}

Although we know the order of execution first*后-But we don't know exactly whichfunprepared in advance,So it's an expression in question,The results are different under different compilers.

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

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

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

原网站

版权声明
本文为[~Xiao Ming learns programming]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/211/202207302229490247.html