CDSY,CDSY.XYZ

运算符基本概念

• 和数学中的运算符一样, C语言中的运算符是告诉程序执行特定算术或逻辑操作的符号
  • 例如告诉程序, 某两个数相加, 相减,相乘等
    
• 什么是表达式
  • 表达式就是利用运算符链接在一起的有意义,有结果的语句;
  • 例如: a + b; 就是一个算数表达式, 它的意义是将两个数相加, 两个数相加的结果就是表达式的结果
  • 注意: 表达式一定要有结果

---

运算符分类

• 按照功能划分:
  • 算术运算符
  • 赋值运算符
  • 关系运算符
  • 逻辑运算符
  • 位运算符
• 按照参与运算的操作数个数划分:
  • C语言中唯一的一个,也称为问号表达式 如: a>b ? 1 : 0;
  • 有两个操作数 如 : a + b;
  • 只有一个操作数 如 : i++;
  • 单目运算
  • 双目运算
  • 三目运算

---

运算符的优先级和结合性

• 早在小学的数学课本中,我们就学习过"从左往右,先乘除后加减,有括号的先算括号里面的", 这句话就蕴含了优先级和结合性的问题
• C语言中,运算符的运算优先级共分为15 级。1 级最高,15 级最低

• 在C语言表达式中,不同优先级的运算符, 运算次序按照由高到低执行
• 在C语言表达式中,相同优先级的运算符, 运算次序按照结合性规定的方向执行
  
  

---

算数运算符

优先级	名称	符号	说明
3	乘法运算符	*	双目运算符,具有左结合性
3	除法运算符	/	双目运算符,具有左结合性
3	求余运算符 (模运算符)	%	双目运算符,具有左结合性
4	加法运算符	+	双目运算符,具有左结合性
4	减法运算符	-	双目运算符,具有左结合性

• 注意事项
  • 如果参与运算的两个操作数皆为整数, 那么结果也为整数
  • 如果参与运算的两个操作数其中一个是浮点数, 那么结果一定是浮点数
  • 求余运算符, 本质上就是数学的商和余"中的余数
  • 求余运算符, 参与运算的两个操作数必须都是整数, 不能包含浮点数
  • 求余运算符, 被除数小于除数, 那么结果就是被除数
  • 求余运算符, 运算结果的正负性取决于被除数,跟除数无关, 被除数是正数结果就是正数,被除数是负数结果就是负数
  • 求余运算符, 被除数为0, 结果为0
  • 求余运算符, 除数为0, 没有意义(不要这样写)

#include <stdio.h>
int main(){
    int a = 10;
    int b = 5;
    // 加法
    int result = a + b;
    printf("%i\n", result); // 15
    // 减法
    result = a - b;
    printf("%i\n", result); // 5
    // 乘法
    result = a * b;
    printf("%i\n", result); // 50
    // 除法
    result = a / b;
    printf("%i\n", result); // 2
    
    // 算术运算符的结合性和优先级
    // 结合性: 左结合性, 从左至右
    int c = 50;
    result = a + b + c; // 15 + c;  65;
    printf("%i\n", result);
    
    // 优先级: * / % 大于 + -
    result = a + b * c; // a + 250; 260;
    printf("%i\n", result);
}

#include <stdio.h>
int main(){
    // 整数除以整数, 结果还是整数
    printf("%i\n", 10 / 3); // 3

    // 参与运算的任何一个数是小数, 结果就是小数
    printf("%f\n", 10 / 3.0); // 3.333333
}

#include <stdio.h>
int main(){
    // 10 / 3 商等于3, 余1
    int result = 10 % 3;
    printf("%i\n", result); // 1

    // 左边小于右边, 那么结果就是左边
    result = 2 % 10;
    printf("%i\n", result); // 2

    // 被除数是正数结果就是正数,被除数是负数结果就是负数
    result = 10 % 3;
    printf("%i\n", result); // 1
    result = -10 % 3;
    printf("%i\n", result); // -1
    result = 10 % -3;
    printf("%i\n", result); // 1
}

