【C语言】操作符详解(一)

操作符

分类

算术操作符

+	-	*	/	%

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

int main() {
	//整数除法得到商(整数)
	printf("3/5=%d\n", 3 / 5);
	printf("6/5=%d\n", 6 / 5);
	
	//浮点数除法，只要除号两端有一个数是浮点数
	printf("6.0/5=%f\n", 6.0 / 5);
	
	//取余
	printf("7%%4=%d\n", 7 % 4);
	return 0;
}

移位操作符

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

	//移位操作符
	//左移：将数的二进制位向左移位，移1位相当于乘以2
	printf("2<<1=%d\n", 2 << 1);
	//二进制表示为00000000000000000000000000000010(32位)
	//第1位移出，最后1位补0，结果是00000000000000000000000000000100(十进制4)
	
	//右移：
	printf("10>>1=%d\n", 10 >> 1);
	//二进制表示为00000000000000000000000000001010(32位)
	// 1、算数右移
	// 规则：右边丢弃，左边补原符号位，结果是00000000000000000000000000000101(十进制5)
	// 2、逻辑右移
	// 规则：右边丢弃，左边补0，结果是00000000000000000000000000000101(十进制5)
	//对于unsigned int/char
	//测试当前编译器是什么规则
	printf("-1>>1=%d\n", -1 >> 1);

整数的二进制表示有三种形式
原码：直接根据数值写出的二进制序列
反码：原码的符号位不变，其它位按位取反
补码：反码+1
正整数原码反码补码相同
负数在内存中存放的是二进制补码
例如：-1
原码：10000000 00000000 00000000 00000001
反码：11111111 11111111 11111111 11111110
补码：11111111 11111111 11111111 11111111
右移如果补1，结果11111111 11111111 11111111 11111111(十进制-1)
右移如果补0，结果01111111 11111111 11111111 11111111，是一个比较大的数字

位操作符

&	按位与
|	按位或
^	按位异或

	//位操作符
	//&——按(二进制)位与
	printf("3&5=%d\n", 3 & 5);
	//00000000 00000000 00000000 00000011——十进制3
	//00000000 00000000 00000000 00000101——十进制5
	//00000000 00000000 00000000 00000001——十进制1
	
	//|——按(二进制)位或
	printf("3|5=%d\n", 3 | 5);
	//00000000 00000000 00000000 00000011——十进制3
	//00000000 00000000 00000000 00000101——十进制5
	//00000000 00000000 00000000 00000111——十进制7
	
	//^——按(二进制)位异或
	//规则：相同为0，相异为1
	printf("3^5=%d\n", 3 ^ 5);
	//00000000 00000000 00000000 00000011——十进制3
	//00000000 00000000 00000000 00000101——十进制5
	//00000000 00000000 00000000 00000110——十进制6

【例1】不定义第三个变量，交换两个变量的值

	int a = 3, 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);
	//缺陷：a与b不能是大数，数值太大会溢出
	//a=011,b=101
	a = a ^ b;	//a=110,b=101
	b = a ^ b;	//a=110,b=011
	a = a ^ b;	//a=101,b=011
	printf("a=%d,b=%d\n", a, b);

	//发现a^ b^ b == a;
	//可以利用这个性质编码和译码

【例2】求整数的二进制中1的个数

	int x = 0, i = 0, j = 1, count = 0;
	printf("请输入一个整数：>");
	scanf("%d", &x);
	for (i = 1; i < 32; i++) {
		if ((x & j) != 0) {
			count++;
		}
		j *= 2;
	}
	printf("1的个数：%d\n", count);

赋值操作符

=

	//赋值操作符
	int a = 10, x = 0, y = 20;
	//连续赋值
	a = x = y + 1;
	//等价
	//x = y + 1;
	//a = x;

复合赋值符

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

	a = a + 100;
	//等价
	//a += 100;

