运算符

() 优先级最大， , 优先级最小

printf("%lf", (1.1 + 2.01));
// 输出结果为 3.110000
printf("%.2lf", (1.1 + 2.01));
// 输出结果为 3.11

算术运算符

+	// 两数相加
-	// 两数相减
*	// 两数相乘
/	// 两数相除
%	// 取余数，例如 1 % 2 = 1

• 整数计算，即使最后的结果是小数，最后输出的结果还是整数

  printf("%lf", (10 / 3));	// 输出结果 0.000000
  // 以数学的思维来看其结果为 3.333.. ,在这里直接舍弃小数，且不会四舍五入
  printf("%d", (10 / 3));	// 输出结果 3

• 小数计算，其结果一定是小数，即使能整除；小数和整数一起计算最后的结果也是小数

  printf("%d", (9.0 / 3.0));		// 其输出结果为 0
  printf("%.2lf", (9.0 / 3.0));	// 其输出结果为 3.00

  小数太长，最后的结果可能不精确

• 取余细节：两数都必须是整数

  结果的符号和第一个数保持一致

  不能 %0

  printf("%d", (10 % 3));
  
  printf("%d", (10.0 % 3));	// 错误的

练习

#include <stdio.h>

void main()
{
    int a;
    printf("输入一个百位的数：");
    scanf("%d", &a);
    int ge = a / 1 % 10;
    int shi = a / 10 % 10;
    int bai = a / 100 % 10;
    printf("个位：%d\n", ge);
    printf("十位：%d\n", shi);
    printf("百位：%d\n", bai);
}

自增自减

自增与自减在不同的编译环境下的运算方式会有所不同：

• 前缀优先于后缀
• 前缀统一自增/自减，在把结果拿出来用
• 后缀统一先用，等整个表达式中的变量用完了，在进行自增

a++		// 先赋值，在自增
++a		// 先自增，在赋值
    
a--		// 先赋值，在自减
--a		// 先自减，在赋值

int a = 10;
int b = a++;	// b = 10

int c = 10;
int d = ++c;	// c = 11

int i = 10;
int j = 5;
int k = i++ + ++i - --j - i--;
// 根据上面的规则计算
// 前缀优先于后缀，所以 ++i - --j ==> 11 - 4
// 此时 i = 11，j = 4
// 后缀统一先用，在自增，所以先用 11 + 11 - 4 - 11 = 7
// 在自增/自减，因为 i++ 之后又 i--，所以 i 没变化 i = 11
printf("%d", k); 
// 在类Unix的系统上是这样运算的
// 10 + 12 - 4 - 12
// i++ 为 10，对于下一个 i 是 11
// ++i 为 12，先自增在赋值，所以 11 自增变为 12，对于下一个 i 为 12
// --j 为 4
// i-- 为 12，先自减在赋值，对于下一个 i 是 11
// 所以最后的结果为 10 + 12 - 4 - 12 = 6

根据上面的规则

int a = 10;
int k1 = a++ + a++;
// 后缀先用，则 10 + 10 = 20
// 此时 a = 12，因为有两个 a++
int k2 = ++a + ++a;
// 前缀先自增，自增两次，a = 14
// 所以结果为 14 + 14 = 28
// 此时 a = 14
int k3 = ++a + a++;
// 前缀优先于后缀，所以 ++a = 15
// a++ = 15,结果为 15 + 15 = 30
// 此时 a = 16
int k4 = a++ + ++a;
// 前缀优先于后缀，所以 ++a = 17
// a++ = 17,结果为 17 + 17 = 34
// 此时 a = 18
printf("%d\n", k1);		// 20

printf("%d\n", k2);		// 28 
printf("%d\n", k3);		// 30
printf("%d\n", k4);		// 34

赋值运算符

int a;
a  = 10;	// 将10赋值给a
a += 10;	// a += 10 ==> a = a + 10;
a -= 10;	// a -= 10 ==> a = a - 10;
a *= 10;	// a *= 10 ==> a = a * 10;
a /= 10;	// a /= 10 ==> a = a / 10;
a %= 10;	// a %= 10 ==> a = a % 10;

关系运算符

一般用于判断真假，1 为真， 0 为假

a == b		// a 等于 b
a != b		// a不等于 b
a > b		// a 大于 b
a >= b		// a 大于等于 b
a < b		// a 小于 b
a <= b		// a 小于等于 b

printf("%d", (3 > 2));		// 输出结果为 1

练习

判断奇偶数

#include <stdio.h>

void main()
{
    int a;
    printf("请输入判断数：");
    scanf("%d", &a);
    if ((a % 2) == 0)
    {
        printf("%d是偶数", a);
    }
    else
    {
        printf("%d是奇数", a);
    }
}

逻辑运算符

!		// 非，取反

&&		// 而且，两边的结果为真，才为真 / 同时满足

||		// 或者，两边的结果为假，才为假 / 二选一

int a = 0;
printf("%d", a > 1 && a < 10);	// 0 (为假)
// 细节
// 因为 a > 1 不成立，所以 a < 10 的代码就不会被执行
// 只有前面的代码成立了，&& 后面的代码才会继续执行

先找 || ，在找 &&

先找到 || 然后在以该符号为界限划分

int a = 3;
int b = 4;
int c = 5;
int num = a || b + c && b - c;
==> num = a || (b + c && b - c);

练习

判断：键盘输入一个两位的整数，要求该数字不能包含7，而且不能是7的倍数，如果满足条件则为真，否则为假

#include <stdio.h>

void main() {
	int num;
	printf("请输入判断数：");
	scanf("%d", &num);
	int ge = num % 10;
	int shi = (num / 10) % 10;
	if (ge != 7 && shi != 7 && num % 7 != 0) {
		printf("%d为真", num);
	} else {
		printf("%d为假", num);
	}
}

逻辑运算符的短路性

三元运算符

// 当a 大于 b 时，则赋值a；当a 小于 b时，则赋值 b
a > b ? a : b;

int a = 10;
int b = 30;
int c = 20;
int d = a > b ? a : b;
int e = d > c ? d : c;
printf("%d,%d,%d中最大值为%d", a, b, c, e);

// 绝对值
int number = -20;
number = number >= 0 ? number : -number;
// 最后的结果为正数

多从运算符

解题关键：从左边的额第一个问号开始往后找冒号

如果找的过程中，遇到了其它问号，那么找冒号的数量加1

int y = a > b ? a > c ? a : c : b > c ? b : c;
// 有两个 ? 则要找两个 : 并且以该 : 为基础划分括号
int y = a > b ? (a > c ? a : c) : (b > c ? b : c);