13-操作符（初识）

课前小技巧：VS中，想要复制哪一行，直接把鼠标放在哪一行，Ctrl+C即可，Ctrl+V直接自动复制到下一行

C语言非常灵活：C语言提供了非常丰富的操作符，使用起来比较灵活

13-1 算术操作符

+  -  *  /  %

这里主要讲解除法符合（/）和取模（%）

计算7/2：

int main()
{
	int a = 7/2;  //除法 关注商
	int b = 7%2;  //取模 关注余数
	printf("%d\n",a);
	printf("%d\n",b);
	return 0;

结果如下：

大家可能会疑惑：除法结果为什么不是3.5呢？

那是因为，除号的两端都是整数的时候，执行的是整数除法；如果两端只要有一个浮点数（当然两个都是也可以），执行的就是浮点数的除法

如果你想得到3.5的结果：

int main()
{
	float a = 7/2.0;  //将整数2改为浮点数2.0
	printf("%f\n",a);  //打印浮点数用%f
	return 0;
}

结果如下：

如果你不想要小数点后那么多0 ：

int main()
{
	float a = 7 / 2.0;
	printf("%.1f\n", a);  //%.nf表示浮点数小数点后打印n位
	return 0;
}

完美！

13-2 移位操作符

涉及二进制，暂时不讲，后续会讲

>>  //右移
<<  //左移

13-3 位操作符

暂时不讲，后续会讲

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

13-4 赋值操作符

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

解释如下：

int main()
{
	int a = 0;  //初始化
	a = 20;  //赋值

	a = a + 3;  //a=23
	a += 3;  //相当于a=a+3

	a = a - 3;
	a -= 3;  //相当于a=a-3

	return 0;
}

其余的同理

13-5 单目操作符

什么是单目操作符？

 a+b  //操作数是两个（a和b），所以+是双目操作符，单目操作符的操作数只有一个

单目操作符有哪些？

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

!

在C语言中，0表示假，非0表示真

代码举例：

int main()
{
	int flag = 0;  //为假
	if (!flag)  //为真，可以通过
	{
		printf("Hello World!");
	}
	return 0;
}

成功打印：

再举一个例子：

int main()
{
	int flag = -1;  //为真
	if (!flag)  //为假，不能通过
	{
		printf("Hello World!");
	}
	return 0;
}

没有输出：

-

正变负，负变正

举例如下：

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

代码结果：

+

相当于没有，対值没有影响

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

结果如下：

&

这个在指针部分讲

sizeof

请大家记住：sizeof不是函数，而是操作符，并且是单目操作符！

举例：

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

结果如下：

值得一提的是，sizeof(a)中的()可以去掉，这也证明了sizeof是操作符而不是函数：

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

仍然成功运行：

但是要注意，sizeof(int)时的()不能省略 （红色曲线表示有问题）

我们再拓展一下吧~~~

int main()
{
	int arr[10] = { 0 };
	printf("%d\n", sizeof(arr));
	return 0;
}

结果如下：

所以，此时计算的是整个数组的大小，单位是字节

计算arr[0]的大小：

int main()
{
	int arr[10] = { 0 };
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr[0]));
	return 0;
}

结果如下：

其实计算的就是数组中一个元素的大小

那如果计算sizeof(arr)/sizeof(arr[0])呢？

int main()
{
	int arr[10] = { 0 };
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr[0]));
	printf("%d\n", sizeof(arr)/sizeof(arr[0]));
	return 0;
}

结果不出意外，是10：

我们仔细想一想，这不就是该数组中元素的个数吗？40是数组中元素总的大小，4是1个元素的大小，那么40/4=10就是数组中元素的个数。所以我们得出结论：

求数组中元素的个数（以数组名为arr举例）：

sizeof(arr)/sizeof(arr[0])

~

涉及到二进制，后期再讲

++

有前置和后置之分

后置++：先使用，后++

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

结果如下：

先使用，后++解释该代码，其实就是先把a的值赋给b，a的值再++

前置++：先++，后使用

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

结果如下：

先++，后使用解释该代码，其实就是a的值先++，再把a的值赋给b

--

有前置和后置之分，与++同理

后置--：先使用，后--

测试代码：

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

结果如下：

前置--：先--，后使用

测试代码：

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

结果如下：