---

赋值运算符

优先级	名称	符号	说明
14	赋值运算符	=	双目运算符,具有右结合性
14	除后赋值运算符	/=	双目运算符,具有右结合性
14	乘后赋值运算符 (模运算符)	*=	双目运算符,具有右结合性
14	取模后赋值运算符	%=	双目运算符,具有右结合性
14	加后赋值运算符	+=	双目运算符,具有右结合性
14	减后赋值运算符	-=	双目运算符,具有右结合性

• 简单赋值运算符

#include <stdio.h>
int main(){
    // 简单的赋值运算符 =
    // 会将=右边的值赋值给左边
    int a = 10;
    printf("a = %i\n", a); // 10
}

• 复合赋值运算符

#include <stdio.h>
int main(){
     // 复合赋值运算符 += -= *= /= %=
     // 将变量中的值取出之后进行对应的操作, 操作完毕之后再重新赋值给变量
     int num1 = 10;
     // num1 = num1 + 1; num1 = 10 + 1; num1 = 11;
     num1 += 1;
     printf("num1 = %i\n", num1); // 11
     int num2 = 10;
     // num2 = num2 - 1; num2 = 10 - 1; num2 = 9;
     num2 -= 1;
     printf("num2 = %i\n", num2); // 9
     int num3 = 10;
     // num3 = num3 * 2; num3 = 10 * 2; num3 = 20;
     num3 *= 2;
     printf("num3 = %i\n", num3); // 20
     int num4 = 10;
     // num4 = num4 / 2; num4 = 10 / 2; num4 = 5;
     num4 /= 2;
     printf("num4 = %i\n", num4); // 5
     int num5 = 10;
     // num5 = num5 % 3; num5 = 10 % 3; num5 = 1;
     num5 %= 3;
     printf("num5 = %i\n", num5); // 1
}

• 结合性和优先级

#include <stdio.h>
int main(){
    int number = 10;
    // 赋值运算符优先级是14, 普通运算符优先级是3和4, 所以先计算普通运算符
    // 普通运算符中乘法优先级是3, 加法是4, 所以先计算乘法
    // number += 1 + 25; number += 26; number = number + 26; number = 36;
    number += 1 + 5 * 5;
    printf("number = %i\n", number); // 36
}

---

自增自减运算符

• 在程序设计中,经常遇到“i=i+1”和“i=i-1”这两种极为常用的操作。
• C语言为这种操作提供了两个更为简洁的运算符,即++和--

优先级	名称	符号	说明
2	自增运算符(在后)	i++	单目运算符,具有左结合性
2	自增运算符(在前)	++i	单目运算符,具有右结合性
2	自减运算符(在后)	i--	单目运算符,具有左结合性
2	自减运算符(在前)	--i	单目运算符,具有右结合性

---

• 自增
  • 如果只有***单个***变量, 无论++写在前面还是后面都会对变量做+1操作

#include <stdio.h>
int main(){
    int number = 10;
    number++;
    printf("number = %i\n", number); // 11
    ++number;
    printf("number = %i\n", number); // 12
}

• 如果出现在一个表达式中, 那么++写在前面和后面就会有所区别
  • 前缀表达式:++x, --x;其中x表示变量名,先完成变量的自增自减1运算,再用x的值作为表达式的值;即“先变后用”,也就是变量的值先变,再用变量的值参与运算
  • 后缀表达式:x++, x--;先用x的当前值作为表达式的值,再进行自增自减1运算。即“先用后变”,也就是先用变量的值参与运算,变量的值再进行自增自减变化

#include <stdio.h>
int main(){
    int number = 10;
    // ++在后, 先参与表达式运算, 再自增
    // 表达式运算时为: 3 + 10;
    int result = 3 + number++;
    printf("result = %i\n", result); // 13
    printf("number = %i\n", number); // 11
}

