Day 1【easy】
环境搭建：
1、软件安装列表
1、Source Insight 4.0: 代码编辑软件【企业常用】
2、VMware Workstation: 虚拟机【用软件模拟硬件设备】
3、FeiQ: 局域网聊天软件
4、VNC: 局域网视频共享软件
软件资源: 夸克网盘
2、软件配置
1、Source Insight 4.0
(一)、注意破解流程
(二)、打开代码行提示：View ——> Line Numbers
2、VMware Workstation
1、打开虚拟机
step1:
step2:
2、设置共享文件夹
step1:
step2:
step3:
在Ubuntu终端 输入
cd /mnt/hgfs/
检查是否有自己设置的文件夹
相关知识点：
1、Linux的基本相关操作
1、cd 命令【切换目录】
格式：cd 目标目录
特殊用法：
1、 ./ 当前文件夹
2、 ../ 上一级文件夹
3、 ~ 工作目录
4、 - 上一次访问的文件夹
-----------------------------------------------------------------------------------------------------
2、rm 命令【删除功能】
格式：rm 目标文件名
特殊用法：
1、*通配符 经常与rm一起连用：rm *
-----------------------------------------------------------------------------------------------------
3、Tab 快捷键【补齐】
-----------------------------------------------------------------------------------------------------
4、clear 命令【清屏】
练习作业：
1、练习
练习1：
完成第一个C文件从编写 ——> 编译 ——> 运行的整个过程【要求代码编写在Windows, 编译运行在Ubuntu】
练习2：
熟悉printf() 和 scanf() 的操作：输入a b;要求输出 a + b == a+b
2、作业
作业1：
求出1000以内的奇数之和【要求代码编写在Windows, 编译运行在Ubuntu】
拓展思考：
(一) #include<> 和 #include" "的区别
1、前者一般为标准头文件，后者一般为非标准头文件
2、前者先到标准函数库寻找，后者先到当前目录寻找，再到标准函数库寻找
(二) 汇编过程中的错误
1、词法错误：指非法字符或拼写错关键字、标识符等
2、语法错误：指语法结构出错，如少分号、括号不匹配等
3、语义错误：
类型不一致、参数不匹配等 (静态)
死循环、变量为零时作除数等 (动态)
(三) C语言从编写 ——> 编译 ——> 运行的详细过程
1、编写：产生源文件【c文件】
2、编译：
(一)、预处理：先处理伪指令(以#开头的指令)和特殊符号
(二)、编译【s文件】：将c文件生成s文件，并且进行词法、语法、语义分析
(三)、汇编【目标文件】：将s文件生成目标文件(机器码【二进制】)
目标文件内容至少有：
1、代码段
2、数据段
(四)、优化(不是每个机器都会优化代码)：简化目标文件，减少运行时间和空间
3、连接：
(一)、地址和符号解释：
(二)、重定位：
(三)、库文件连接【可执行文件】
1、静态链接：
2、动态链接：
Day 2【hard】
相关知识点：
1、数据类型的分类
基本类型【系统分配的大小是固定的】
1、整型
| 类型 | 大小 |
|---|---|
| 短整型(short) | 2Byte |
| 整型 (int) | 4Byte |
| 长整型(long) | 【32位处理器】Byte 4 /【64位处理器】Byte 8 |
>（一） 整型常量
| 类型 | 表达方式 | 格式符 |
|---|---|---|
| 10进制 | %d(有符号) / %u(无符号) | |
| 8进制 | 以”0“开头 | %o |
| 16进制 | 以”0X“开头 | %x |
2、实型（浮点型）
| 类型 | 大小 | 格式符 |
|---|---|---|
| 单精度实型(float) | 4Byte | %f |
| 双精度实型(double) | 8Byte | %lf |
>（一） 浮点数在CPU当中的存储规则
注意：不是所有的小数都能存储(如0.1),只能存储其的近似值
3、字符型（本质就是一个小于255的整数）
| 类型 | 大小 | 格式符 |
|---|---|---|
| 字符型(char) | 1Byte | %c |
>（一） 常见字符（如果想查看全部的ASCII，可在Linux中输入： man ascii 指令）
1、'\n' 换行
2、'\t' 对齐
3、'\r' 回到段落开头
4、'\' 转义字符
5、'\b' 删除前一个字符
6、'\\' \ 字符
7、'%%' % 字符
8、'\ddd' ddd 8进制对于的数据
9、'\xdd' dd 16进制对于的数据
4、数据的取值范围计算【对于每个基本类型都适用】：
1、原码、反码、补码
>正数：
原码、反码、补码是一致的
>负数：
例：8 （在32位处理器中时）
原码： 0000 0000 0000 0000 0000 0000 0000 1000
反码： 0111 1111 1111 1111 1111 1111 1111 0111 【除符号位之外，其余位取反】
补码： 0111 1111 1111 1111 1111 1111 1111 1000 【将补码 +1】
------------------------------------------------------------------------------------------------------
2、数据取值范围知识点【以short为例】
(一) 计算过程
short的范围：-128 ~ 127
负数范围：1111 1111 ~ 1000 0001 ----> 【-(2^7 - 1) ~ -1】
正数范围：0000 0001 ~ 0111 1111 ----> 【1 ~ (2^7 - 1)】
两个特殊部分：
0000 0000 "0"
1000 0000 "-128" ----> -2^7
所以整个部分取值范围部分就是：-128 ~ 127
同理，可推出其他数据类型的取值范围
(二)当超出范围时，则会从该数据类型的最小值开始【轮回】
构造类型【系统无法分配指定的大小，由用户决定。此内容重要】
1、数组类型
2、结构体类型
3、联合类型
4、枚举类型
指针类型【非常重要！！！】
空类型 (void)
2、常量和变量
1、常量【在代码运行时不能实时改变】
------------------------------------------------------------------------------------------------------
2、变量【内存中具有特定属性的存储单元，用于存放数据，可在运行中改变】
(一) 分配的空间由数据类型进行规定
(二) 变量名和其对应单元的首地址可以有联系
------------------------------------------------------------------------------------------------------
3、常变量（具有保护作用，防止误操作）【在初始化之后不能再次赋值】
常见的例子：const int a; // 初始化之后不能赋值
拓展部分：
1、auto 在我们的程序中基本看不到，一般在定义局部变量时都自动省略了
2、const 也就是read only，只读，不可写，若定义时未初始化，会被编译器自动初始化为0。const 量一般在main函数外部定义，若在子函数内部定义，则main函数无法调用该变量。
3、register 定义一个寄存器变量，让该变量的访问速度达到最快。当要非常频繁的调用一个变量时，可以定义为寄存器变量
4、extern extern用来声明在当前文件中引用的变量在是其它文件中定义的全局变量。
5、static 静态变量，静态变量存储在静态区，定义时未初始化，会被编译器自动初始化为0，且只会被初始化一次。
3、数据类型的定义
定义格式
数据类型 变量名
例如：int a;
标识符[变量名]规则与规范
1、规则
· 不能与关键字同名
· 只能由数字、字母、下划线组成
· 不能以数字开头
------------------------------------------------------------------------------------------------------
2、规范
· 驼峰命名法 int StudentAge;
· 下划线间隔法 int student_age;
变量操作（读/写）【其中左值和右值的概念在指针中非常重要】
1、读操作：
> 通过变量名找到对应地址内部的参数（本质是找参数），此时的变量被称作【右值】
2、写操作：
> 通过变量名找到对应的地址（本质是找地址），此时的变量被称作【左值】
注意：特别重要的写操作：初始化(变量的第一次赋值)【很重要，不可偷懒】
4、类型转换
不管是什么数据类型，数据在CPU存储、运算中总是以（二进制补码）存在【这个观点非常重要！！！】
（一）有符号与无符号
1、决定对应数据最高位是否是符号位：（其中“1”代表负数，0”代表正数）
2、【以32位寄存器为例】当变量数据小于32位时，拷贝到寄存器后分情况讨论：
(一)、有符号位时，用符号位补充高位
(二)、无符号位时，用 "0"补充高位
（二）长字节与短字节
1、长字节 ——> 短字节
只需要按短字节空间截取低位
2、短字节 ——> 长字节
注意数据有误符号位，可以参考上述内容进行操作
练习作业：
1、练习
练习1(关于浮点数与0的判断)【非常重要！！！】：
void test1()
{
float a = -1;
while (1)
{
printf("%f\r",a);
a += 0.1;
sleep(1);
/*
刷新输出缓存区，将刷新缓存区的数据直接输出
输出的情况：
1、当存在回车'\n'时，直接输出
2、当输出缓存区满了时，自动输出
*/
fflush(stdout);
if(-ESP<=a && a<=ESP)
{
printf("a值近似为0\n");
break;
}
}
}
练习2(字符小练习1)：
void test2()
{
printf("\t\141 \x62 c %c\n",'d');
}
练习3(字符小练习2)：
void test3()
{
char c;
c = getchar();//从键盘上获取一个字符存放在变量c中
putchar(c);//把指定的字符输出到终端上
putchar('a');
putchar(97);
putchar(c+2);
putchar('\n');
}
练习4(字符串小练习)：
void test4()
{
printf("i like %s\n","zhoujielun");
}
2、作业【非常重要！！！】
请解释下列表达式在CPU运行时的详细过程【考点：有无符号和长短字节数据的转换】
作业1：
unsigned char c = 250;
char d;
d = c + 8;
printf ("%d %u\n",d,d);
作业2：
char c = 250;
int d;
d = c + 8;
printf ("%d %u\n",d,d);
作业3：
unsigned char c = 250;
int d;
d = c + 8;
printf ("%d %u\n",d,d);
拓展思考：
（一）大端与小端
大端：高地址存低字节，低地址存高字节
小端：低地址存低字节，高地址存高字节
人类读写数据习惯是大端字节序，大数据先读，小数据后读。所以小端是反人类的方式
（二）数据类型强转【例如：(int) a】与格式符【例如：%d】的区别
1、数据类型强转：是将a变量的原本存储的规则进行改变【会改变存储在计算机里的数据】
2、格式符：是将存储在计算机里的a变量，以指定的形式进行输出【不会改变存储在计算机里的数据】
此处建议结合
float a = 1; int b = 1;
在计算机存储的形式的差异性(结合上述描述的浮点数)
（三）输入[scanf]输出[printf]缓存区
背景：由于计算机设备处理时间给有不同，所以就会有输入输出的缓存区来暂时缓存数值，最后一起输出输入
只有以下5种情况可以输出缓存区的值【针对输出缓存区printf较多】
1、当填满缓存区时，自动输出
2、当缓存区遇到换行‘\n’时，自动输出
3、程序运行结束
4、手动输出输出缓存区：fflush(stdout)；
5、遇到scanf时，自动输出
（四）小数二进制转化
【注意：如果二进制不能正好存储小数部分，就要提前知道二进制的精度(保留后几位)】
例题1:
求0.8124的二进制，保留后6位
求法：
0.8125 * 2 = 1.6248 ·············· 取整数部分1，将小数部分继续相同操作
0.6248 * 2 = 1.2496 ·············· 取整数部分1，将小数部分继续相同操作
0.2496 * 2 = 0.4992 ·············· 取整数部分0，将小数部分继续相同操作
0.4992 * 2 = 0.9984 ·············· 取整数部分0，将小数部分继续相同操作
0.9984 * 2 = 1.9968 ·············· 取整数部分1，将小数部分继续相同操作
0.9968 * 2 = 1.9936 ·············· 取整数部分1，精度达标，停止操作
最后【从上向下排列】(这里与整数部分求二进制不同)
结果：0.110011
例题2:
求0.8125的二进制
求法：
0.8124 * 2 = 1.6250 ·············· 取整数部分1，将小数部分继续相同操作
0.6250 * 2 = 1.2500 ·············· 取整数部分1，将小数部分继续相同操作
0.2500 * 2 = 0.5000 ·············· 取整数部分0，将小数部分继续相同操作
0.5000 * 2 = 1.0000 ·············· 取整数部分1，将小数部分为0，停止操作
最后【从上向下排列】(这里与整数部分求二进制不同)
结果：0.1101
（五）代码存储的位置【内存分段】
【与操作系统的分段管理系统有很大的关系】
作用：
1、简化链接和装载过程
由于程序被划分为不同的段，链接和装载变得更为灵活。程序的不同部分可以独立地被装载和管理。
2、保护和安全
分段提供了内存保护机制。操作系统可以设定不同的访问权限（如只读、可写）给不同的段，从而提高程序的安全性。
3、共享和隔离
不同程序或进程可以共享相同的段（如代码段），同时保持数据的隔离。
4、动态增长
某些段（如堆栈和堆）可以动态增长，这为动态内存分配提供了便利。
--------------------------------------------------------------------------------------------------------------------------------------
常见的内存分段：【从低地址到高地址】
(一) 代码段(文本段)：这个段包含程序的【可执行代码】。它通常是【只读】的，以防止程序代码被意外修改。
(二) 常量段：有些系统可能设置一个专门的常量段，用于存储【常量值，如字符串字面量】等。这个段通常是【只读】的。
(三) 数据段：用于存储程序【初始化的】全局变量和静态变量。
(四) BSS段：用于存放程序【未初始化的】全局变量和静态变量。在程序开始执行之前，这个段中的数据通常被初始化为零。
(五) 堆段：堆段用于动态内存分配，即程序运行时请求和释放的内存。
(六) 共享段：【允许不同的进程共享相同的内存区域】，这对于进程间通信非常有用
(七) 栈段：栈段用于支持函数调用时的参数传递、局部变量存储以及函数调用的返回地址。通常不用释放，自动回收。
Day 3【hard】
相关知识点：
表达式(用来表示某个意识的公式，用运算符连接操作数)
例：c = a + b; 【整体被称作语句，";"之前的部分被称作表达式】
运算符
（一）算术运算符【双目运算符，结合性：左 —> 右】
+(加法)、-(减法)、*（乘法）、/（除法）、%（取余）
重点
1、"/" 部分：
(一) 整数 / 整数 = 整数 【如果想得从低精度到高精度结果 --> 需要高精度数据参与计算，如：(0.1)*4/3 = 1.33333】
(二) 小数 / 整数 = 小数
2、"%" 部分：（左右皆为整数，且被除余数不可为“0”）
【常见例题】
(一) 5%3 = 2
(二) 2%3 = 2
(三) -5%2 = -1
(四) 5%-2 = 1
(五) -5%-2 = -1
（二）关系运算符【双目运算符，结合性：左 —> 右】
由关系运算符连接操作符所形成的式子被称作【关系表达式】
>(大于)、>=(大于等于)、<(小于)、<=(小于等于)、==(等于)、!=(不等于)
易错点：
printf("%d",(5>4>3));
结果：
0
分析：
先进行 5 > 4 计算 结果为 “1”
再进行 1 > 3 计算 结果为 “0”
（三）逻辑运算符
!(逻辑非【单目】)、&&(逻辑与【双目】)、&(逻辑与【双目】)、||(逻辑或【双目】)、|(逻辑或【双目】)
易错点：
(一) 关于 && 和 || 的“惰性运算” ，而对于 & 和 | 来说就都得进行运算
如果 [&& / ||] 之前就已经能判断是 [假 / 真] ,就无需进行后面的运算
------------------------------------------------------------------------------------------------------
(二) 关于 && 和 || 优先级结合问题
例1：
int a=0,b=1,c=1;
int d=a&&(b=b-1)||(c=c-1);
printf("%d %d %d %d",a,b,c,d);
结果：
0 1 0 0
分析：
a: a本身为0
b: 由于 && 前的结果为0，所以不会进行b=b-1的计算，b为原值1
c: 由于 || 前的结果为0，所以会进行c=c-1的计算，c为0
d: 由于 0 || 0 的结果为0，所以d为0
---------------------------------------------------------------------------------
例2：
int a=2,b=1,c=2;
int d=(c=c-1)||(a=a-1)&&(b=b-1);
printf("%d %d %d %d",a,b,c,d);
结果：
2 1 1 1
分析：
由于 && 的 优先级略高于 || ，则需要看作：(c=c-1)||【(a=a-1)&&(b=b-1)】; ——> x ||【y】
a:由于 || 前的结果为1，导致后面过程没有计算，a为2
b:由于 || 前的结果为1，导致后面过程没有计算，b为1
c: c=c-1 ——> c为1
d: 由于 || 前的结果为1，所以d为1
个人决定注意的点：判断条件的值，是取决于表达式的运算结果，不取决于你是否存储该值
（四）位运算符
~(按位取反【单目】)、&(按位与【双目】)、|(按位或【双目】)、^(异或【双目】)、<<(左移【双目】)、>>(右移【双目】)
(一) 各符号的运用场所
& 【将指定位清零，设0】
| 【将指定位置位，设1】
^ 【将指定位取反(和1异或)】
<< 【低位补0】：其本质就是数据 * 2^移动位数
>> 【高位补零(逻辑右移) / 高位补符号位(算数右移)】
> 笔试题【很重要！！！】
例题1：有一个int变量a[31:0],写一个表达式，把a的第10位置位(置1)，其他位不变
例题2：有一个int变量a[31:0],写一个表达式，把a的第10位复位(置0)，其他位不变
例题3：有一个int变量a[31:0],写一个表达式，把a的第10位取反，其他位不变
例题4：有一个int变量a[31:0],写一个表达式，判断a的第10位是否为"1"
例题5：有一个int变量a[31:0],写一个表达式，将a[9:6]设置为“1100”
（五）赋值运算符【双目运算符，结合性：右 —> 左（特殊），优先级倒数第二】
1、常见赋值运算符：“ = ” 【左边必须是“可写的地址”】
2、常见赋值运算符：“ = ” 左右两边的数据类型必须一致【存在隐性强转】
3、符合赋值运算符：算术运算符/位运算符 + 常见赋值运算符
易错点：
a *= 3 + 5;
结果：
a = a * 8;
分析：
赋值运算符 *= 优先级小于 算数运算符 +
1、a *= 8;
2、a = a * 8;
（六）条件运算符【三目运算符，结合性：右 —> 左（特殊）】
格式：表达式1？表达式2：表达式3
求值顺序：左 ——> 右
1、如果表达式1为真，取表达式2的结果
2、如果表达式1为假，取表达式3的结果
易错点：
(一) 条件运算符也存在惰性运算情况
(二) 条件运算符结合性
（七）逗号运算符
格式：表达式1,表达式2,...,表达式n
求值顺序：左 ——> 右
最后取值是取【表达式n】的结果
（八）指针运算符
*(取值)、&(取地址)
（九）分量运算符
.(非指针结构体)、->(非指针结构体)
（十）下标运算符
[](数组下标)
（十一）强制类型转换运算符
(需要强转的类型) 例如：(int)
（十二）求字节运算符
sizeof() 【这个是运算符，而不是函数】
易错点：
例题1:
short s;
printf("%ld\n",sizeof(s+1));
结果：
4
分析：
由于 short + int ——> int【隐性类型转换】所以结果为 sizeof(int) ——> 4
------------------------------------------------------------------------------------------
例题2：
printf("%ld",sizeof('a'));
结果：
4
分析：
由于'a'没有固定的大小，所以系统默认将其视作对于的ASCII整型int
所以结果为 sizeof(int) ——> 4
（十三）自增运算符
i++、++i、i--、--i
易错点:
(一) 不可以有i=i++的表达公式【存在二义性】
(二) 在printf()中
例如：
int a = 1
printf("%d %d %d %d",++a,a++,++a,a++);
结果：
7 5 7 3
分析：(入栈问题)
【顺序：从右向左进行运算】
++a: a值加1后,先不急着输出
a++: 先输出，之后再加1
运算符的优先级和结合性总结
| 运算符 | 优先级 | 结合性 | 类型 |
|---|---|---|---|
| ( )【括号】、[ ]【下标】、. 【结构体(非指针变量)】、->【结构体(指针变量)】、(需强转的类型)【强转】 | 1 | 从左到右 | 单目运算符 |
| !【逻辑取反】、~【按位取反】、++、- -【自加自减】、+ / -【正负号】 | 2 | 算术运算符 | |
| *【乘】、/【除】、%【取余】 | 3 | 算术运算符 | |
| +【加】、-【减】 | 4 | 算术运算符 | |
| <【小于】、<=【小于等于】、>【大于】、>=【大于等于】、==【等于】、!=【不等于】 | 5 | 关系运算符 | |
| &【按位与】、^【按位异或】、|【按位或】、<<【左移】、>>【右移】 | 6 | 位运算符 | |
| &&【逻辑与】 | 7 | ||
| ||【逻辑或】 | 8 | ||
| 条件运算符 | 9 | 从右到左 | |
| 赋值运算符 | 10 | 从右到左 | |
| 逗号运算符 | 11 |
运算过程：(1)先考虑优先级 (2)再考虑结合性 (3)最后注意惰性运算
大致优先级排序：括号>单目>算术>关系>位运算>&&>||>赋值
练习作业：
1、作业
作业1：
输入不超过5位数的整数，判断是几位数
作业2：
输入对于整数的反数，如"123" <——> "321"
作业3：
1、若有定义：int a=11; float x=2.8,y=5.7;则表在式x+a%3*(int)(x+y)%2/4的值是：
解：
step1: x+a%3*8%2/4
step2: x+0
step3: 2.8 (answer)
*************************************************************************************************
2、若有定义: int a=8,b=5,c; 执行语句：c=a/b+0.4;后，c的值是：
解：
step1: 1+0.4
step2: 1 (answer)
*************************************************************************************************
3、已有定义：int x=3; 则表达式：x=x+1.78的值是
解：
step1: 3+1.78
step2: 4 (answer)
*************************************************************************************************
4、已有定义：float f=13.8;,则表达式:(int)f/3的值是
解：
step1: 13/3
step2: 4 (answer)
*************************************************************************************************
5、已有定义：double x=3.5; 则表达式：x=(int)x+1的值是
解：
step1: 3+1
step2: 4.0 (answer)
*************************************************************************************************
6、已有定义：int x=10, y=3,z; ，则表达式：z=(x%y, x/y)的值是
解：
step1: 10/3
step2: 3 (answer)
*************************************************************************************************
7、已有定义：int x=0,y=0;，则计算表达式：(x=x+2,y=x+3/2,y+5)后，表达式的值是：____，变量x的值是：____
解：
step1: x=x+2 ————> x=2 (answer2)
step2: y+5 ————> 8 (answer1)
*************************************************************************************************
8、若x,i,j和k都是int型变量，则执行表达式x=(i=4,j=16,k=32)后，x 的值为：____
解：
step1: 32 (answer)
*************************************************************************************************
9、设变量a是int型，f是float型，i是double型，则表达式10+'a'+i*f 值的数据类型为：
解：
step1: 最高精度数据类型为double类型 (answer)
*************************************************************************************************
10、若有语句：
int x=12,y=8,z;
z=0.8+x/y;
则执行语句后，z的值为：
解：
step1: 12.8/8=1.6
step2: 1 (answer)
*************************************************************************************************
11、若“int a; float b=12.2；”，则执行“a=(int)b%3;”后，a的值是：
解：
step1: 12%3
step2: 0 (answer)
*************************************************************************************************
12、假设所有变量均为整型，则表达式(a=2,b=5,b++,a+b)的值是
解：
step1: b++ ————> b=6
step2: a+b = 8 (answer)
*************************************************************************************************
13、若有定义句语：int s=6; 则表达式s%2+(s+1)%2的值为
解：
step1: s+1 ————> 7
step2: s%2 ————> 0
step3: 7%2 ————> 1
step4: 0+1 ————> 1 (answer)
*************************************************************************************************
14、设a,b均为double型，且a=5.5;b=25;则表达式(int)a+b/b的值是：
解：
step1: b/b —————> 1.0
step2: a+1.0 —————> 6.0 (answer)
*************************************************************************************************
Day 4 + Day 5【easy】
相关知识点：
三大结构：顺序、选择(分支)、循环
(一) 顺序：
C语言代码运行时的基本运行顺序
(二) 选择(分支)：
1、if
格式：
if(表达式)
{
语句;
}
作用：
表达式为真(非0)，就执行语句
易错点：
if和else的配对规则：else总是和上面最近未配对的if的进行配对
--------------------------------------------------------------------------------
2、if - else
格式：
if(表达式)
{
语句1;
}
else
{
语句2;
}
作用：
表达式为真(非0)，就执行语句1，反之执行语句2
--------------------------------------------------------------------------------
3、if - elseif
格式：
if(表达式1)
{
语句1;
}
elseif(表达式2)
{
语句2;
}
...
elseif(表达式n)
{
语句n;
}
else
{
表达式(n+1)
}
作用：
如果哪个表达式符合条件，就执行对应代码块内部的语句
/* 前3者分别是if的基本类型 */
--------------------------------------------------------------------------------
4、switch
格式：
switch(表达式)
{
case 常量表达式1:
语句1
break;
case 常量表达式2:
语句2
break;
···
case 常量表达式n:
语句n
break;
default:
语句(n+1)
break;
}
作用：
可以类比if-elseif的作用
易错点：
1、表达式的值必须是：整型、字符型、枚举型(整数)
2、常量表达式的值不能有2个相同的值
3、如果表达式与其中一个表达式匹配，就运行此case以下的所有语句, 当遇到break时自动跳出
个人感受:
1、但相比if-elseif结构，个人认为switch结构更简洁，很适合写一些偏简单的条件判断
2、如菜单功能板块，非常推荐能使用switch的时候就用switch（跟函数一起打组合拳）！！！
(三) 循环：
1、while
格式：
whlie(表达式)
{
语句;
}
作用：
如果表达式结果真，就会进行一次语句
-------------------------------------------------------------------------------
2、do-while
格式：
do
{
语句;
}while(表达式);
作用：
如果表达式(合法即可)结果真，就会进行一次语句
注意:
与while不同，此结构都要先进行一次语句【无论表达式是否为真】
-------------------------------------------------------------------------------
3、for
格式：
for(表达式1; 表达式2; 表达式3)
{
语句;
}
作用：
如果符合条件判断结果为真就会进行一次语句
注意：
1、此结构的运行顺序：
(一) 无条件先执行表达式1
(二) 再判断表达式2的值，若为真，再执行循环体语句，再执行表达式3，无限循环
(三) 若为假，则直接结束for循环
2、表达式1合法即合理，表达式2有多个条件时使用 || 和 &&
-------------------------------------------------------------------------------
4、goto
格式：
goto 语句标号
注意：
"语句标号":在C语言中，把一个符号与某一行的地址相关联。格式为在某一行的开始处定义某个符号，然后再加一个冒号即可
eg:
loop:
n++;
goto loop;
作用：
(1)与if语句向上跳转构成循环结构,但是我们尽量不要使用goto去实现循环
(2)向后跳转可以跳出多重循环结构（当陷入多重循环， 想要直接跳出循环，但是又很麻烦， 可以直接使用goto）,还有linux内核驱动源码用goto跳转 到硬件的初始化是很常用的用法.
注意：
goto是无条件跳转,导致程序的可读性变差,要慎重使用goto!!并不是不能使用goto
两种结束语句：break【跳出循环】continue【提前结束本循环，开始下一个循环】
练习作业：
1、作业
作业1
输入一个正整数n,打印这个正整数的前n行
eg:
输入：
4
输出：
0
0 1
0 1 2
0 1 2 3
0 1 2 3 4
作业2
输入一个正整数，打印所有的它能够分解成连续数的形式
eg:
输入：
15
输出：
15=1+2+3+4+5
15=4+5+6
15=7+8
作业3
输入2个正整数，求两个正整数的最小公倍数和最大公约数
拓展思考：
(一) 考试错题总结
(1) 符号常量 #define【要知道符号常量就是 ☞ #define】
格式: #define 标识符 数值
经常用#define，但是不知道它叫符号常量，就很尴尬😓
(2) 表达式的判断【最后一次属于什么表达式，整个表达式则为对应表达式】
例题：
请判断下列两项表达式的类型：
1、a=(c+b,d-e)
2、a=c+b,d-e
结果：
表达式1为赋值表达式
表达式2为逗号表达式
分析：
表达式1中，先是()运算【内部的逗号运算符】，再进行赋值运算 ————> 赋值表达式
表达式2中，将a=c+b和d-e分别看作整体，所以整体形式就是【表达式1，表达式2】 ————> 赋值表达式
(3) 数据类型的常量表达方式总结
1、注意特定的格式 2、注意不要超出数据类型范围
整型
| 类型 | 表达方式 |
|---|---|
| 短整型 | 32 （注意范围） |
| 整型 | 32 |
| 长整型 | 32L |
| 8进制 | 07（以0开头，8进制没有8） |
| 16进制 | 0x11（以0x开头，16进制没有16） |
实型
| 类型 | 表达方式 |
|---|---|
| 双精度 | 4.7 |
| 单精度 | 4.7f |
字符型
| 类型 | 表达方式 |
|---|---|
| 字符 | a |
(4) 运算符的优先级【非常重要！！！】
Day3的运算符的优先级和结合性总结部分要重点记忆！！！
扫一扫
3011
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