*

后期再讲

(类型)

举例：

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

运行后，编译器给出提示：

这是因为，3.14是字面浮点数，编译器默认理解为double类型

我们用(类型)进行强制类型转换：

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

运行结果：

编译器不再提醒：

13-6 关系操作符

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

区分=与==

请大家考虑下面代码是否能够成功打印"Hello World!"：

int main()
{
	int a = 10;
	if (a = 3)
	{
		printf("Hello World!");
	}
	return 0;
}

答案是可以：

因为a=3是赋值，并不是判断a是否等于3。a起初是10，后来又被赋值为3，()里面的结果就是3，3非0，为真，所以成功打印

那么下面代码是否能够成功打印"Hello World!"呢？

int main()
{
	int a = 10;
	if (a == 3)
	{
		printf("Hello World!");
	}
	return 0;
}

答案是不能：

这里用的是a==3，是判断a是否等于3，很明显，a的值是10，并不等于3，自然就无法打印

13-7 逻辑操作符

&&  逻辑与  并且
||  逻辑或  或者

举一个生活中的例子：

①甲需要乙并且丙帮忙，那么乙和丙缺一不可

②甲需要乙或者丙帮忙，那么乙来、丙来、乙丙都来这三种情况都可以

&&

例子1：

int main()
{
	int a = 1;
	int b = 2;
	if (a&&b)  //a和b都为真才能打印
	{
		printf("Hello World!");
	}
	return 0;
}

结果：

例子2：

int main()
{
	int a = 0;
	int b = 2;
	if (a&&b)  //a和b有一个是0就不能打印
	{
		printf("Hello World!");
	}
	return 0;
}

结果：

例子3：

int main()
{
	int a = 0;
	int b = 0;
	if (a&&b)  //a和b都为0当然也不能打印
	{
		printf("Hello World!");
	}
	return 0;
}

结果：

||

例子1：

int main()
{
	int a = 10;
	int b = 23;
	if (a||b)  //a和b都为真当然能打印
	{
		printf("Hello World!");
	}
	return 0;
}

结果：

例子2：

int main()
{
	int a = 10;
	int b = 0;
	if (a||b)  //a和b有一个为真就能打印
	{
		printf("Hello World!");
	}
	return 0;
}

结果：

例子3：

int main()
{
	int a = 0;
	int b = 0;
	if (a||b)  //只有a和b都为0的时候不能打印
	{
		printf("Hello World!");
	}
	return 0;
}

结果：

13-8 条件操作符

也叫三目操作符：

exp1?exp2:exp3
//exp：表达式

含义：表达式1为真，表达式2的值为结果；表达式1为假，表达式3的值为结果。

举一个简单的例子：

int main()
{
	int a = 10;
	int b = 23;
	int r = a > b ? a : b;
	printf("%d\n", r);
	return 0;
}

代码结果：

其实很好理解，如果a>b，就取a的值作为结果，反之，取b的值作为结果

当然，这个三目操作符可以嵌套，但是建议不要太复杂，这样不便于自己和他人理解

13-9 逗号表达式

理解：逗号表达式就是逗号隔开的一串表达式

特点：从左向右依次计算，整个表达式的结果是最后一个表达式的结果

举一个例子吧：

int main()
{
	int a = 10;
	int b = 20;
	int c = 0;
	//       c=8   a=28  5
	int r = (c=a-2,a=b+c,c-3);
	printf("%d\n", r);
	return 0;
}

结果如下：

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

[]  ()  .  ->

[]

我们可以从以下程序理解：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };  //定义数组的语法形式，并不是操作符
	arr[3] = 20;
	printf("%d\n", arr[3]);
	return 0;
}

结果如下：

其实，在arr[3]=20中，[]就是下标引用操作符，arr和3就是[]的操作数

这里要注意，如果有变量n=3，arr[n]=20依旧可以运行，因为这里并不是创建数组，而是访问数组元素

换句话说，变量的值是程序运行出来的，而定义数组大小的时候要用常量明确给出数组大小

()

int Max(int x, int y)
{
	if (x > y)
	{
		return x;
	}
	else
	{
		return y;
	}
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("%d\n", Max(a, b));  //Max(a,b)中的()就是函数调用操作符，Add，2，3是()的操作数
	return 0;
}