#include <stdio.h>
int main(){
    int number = 10;
    // ++在前, 先自增, 再参与表达式运算
    // 表达式运算时为: 3 + 11;
    int result = 3 + ++number;
    printf("result = %i\n", result); // 14
    printf("number = %i\n", number); // 11
}

• 自减

#include <stdio.h>
int main(){
    int number = 10;
    // --在后, 先参与表达式运算, 再自减
    // 表达式运算时为: 10 + 3;
    int result = number-- + 3;
    printf("result = %i\n", result); // 13
    printf("number = %i\n", number); // 9
}

#include <stdio.h>
int main(){
    int number = 10;
    // --在前, 先自减, 再参与表达式运算
    // 表达式运算时为: 9 + 3;
    int result = --number + 3;
    printf("result = %i\n", result); // 12
    printf("number = %i\n", number); // 9
}

• 注意点:
  • 错误用法:++(a+b); 5++;
  • 自增、自减运算只能用于单个变量,只要是标准类型的变量,不管是整型、实型,还是字符型变量等,但不能用于表达式或常量
  • 企业开发中尽量让++ -- 单独出现, 尽量不要和其它运算符混合在一起

int i = 10;
int b = i++; // 不推荐
或者
int b = ++i; // 不推荐
或者
int a = 10;
int b = ++a + a++;  // 不推荐

• 请用如下代码替代

int i = 10;
int b = i; // 推荐
i++;
或者;
i++;
int b = i; // 推荐
或者
int a = 10;
++a;
int b = a + a; // 推荐
a++;

• C语言标准没有明确的规定，同一个表达式中同一个变量自增或自减后如何运算, 不同编译器得到结果也不同, 在企业开发中千万不要这样写

    int a = 1;
    // 下列代码利用Qt运行时6, 利用Xcode运行是5
    // 但是无论如何, 最终a的值都是3
   //  在C语言中这种代码没有意义, 不用深究也不要这样写
   // 特点: 参与运算的是同一个变量, 参与运算时都做了自增自减操作, 并且在同一个表达式中
    int b = ++a + ++a;
    printf("b = %i\n", b); 

---

sizeof运算符

• sizeof可以用来计算一个变量或常量、数据类型所占的内存字节数
  • 标准格式: sizeof(常量 or 变量);
• sizeof的几种形式
  • sizeof(float);
  • 如果是数据类型不能省略括号
  • sizeof 10;
  • char c = 'a'; sizeof c;
  • sizeof(10);
  • char c = 'a'; sizeof(c);
  • sizeof( 变量\常量 );
  • sizeof 变量\常量;
  • sizeof( 数据类型);
• sizeof面试题:
  • sizeof()和+=、*=一样是一个复合运算符, 由sizeof和()两个部分组成, 但是代表的是一个整体
  • 所以sizeof不是一个函数, 是一个运算符, 该运算符的优先级是2

#include <stdio.h>
int main(){
    int a = 10;
    double b = 3.14;
    // 由于sizeof的优先级比+号高, 所以会先计算sizeof(a);
    // a是int类型, 所以占4个字节得到结果4
    // 然后再利用计算结果和b相加, 4 + 3.14 = 7.14
    double res = sizeof a+b;
    printf("res = %lf\n", res); // 7.14
}

---

逗号运算符

• 在C语言中逗号“,”也是一种运算符,称为逗号运算符。其功能是把多个表达式连接起来组成一个表达式,称为逗号表达式
• 逗号运算符会从左至右依次取出每个表达式的值, 最后整个逗号表达式的值等于最后一个表达式的值
• 格式:表达式1，表达式2，… …，表达式n;

• 例如:int result = a+1,b=3*4;

