C语言 *** 作符

文章目录

• 一. *** 作符的分类
• 二.算术 *** 作符
• 三.移位 *** 作符
• • 1. 左移 *** 作符：
  • 2. 右移 *** 作符：
• 四.位 *** 作符
• • 1. & ———按位与
  • 2. | —— 按位或
  • 3. ^ ——— 按位异或
• 五.赋值 *** 作符
• 六.单目 *** 作符
• • 1. ！（逻辑反 *** 作）
  • 2. +（正值）-（负值）
  • 3. &（取地址）
  • 4. sizeof （ *** 作数的类型长度（以字节为单位））
  • 5. ~ （对一个数的二进制按位取反）
  • 6. ++ - -（前置、后置-- ， 前置、后置++）
  • 7. *（间接访问 *** 作符(解引用 *** 作符)）
  • 8.(类型) —— 强制类型转换
• 七.关系 *** 作符
• 八.逻辑 *** 作符
• • 1.&&（逻辑与）
  • 2.||(逻辑或)
• 九.条件 *** 作符
• 十.逗号表达式
• 十一.下标引用、函数调用和结构成员
• • 1. [ ] 下标引用 *** 作符
  • 2. ( ) 函数调用 *** 作符
  • 3. 结构成员访问 *** 作符
• 十二.结语

一. *** 作符的分类

*** 作符可以分为以下几类：

• 算术 *** 作符
• 移位 *** 作符
• 位 *** 作符
• 赋值 *** 作符
• 单目 *** 作符
• 关系 *** 作符 逻辑 *** 作符
• 条件 *** 作符
• 逗号表达式
• 下标引用、函数调用和结构成员

二.算术 *** 作符

算术 *** 作符有以下五种：

•     +   ————— 加法
  

•     -   ————— 减法
  

•     *   ————— 乘法
  

•     /   ————— 除法
  

•     %   ————— 取余（求模）
  

其中，+ ， - 的优先级低于 * ， / ， %.
注意：

1. 除了 % *** 作符之外，其他的几个 *** 作符可以作用于整数和浮点数。
   

2. 对于 / *** 作符如果两个 *** 作数都为整数，执行整数除法。
   

   而只要有浮点数执行的就是浮点数除法。
   

3. % *** 作符的两个 *** 作数必须为整数。
   

   返回的是整除之后的余数。
   

这儿给大家两个简单的代码来理解一下第二个注意事项：

#include 
int main()
{
	int a = 0;
	a = 9 / 2;
	printf("a=%d\n", a);
}

运行结果为：

a = 4

#include 
int main()
{
	float a = 0;
	a = 9 / 2.0;
	printf("%f\n", a);
}

运行结果为：

a = 4.500000

三.移位 *** 作符

移位 *** 作符有两种：

•    >> —————— 右移 *** 作符
  

•    << —————— 左移操作符
  

注：移位 *** 作符的 *** 作数只能是整数。

1. 左移 *** 作符：

左边丢弃，右边补 0；

eg：

int main()
{
	int a = 2;
	int b = a << 1;//把 a 的二进制位向左
	printf("b=%d\n", b);
	return 0;
}

运行结果为：

b =4

左移 *** 作符移动图解：

2. 右移 *** 作符：

1. 算术右移
   右边丢弃，左边补原符号位。
   

2. 逻辑右移
   左边用0填充，右边丢弃（右移丢弃·，左边补 0 ）

右移 *** 作符移动图解：

警告⚠ ：

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

例如：

int = 10;
num>> -1;//error

四.位 *** 作符

位 *** 作符有三种：

•    & ——————— 按位与
  

•    | ——————— 按位或
  

•    ^ ——————— 按位异或
  

注：他们的 *** 作数必须是整数。

1. & ———按位与

解释：

两个数的二进制位对应，若对应的二进制位有一个为 0 就出 0 ，当两个都为 1 时才出 1 。

下面举个例子说明一下：
eg：

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

运行结果

c = 1

图解

补充：