单目操作符

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

	//单目操作符
	//逻辑反操作
	int flag = 5;
	printf("!flag=%d\n", !flag);	//！让真变假，假变真

	//操作数的类型长度
	int a = 10;
	printf("sizeof(a)=%d\n", sizeof(a));
	//printf("sizeof(a)=%d\n", sizeof a);		//省略括号证明sizeof是操作符而不是函数
	printf("sizeof(int)=%d\n", sizeof(int));
	char arr[10] = { 0 };
	printf("sizeof(arr)=%d\n", sizeof(arr));
	int arr[10] = { 0 };
	printf("sizeof(arr)=%d\n", sizeof(arr));
	printf("sizeof(int[10])=%d\n", sizeof(int[10]));		//说明int[10]是数组类型
	short s = 5;
	int b = 10;
	printf("%d\n", sizeof(s = b + 2));		//s的空间就是short——2字节
	printf("s=%d\n", s);		//sizeof括号中放的表达式不参与运算

	//二进制按位取反
	int c = -1;
	//10000000 00000000 00000000 00000001
	//11111111 11111111 11111111 11111111——补码
	int d = ~c;
	//00000000 00000000 00000000 00000000
	printf("%d\n", d);

	//前置、后置++	--
	int e = 10;
	int f = e++;    //后置++：直接使用，后++
	printf("%d\n", f);	//10(前置为11)
	printf("%d\n", e);	//11(前置为11)
	int g = 10;
	printf("%d\n", g--);	//10，先使用后减
	printf("%d\n", g);		//9

	//间接访问操作符
	int x = 10;
	printf("%p\n", &x);		//取地址操作符
	int* pa = &x;			//pa是用来存放地址的——就是一个指针变量
	*pa = 20;				//*为解引用操作符——间接访问操作符
	printf("%d\n", x);		//20

	//强制类型转换
	//int h = 3.14;			//warning
	int h = (int)3.14;

关系操作符

>	>=	<	<=
!=		用于测试"不相等"
==		用于测试"相等"

	int a = 3, b = 5;
	//if (a == b)		//注意：=为赋值	==判断相等
	//if (a != b) 
	if (a < b) {

	}
	//比较两个字符串不能使用==

逻辑操作符

&&		逻辑与
||		逻辑或

	//逻辑操作符
	int a = 3, b = 0;
	if (a && b) {
		//a和b同时为真
	}
	if (a || b) {
		//a或b为真
	}

	//区分逻辑与	按位与
	1&2-->0
	1&&2-->1
	//区分逻辑或	按位或
	1|2-->3
	1||2-->1

	int i = 1, a = 0, b = 2, c = 3, d = 4;
	//i = a++ && ++b && d++;		//左边为假右边就直接跳过，结果1 2 3 4
	i = a++ || ++b || d++;			//只要遇到真，后面就跳过，结果1 3 3 4
	printf("a=%d b=%d c=%d d=%d\n", a, b, c, d);

条件操作符

也称为三目操作符

exp1?exp2:exp3

	//条件操作符
	int a = 3, b = 0;
	if (a > 5) {
		b = 1;
	}
	else {
		b = -1;
	}
	//b = a > 5 ? 1 : -1;

逗号表达式

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

	//逗号表达式
	int a = 3, b = 5, c = 0;
	int d = (c = 5, a = c + 3, b = a - 4, c += 5);
	//从左向右依次计算，取最后一个表达式的结果
	//c=5-->a=8-->b=4-->c=10，结果d=10

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

下标引用

[ ] 下标引用操作符
操作数：一个数组名+一个索引值

	//下标引用操作符
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//下标          0 1 2 3 4 5 6 7 8 9
	printf("%d\n", arr[4]);

函数调用

( ) 函数调用操作符
接受一个或多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

//函数调用操作符
//函数的定义
int Add(int x, int y) {
	return x + y;
}
void test() {
	
}
int main() {
	int a = 10, b = 20;
	int ret = Add(a, b);		//()——函数调用操作符	//3个操作数
	test();
	return 0;
}

如果是无返回值的函数调用也需加()，因为是函数调用操作符

结构成员

.
->

//结构成员访问操作符
//书：书名，书号，出版社，作者，定价
//创建一个自定义的类型
struct Book {
	//结构体的成员(变量)
	char name[20];
	char id[20];
	int price;
};
int main() {
	//结构体变量名.成员名
	struct Book b = { "C语言","20220901",55 };
	printf("书名：%s\n", b.name);
	printf("书号：%s\n", b.id);
	printf("定价：%d\n", b.price);
	return 0;
}

或

int main() {
	//结构体变量名.成员名
	struct Book b = { "C语言","20220901",55 };
	struct Book* pb = &b;
	printf("书名：%s\n", (*pb).name);
	printf("书号：%s\n", (*pb).id);
	printf("定价：%d\n", (*pb).price)；
	return 0;
}

或

int main() {
	//结构体变量名.成员名
	struct Book b = { "C语言","20220901",55 };
	struct Book* pb = &b;
	//结构体指针->成员名
	printf("书名：%s\n", pb->name);
	printf("书号：%s\n", pb->id);
	printf("定价：%d\n", pb->price);
	return 0;
}