#include <stdio.h>
int main(){
    int a = 10, b = 20, c;
    // ()优先级高于逗号运算符和赋值运算符, 所以先计算()中的内容
    // c = (11, 21);
    // ()中是一个逗号表达式, 结果是最后一个表达式的值, 所以计算结果为21
    // 将逗号表达式的结果赋值给c, 所以c的结果是21
    c = (a + 1, b + 1);
    printf("c = %i\n", c); // 21
}

---

关系运算符

• 为什么要学习关系运算符

• 默认情况下，我们在程序中写的每一句正确代码都会被执行。但很多时候，我们想在某个条件成立的情况下才执行某一段代码
• 这种情况的话可以使用条件语句来完成，但是学习条件语句之前，我们先来看一些更基础的知识：如何判断一个条件是否成立

---

• C语言中的真假性

• 在C语言中，条件成立称为“真”，条件不成立称为“假”，因此，判断条件是否成立，就是判断条件的“真假”
• 怎么判断真假呢？C语言规定，任何数值都有真假性，任何非0值都为“真”，只有0才为“假”。也就是说，108、-18、4.5、-10.5等都是“真”，0则是“假”
  

---

• 关系运算符的运算结果只有2种：如果条件成立，结果就为1，也就是“真”；如果条件不成立，结果就为0，也就是“假”

优先级	名称	符号	说明
6	大于运算符	>	双目运算符,具有左结合性
6	小于运算符	<	双目运算符,具有左结合性
6	大于等于运算符	>=	双目运算符,具有左结合性
6	小于等于运算符	<=	双目运算符,具有左结合性
7	等于运算符	==	双目运算符,具有左结合性
7	不等于运算符	!=	双目运算符,具有左结合性

#include <stdio.h>
int main(){
    int result = 10 > 5;
    printf("result = %i\n", result); // 1
    result = 5 < 10;
    printf("result = %i\n", result); // 1
    result = 5 > 10;
    printf("result = %i\n", result); // 0
    result = 10 >= 10;
    printf("result = %i\n", result); // 1
    result = 10 <= 10;
    printf("result = %i\n", result); // 1
    result = 10 == 10;
    printf("result = %i\n", result); // 1
    result = 10 != 9;
    printf("result = %i\n", result); // 1
}

• 优先级和结合性

#include <stdio.h>
int main(){
    // == 优先级 小于 >, 所以先计算>
    // result = 10 == 1; result = 0;
    int result = 10 == 5 > 3;
    printf("result = %i\n", result); // 0
}

#include <stdio.h>
int main(){
    // == 和 != 优先级一样, 所以按照结合性
    // 关系运算符是左结合性, 所以从左至右计算
    // result = 0 != 3; result = 1;
    int result = 10 == 5 != 3;
    printf("result = %i\n", result); // 1
}

• 练习: 计算result的结果

int result1 = 3 > 4 + 7
int result2 = (3>4) + 7
int result3 = 5 != 4 + 2 * 7 > 3 == 10

• 注意点:
  • 无论是float还是double都有精度问题, 所以一定要避免利用==判断浮点数是否相等

#include <stdio.h>
int main(){
    float a = 0.1;
    float b = a * 10 + 0.00000000001;
    double c = 1.0 + + 0.00000000001;
    printf("b = %f\n", b);
    printf("c = %f\n", c);
    int result = b == c;
    printf("result = %i\n", result); // 0
}

---

逻辑运算符

优先级	名称	符号	说明
2	逻辑非运算符	!	单目运算符,具有右结合性
11	逻辑与运算符	&&	双目运算符,具有左结合性
12	逻辑或运算符	\|\|	双目运算符,具有左结合性

• 逻辑非

• 格式:! 条件A;
• 运算结果: 真变假,假变真
• 运算过程:
  • 可以多次连续使用逻辑非运算符
  • !!!0;相当于(!(!(!0)));最终结果为1
  • 使用注意:
  • 先判断条件A是否成立，如果添加A成立, 那么结果就为0，即“假”；
  • 如果条件A不成立，结果就为1，即“真”