前面提到的原码，反码，补码是针对负数的，对于正整数来说，原码，反码，补码是一样的。

2. | —— 按位或

解释：

两个数的二进制位对应，若对应的二进制位有一个为 1 就出 1 ，当两个都为 0 时才出 0 。

举例说明：
eg：

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

运行结果：

c = 7

图解：

3. ^ ——— 按位异或

解释：

两个数的二进制位对应，对应的二进制位进行异或，对应的二进制位相同出 0 ，相异出 1 .

举例说明：
eg：

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

运行结果：

c = 6
图解：

五.赋值 *** 作符

赋值 *** 作符是一个简单的 *** 作符，它大致拥有这么一些：

•     =
  

•     +=
  

•     -=
  

•     *=
  

•     /=
  

•     %=
  

•     >>=
  

•     <<=
  

•     &=
  

•     |=
  

•     ^=
  

举例说明：
eg：

int a = 0;
a = 100;
a = a + 100;

int a = 0;
a = 100;
a += 100;

这儿将 a = a + 100；写成a += 100；达到的效果一样，但可以使代码看上去更加简洁，美观。

其他运算符使用方法与这个一样。

注意：
=为赋值，==为判断。

六.单目 *** 作符

单目 *** 作符有下面几种：

•  ! ————— 逻辑反 *** 作
  

•  - ————— 负值
  

•  + ————— 正值
  

•  & ————— 取地址
  

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

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

•  -- ————— 前置、后置--
  

•  ++ ————— 前置、后置++
  

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

•  (类型) ————— 强制类型转换
  

举例说明：

1. ！（逻辑反 *** 作）

int flag = 0;
	if (flag == 0)//flag为假时，输出Hello
	{
		printf("Hello\n");
	}
	if (flag != 0)//flag为假时，输出World
	{
		printf("World\n");
	}

2. +（正值）-（负值）

int a = 10;
a = -a;//负值
a = +a;//正值

3. &（取地址）

int a = 10;
int *pa = &a;//将变量a的地址存放在pa中，此时，pa是指针变量

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

eg：

int a = 10;
printf("%d\n", sizeof(a));   //结果为 4 字节
printf("%d\n", sizeof(int)); //结果为 4 字节
printf("%d\n", sizeof a);    //结果为 4 字节
printf("%d\n", sizeof int );//err(错误)

注意：

sizeof 计算变量的时候可以省略括号，计算类型的时候不能省略括号。

sizeof也能计算数组的大小：

int arr[10] = { 0 };
printf("%d\n", sizeof(arr));//结果为 40 (字节)

注意：

sizeof括号中的表达式是不参与运算的！

eg：

short s = 5;
int a = 10;
printf("%d\n", sizeof(s = a + 2));
printf("%d\n", s);
//结果为 2   5	

5. ~ （对一个数的二进制按位取反）

int a = -1;
int b = ~a;
printf("%d\n", b);

运行结果：

0

图解：

6. ++ - -（前置、后置-- ， 前置、后置++）

int a = 10;
int b = a++;//后置++，先使用，再++
printf("%d\n", a);//结果为 11
printf("%d\n", b);//结果为 10

int a = 10;
int b = ++a;//前置++，先++，再使用
printf("%d\n", a);//结果为 11
printf("%d\n", b);//结果为 11

注意：

- - 的使用与++一样.

7. *（间接访问 *** 作符(解引用 *** 作符)）

int a = 10;
int *pa = &a;
*pa = 20;//解引用
printf("%d\n", a);//结果为 20

8.(类型) —— 强制类型转换

int a = 3.14;

这个时候会报警告：从“double”转换到“int”，可能丢失数据

int a = (int)3.14

这个时候就不会报警告

七.关系 *** 作符

关系 *** 作符有下面这些：

•      >  ———  大于
  

•      =  ———  等于
  

•      <  ———  小于
  

•      <=  ———  小于等于
  

•      >=  ———  大于等于
  

•      !=  ———  不等于
  

•      ==  ———  等于
  

关系 *** 作符主要实现数据的比较运算，如大于，小于等。

