C语言操作符

目录

算术操作符

移位操作符

位操作符

赋值操作符

单目操作符

关系操作符

逻辑操作符

三目操作符

逗号操作符

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

---

算术操作符

包括：

+ - * / %

只对除和取模举例：

#include <stdio.h>
int main()
{
	int ret = 9 / 2;
	//对于/来说两边都是整数执行的是整数除法
	//操作数种有浮点数才执行浮点数除法
	double a = 9.0 / 2;
	printf("%d\n", ret);
	printf("%lf\n", a);

	//%--取模--看余数
	//%--只能针对整形类型
	int b = 9 % 2;
	printf("%d\n", b);
	return 0;
}

发现当使用除法时，只有有浮点数才执行浮点数除法。

%表示取余数，所以b的结果为1.

移位操作符

移位操作符移动的是二进制位

对于整数的二进制有三种表现形式：原码、反码、补码

整数在内存种存储的是二进制的补码
  

1.<<--左移操作符，左边丢弃，右边补0

2.>>右移操作符分为逻辑右移和算术右移

逻辑右移，右边丢弃，左边补0

算数右移--右边丢弃，左闭补原符号位

绝大部分编译器都是采用算数右移。

int main()
{
	
	int a = 5;
	int b = a >> 1;
	printf("%d\n", b);
	int c = -1;
	int d = c >> 1;
	printf("%d\n", d);
	return 0;
}

位操作符

与&、或|、异或^

int main()
{
	//^ --异或
	//| --按位或
	//& --按位与
	int a = 3;
	int b = -2;
	int c = a&b;//内存中补码进行计算
	printf("%d\n", c);//2
	int a = 3;
	int b = -2;
	int c = a|b;
	printf("%d\n", c);//-1
	int a = 3;
	int b = -2;
	int c = a ^ b;
	printf("%d\n", c);//-3
	return 0;
}

^还能解决一个问题，不能创建临时变量（第三个变量），实现两个数的交换

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

赋值操作符

int main()
{
	int a = 10; 
	int x = 0; 
	int y = 20; 
	a = x = y + 1;//连续赋值
	printf("%d\n", a);
	return 0;
}

单目操作符

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

1.！

int main()
{
	int a = 0;
	int b = !a;
	printf("%d\n", b);
	return 0;
}

2.- +

int main()
{
	int a = 10;
	a = -a;
	printf("%d\n", a);
	a = -a;
	printf("%d\n", a);
	return 0;
}

 3.& *

int main()
{
	int a = 10;
	int *p = &a;
	int b = *p;//右值一般是里面的内容
	*p = 20;//相当于a=20;左值用的里面的空间
	printf("%d\n", a);
	printf("%d\n", b);
	return 0;
}

4.[]

int main()
{
	int arr[10] = { 0 };
	arr;//数组首元素的地址
	&arr[0];//数组首元素的地址
	&arr;//取出数组的地址
	return 0;
}

6.sizeof是计算变量或者类型创建变量内存的大小，和内存存放什么数据没有关系

int main()
{
	//char arr[10] = "abc";
	//printf("%d\n", sizeof(arr));//10
	//printf("%d\n", strlen(arr));//字符串的长度，看内存中是否有/0，计算/0之前的字符个数
	//int a = 10;
	//printf("%d\n", sizeof(a));//4
	//printf("%d\n", sizeof a);
	//printf("%d\n", sizeof(int));//4

	int a = 5;
	short s = 10;
	printf("%d\n", sizeof(s = a + 2));//2
	printf("%d\n", sizeof(s)); // sizeof内部的表达式不参与运算--10
	return 0;
}

7.~

int main()
{
	int a = 0;
	int b = ~a;//按位取反
	printf("%d\n", b);//-1
}

8.++ --

int main()
{
	int a = 10;
	int d = 10;
	int b = a++;//后置++，先使用，再加加
	int c = ++d;//前置++，先++，后使用
	printf("%d\n", b);//10
	printf("%d\n", a);//11
	return 0;
	//--方法跟++一样
}

关系操作符

>

>=

<

<=

!=   用于测试 “ 不相等 ”

==       用于测试 “ 相等 ”

逻辑操作符

&& ||

int main()
{
	int i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++ && ++b && d++;
	//i = a++||++b||d++;
	printf("a = %d b = %d c = %d d = %d\n", a, b, c, d); //1 2 3 4
	return 0;
}

三目操作符

int main()
{
	int a = 3;
	int b = 5;
	int m = 0;
	m = (a > b ? a : b);
	return 0;
}

逗号操作符

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

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

[]--操作符

int main()
{
	int arr[] = { 1, 2, 3, 4, 5 };
	int i = 0;
	printf("%d\n", arr[4]);
	printf("%d\n", 4[arr]);
	//arr[4];--*(arr+4)---*(4+arr)---4[arr]
	//for (i = 0; i < 5; i++)
	//{
	//	printf("%p---%p\n", &arr[i],arr+i);//地址一样
	//}
	return 0;
}

()--函数调用操作符

void test()
{
	printf("hehe\n");
}
int main()
{
	strlen("abc");//strlen返回的是unsigned int
	test();
	return 0;
}

 . -> 用在结构体当中

结构成员访问操作符
结构体变量.成员名
结构体指针->成员名
(*结构体指针).成员名

#include <string.h>
struct Book
{
	char name[20];
	float price;
	char id[10];
};

void print1(struct Book b)
{
	printf("书名：%s\n", b.name);
	printf("价格：%f\n", b.price);
	printf("代号：%s\n", b.id);
}
void print2(struct Book* b)
{
	/*printf("书名：%s\n", (*b).name);
	printf("价格：%f\n", (*b).price);
	printf("书号：%s\n", (*b).id);*/


	printf("书名：%s\n", b->name);//->等价于(*b).
	printf("价格：%f\n", b->price);
	printf("书号：%s\n", b->id);
}

int main()
{
	struct Book b = {"C语言",55.5f,"C20190101"};
	print2(&b);
	//b.price = 100.0f;//
	字符串拷贝-strcpy
	//strcpy(b.name, "数据结构");
	//print1(b);
	//return 0;
	//结构成员访问操作符
	//结构体变量.成员名
	//结构体指针->成员名
	//(*结构体指针).成员名
}