#include <stdio.h>
int main(){
    // ()优先级高, 先计算()里面的内容
    // 10==10为真, 所以result = !(1);
    // !代表真变假, 假变真,所以结果是假0
    int result = !(10 == 10);
    printf("result = %i\n", result); // 0
}

---

• 逻辑与
  • "条件A"为假, "条件B"不会被执行
  • 使用注意:
  • 总是先判断"条件A"是否成立
  • 如果"条件A"成立，接着再判断"条件B"是否成立, 如果"条件B"也成立，结果就为1，即“真”
  • 如果"条件A"成立，"条件B"不成立，结果就为0，即“假”
  • 如果"条件A"不成立，不会再去判断"条件B"是否成立, 因为逻辑与只要一个不为真结果都不为真
  • 格式:条件A && 条件B;
  • 运算结果:一假则假
  • 运算过程:

#include <stdio.h>
int main(){
    //               真     &&    真
    int result = (10 == 10) && (5 != 1);
    printf("result = %i\n", result); // 1
    //          假     &&    真
    result = (10 == 9) && (5 != 1);
    printf("result = %i\n", result); // 0
    //          真     &&    假
    result = (10 == 10) && (5 != 5);
    printf("result = %i\n", result); // 0
    //          假     &&    假
    result = (10 == 9) && (5 != 5);
    printf("result = %i\n", result); // 0
}

#include <stdio.h>
int main(){
    int a = 10;
    int b = 20;
    // 逻辑与, 前面为假, 不会继续执行后面
    int result = (a == 9) && (++b);
    printf("result = %i\n", result); // 1
    printf("b = %i\n", b); // 20
}

---

• 逻辑或
  • "条件A"为真, "条件B"不会被执行
  • 使用注意:
  • 总是先判断"条件A"是否成立
  • 如果"条件A"不成立，接着再判断"条件B"是否成立, 如果"条件B"成立，结果就为1，即“真”
  • 如果"条件A"不成立，"条件B"也不成立成立, 结果就为0，即“假”
  • 如果"条件A"成立, 不会再去判断"条件B"是否成立, 因为逻辑或只要一个为真结果都为真
  • 格式:条件A || 条件B;
  • 运算结果:一真则真
  • 运算过程:

#include <stdio.h>
int main(){
    //               真     ||    真
    int result = (10 == 10) || (5 != 1);
    printf("result = %i\n", result); // 1
    //          假     ||    真
    result = (10 == 9) || (5 != 1);
    printf("result = %i\n", result); // 1
    //          真     ||    假
    result = (10 == 10) || (5 != 5);
    printf("result = %i\n", result); // 1
    //          假     ||    假
    result = (10 == 9) || (5 != 5);
    printf("result = %i\n", result); // 0
}

#include <stdio.h>
int main(){
    int a = 10;
    int b = 20;
    // 逻辑或, 前面为真, 不会继续执行后面
    int result = (a == 10) || (++b);
    printf("result = %i\n", result); // 1
    printf("b = %i\n", b); // 20
}

• 练习: 计算result的结果

int result = 3>5 || 2<4 && 6<1;

---

三目运算符

• 三目运算符，它需要3个数据或表达式构成条件表达式
• 格式:表达式1？表达式2(结果A)：表达式3(结果B)

• 示例:考试及格 ? 及格 : 不及格;
  

• 求值规则:

• 如果"表达式1"为真，三目运算符的运算结果为"表达式2"的值(结果A)，否则为"表达式3"的值(结果B)

示例:
    int a = 10;
    int b = 20;
    int max = (a > b) ? a : b;
    printf("max = %d", max);
    输出结果: 20
等价于:
    int a = 10;
    int b = 20;
    int max = 0;
    if(a>b){
      max=a;
    }else {
       max=b;
    }
    printf("max = %d", max);