这儿比较简单，

1.比较两个字符串是否相等的时候不能使用 == ，应该使用 strcmp () 函数。

2.一个 = 为赋值，两个 == 为判断。

八.逻辑 *** 作符

逻辑 *** 作符

•   &&  ———  逻辑与
  

•   ||  ———  逻辑或
  

1.&&（逻辑与）

仅当两 *** 作数都为真时结果才为真，否则为假。

eg:

int a = 0;
int b = 2;
	if (a && b)
	{
		printf("hehe\n");
	}
	//不会打印 hehe ，因为a = 0为假

2.||(逻辑或)

仅当两 *** 作数都为假时结果才为假，否则为真。

eg：

int a = 0;
int b = 2;
	if (a || b)
	{
		printf("hehe\n");
	}
	//会打印 hehe ，因为b=0为真

注意：

在逻辑表达式中，并不是所有的逻辑运算符都被执行。

1.在 && 中，只要有一个表达式为假便为假，不再执行后面的表达式。

2.在 || 中，只要有一个表达式为真便为真，不再执行后面的表达式。

下面可以来看一道题：

int i = 0, a = 0, b = 2, c = 3, d = 4;
i = a++ && ++b && d++;//后置++，先使用再++，所以这儿使用a=0，这儿用的是&&，因为a=0为假，所以后面的表达式不执行，a因为a++ 变成1，b，c，d仍为原值
printf("a=%d b=%d c=%d d=%d ",a, b, c, d);//a=1 b=2 c=3 d=4


int i = 0, a = 0, b = 2, c = 3, d = 4;
i = a++ || ++b || d++;//后置++，先使用再++，前置++，先++再使用，所以这儿使用a=0，b=3,这儿用的是||，因为b=3为真，所以后面的表达式不执行，a因为a++ 变成1，b因为++b变成3，c，d仍为原值
printf("a=%d b=%d c=%d d=%d", a, b, c, d);//a=1 b=3 c=3 d=4

九.条件 *** 作符

条件 *** 作符又叫三目运算符，下面是它的符号：
exp1 ? exp2 : exp3
解释：

判断exp1，若exp1为真则返回exp2，否则返回exp3.

eg：

int a = 5;
int b = 10;
int max = (a > b) ? a : b;//若a>b，则max=a,否则max=b

十.逗号表达式

exp1, exp2, exp3, …, expN
解释：

从左往右依次执行。

整个表达式的结果为最后一个表达式的结果。

eg：

int a = 3;
int b = 5;
int c = 0;
int d = (c = 5, a = c + 3, b = a - 4, c += 5);//结果为10

十一.下标引用、函数调用和结构成员 1. [ ] 下标引用 *** 作符

*** 作数：一个数组名 + 一个索引值

eg：

int arr[10] = { 0 };//创建数组
arr[4] = 8;//实用下标引用 *** 作符
//[ ]的两个 *** 作数是arr和4

2. ( ) 函数调用 *** 作符

符号：

（）

接受一个或者多个 *** 作数：第一个 *** 作数是函数名，剩余的 *** 作数就是传递给函数的参数

eg:

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int a = 10;
	int b = 20;
	int ret = Add(a, b);//()——函数调用 *** 作符
	printf("%d\n", ret);
	return 0;
}

3. 结构成员访问 *** 作符

 .     ————     结构体.成员名
 ->    ————  结构体指针->成员名

eg:

    //结构体变量名.成员名
	struct BOOK b = { "C语言","20220415",60 };
	printf("书名：%s\n", b.name);
	printf("书号：%s\n", b.id);
	printf("价格：%d\n", b.price);


	//结构体指针->成员名
	struct BOOK * pb = &b;
	printf("书名：%s\n", pb->name);
	printf("书号：%s\n", pb->id);
	printf("价格：%d\n", pb->price);

十二.结语

本人水平有限，免不了一些错误和不足之处，希望各位小伙伴能在评论区进行批评改正，感谢各位的 阅读，希望大家能有所收获。