常用操作符

常用操作符

算术操作符

+  -  *  /

除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
% 操作符的两个操作数必须为整数。返回的是整除之后的余数。

移位操作符

<< 左移操作符
>> 右移操作符

• 左移操作符

左边抛弃，右边补零

int num = 10;
int num1 = num << 1;

• 右移操作符

1.逻辑右移 左边用0填充，右边丢弃。
2.算术右移 左边用原该值的符号位填充，右边丢弃
大多数编译器都是支持算术右移

int num = -1;
int num1 = num >> 1;

位操作符

& 按位与
| 按位或
^ 按位异或，相同为0，相异为1

int main()
{
	int a = 2;
	int b = -3;
	int c = a & b;//0
	int c = a | b;//-1
	int c = a ^ b;
	printf("%d\n", c);
	//2的补码       00000000000000000000000000000010
	//-3的原码      10000000000000000000000000000011
	//-3的反码      11111111111111111111111111111100
	//-3的补码      11111111111111111111111111111101
	//c的补码&      00000000000000000000000000000000
	//c的补码|      11111111111111111111111111111111
	//c的反码       11111111111111111111111111111110
	//c的原码       10000000000000000000000000000001
	//c = a ^ b和上面一样，这里不再赘述
}

变量以二进制补码形式存放在内存中，以16进制显示
正数的原码，反码，补码相同
负数的原码是其二进制，反码是原码符号位不变，其他位取反，补码是反码加1
打印是以二进制原码形式输出

面试题

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

#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	a = a^b;
	b = a^b;
	a = a^b;
	printf("a = %d b = %d\n", a, b);
	return 0;
}

这里代码的可读性不够好，只适用于整型，一般情况下，我们都会创建临时变量

赋值操作符，复合赋值符

+=
-=
*=
/=
%=
&=
|=
^= >>= <<=

单目操作符

! 逻辑反操作 非零为真，零为假
-负值
+正值
& 取地址
sizeof 操作数的类型长度（以字节为单位）
~ 对一个数的二进制按位取反
–前置、后置–
++ 前置、后置++
*间接访问操作符(解引用操作符)
(类型) 强制类型转换

注意：sizeof()内部的表达式是不参与运算的

int main()
{
	int a = 5;
	short s = 10;
	printf("%d\n", sizeof(s = a + 2));//2
	printf("%d\n", s);//10
	return 0;
}

关系操作符

>
>=
<
<=
!= 用于测试“不相等”

==用于测试“相等”

逻辑操作符

&&
||

#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);//1 2 3 4 
	return 0;
}
//程序输出的结果是什么？

条件操作符

exp1 ? exp2 : exp3

逗号表达式

exp1, exp2, exp3, …expN

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

a = get_val();
count_val(a);
while (a > 0)
{
	//业务处理
	a = get_val();
	count_val(a);
}
//如果使用逗号表达式，改写：
while (a = get_val(), count_val(a), a>0)
{
	//业务处理
}

下标引用，函数调用，结构体成员

[]
()
.  ->

整型提升

整型提升的意义：

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

那么如何进行整型提升呢？

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

int main()
{
	char a = 3;
	char b = 127;
	char c = a + b;
	printf("%d\n", c);
	//00000000000000000000000000000011
	//00000011 - a
    //00000000000000000000000001111111
    //01111111 - b
    //a和b多是char类型，自身大小都是1byte，所以这里计算的时候要进行整型提升
    //00000000000000000000000000000011
    //00000000000000000000000001111111
    //00000000000000000000000010000010
    //10000010 - c
    //以十进制整型打印输出，进行整型提升
    //11111111111111111111111110000010
    //11111111111111111111111110000001
    //10000000000000000000000001111110
    //-126
	return 0;
}

正数的整型提升 -> 高位补充符号位，即为0。
负数的整型提升 -> 高位补充符号位，即为1。
无符号整型提升，高位补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");//c
		//这里a，b都进行了整型提升
	return 0;
}

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

算术转换

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

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

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

操作符的属性

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

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

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

总结：

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