• 注意点

• 条件运算符的运算优先级低于关系运算符和算术运算符,但高于赋值符
• 条件运算符?和:是一个整体,不能分开使用

#include <stdio.h>
int main(){
    int a = 10;
    int b = 5;
    // 先计算 a > b
    // 然后再根据计算结果判定返回a还是b
    // 相当于int max= (a>b) ? a : b;
    int max= a>b ? a : b;
    printf("max = %i\n", max); // 10
}

#include <stdio.h>
int main(){
    int a = 10;
    int b = 5;
    int c = 20;
    int d = 10;
    // 结合性是从右至左, 所以会先计算:后面的内容
    // int res = a>b?a:(c>d?c:d);
    // int res = a>b?a:(20>10?20:10);
    // int res = a>b?a:(20);
    // 然后再计算最终的结果
    // int res = 10>5?10:(20);
    // int res = 10;
    int res = a>b?a:c>d?c:d;
    printf("res = %i\n", res);
}

---

类型转换

强制类型转换(显示转换)	自动类型转换(隐式转换)
(需要转换的类型)(表达式)	1.算数转换 2.赋值转换

• 强制类型转换(显示转换)

// 将double转换为int
int a = (int)10.5;

• 算数转换
  • 系统会自动对占用内存较少的类型做一个“自动类型提升”的操作, 先将其转换为当前算数表达式中占用内存高的类型, 然后再参与运算

// 当前表达式用1.0占用8个字节, 2占用4个字节
// 所以会先将整数类型2转换为double类型之后再计算
double b = 1.0 / 2;

• 赋值转换

// 赋值时左边是什么类型,就会自动将右边转换为什么类型再保存
int a = 10.6;

• 注意点:

• 参与计算的是什么类型, 结果就是什么类型

// 结果为0, 因为参与运算的都是整型
double a = (double)(1 / 2);
// 结果为0.5, 因为1被强制转换为了double类型, 2也会被自动提升为double类型
double b = (double)1 / 2;

• 类型转换并不会影响到原有变量的值

#include <stdio.h>
int main(){
    double d = 3.14;
    int num = (int)d;
    printf("num = %i\n", num); // 3
    printf("d = %lf\n", d); // 3.140000
}

---

阶段练习

• 从键盘输入一个整数, 判断这个数是否是100到200之间的数
• 表达式 6＝＝6＝＝6 的值是多少？
• 用户从键盘上输入三个整数,找出最大值,然后输入最大值
• 用两种方式交换两个变量的保存的值

交换前
int a = 10; int b = 20;
交换后
int a = 20; int b = 10;

---

流程控制基本概念

• 默认情况下程序运行后，系统会按书写顺序从上至下依次执行程序中的每一行代码。但是这并不能满足我们所有的开发需求, 为了方便我们控制程序的运行流程，C语言提供3种流程控制结构，不同的流程控制结构可以实现不同的运行流程。
• 这3种流程结构分别是顺序结构、选择结构、循环结构
• 顺序结构:

• 按书写顺序从上至下依次执行
  

• 选择结构

• 对给定的条件进行判断，再根据判断结果来决定执行代码
  
  

• 循环结构

• 在给定条件成立的情况下，反复执行某一段代码
  
  

---

选择结构

• C语言中提供了两大选择结构, 分别是if和switch

  选择结构if

• if第一种形式
  • 表示如果表达式为真,执行语句块1,否则不执行

if(表达式) {
  语句块1;
}
后续语句;

if(age >= 18) {
  printf("开网卡\n");
}
printf("买烟\n");

• if第二种形式
  • 如果表达式为真,则执行语句块1,否则执行语句块2
  • else不能脱离if单独使用

if(表达式){
  语句块1;
}else{
  语句块2;
}
后续语句;

if(age > 18){
  printf("开网卡\n");
}else{
  printf("喊家长来开\n");
}
printf("买烟\n");

• if第三种形式
  • 如果"表达式1"为真,则执行"语句块1",否则判断"表达式2",如果为真执行"语句块2",否则再判断"表达式3",如果真执行"语句块3", 当表达式1、2、3都不满足,会执行最后一个else语句
  • 众多大括号中,只有一个大括号中的内容会被执行
  • 只有前面所有添加都不满足, 才会执行else大括号中的内容

if(表达式1) {
  语句块1;
}else if(表达式2){
  语句块2;
}else if(表达式3){
  语句块3;
}else{
  语句块4;
}
后续语句;

if(age>40){
  printf("给房卡");
}else if(age>25){
  printf("给名片");
}else if(age>18){
   printf("给网卡");
}else{
  printf("给好人卡");
}
printf("买烟\n");

• if嵌套
  • if中可以继续嵌套if, else中也可以继续嵌套if

if(表达式1){
    语句块1;
   if(表达式2){
      语句块2;
  }
}else{
   if(表达式3){
      语句块3;
  }else{
      语句块4;
  }
}

---

• if注意点
  • 任何数值都有真假性

#include <stdio.h>
int main(){
    if(0){
        printf("执行了if");
    }else{
        printf("执行了else"); // 被执行
    }
}

• 当if else后面只有一条语句时, if else后面的大括号可以省略

    // 极其不推荐写法
    int age = 17;
    if (age >= 18)
        printf("开网卡\n");
    else
        printf("喊家长来开\n");

• 当if else后面的大括号被省略时, else会自动和距离最近的一个if匹配

#include <stdio.h>
int main(){
    if(0)
    if(1)
    printf("A\n");
    else // 和if(1)匹配
    printf("B\n");
    else // 和if(0)匹配, 因为if(1)已经被匹配过了
    if (1)
    printf("C\n"); // 输出C
    else // 和if(1)匹配
    printf("D\n");
}

• • 如果if else省略了大括号, 那么后面不能定义变量

#include <stdio.h>
int main(){
    if(1)
        int number = 10; // 系统会报错
    printf("number = %i\n", number);
}

#include <stdio.h>
int main(){
    if(0){
        int number = 10; 
    }else
        int value = 20; // 系统会报错
    printf("value = %i\n", value);
}

• C语言中分号(;)也是一条语句, 称之为空语句

// 因为if(10 > 2)后面有一个分号, 所以系统会认为if省略了大括号
// if省略大括号时只能管控紧随其后的那条语句, 所以只能管控分号
if(10 > 2);
{
printf("10 > 2");
}
// 输出结果: 10 > 2

• 但凡遇到比较一个变量等于或者不等于某一个常量的时候，把常量写在前面

#include <stdio.h>
int main(){
    int a = 8;
//    if(a = 10){// 错误写法, 但不会报错
    if (10 == a){
      printf("a的值是10\n");
    }else{
     printf("a的值不是10\n");
    }
}

---

• if练习
  • 从键盘输入一个整数，判断其是否是偶数，如果是偶数就输出YES，否则输出NO；
  • 接收用户输入的1～7的整数，根据用户输入的整数，输出对应的星期几
  • 接收用户输入的一个整数month代表月份，根据月份输出对应的季节
  • 接收用户输入的两个整数，判断大小后输出较大的那个数
  • 接收用户输入的三个整数，判断大小后输出较大的那个数
  • 接收用户输入的三个整数，排序后输出
• 实现石头剪刀布

剪刀石头布游戏:
1)定义游戏规则
  剪刀 干掉 布
  石头 干掉 剪刀
  布 干掉石头
2)显示玩家开始猜拳
3)接收玩家输入的内容
4)让电脑随机产生一种拳
5)判断比较
(1)玩家赢的情况(显示玩家赢了)
(2)电脑赢的情况(显示电脑赢了)
(3)平局(显示平局)

CDSY,CDSY.XYZ