【保姆级讲解】C语言---初识C语言
初识C语言
1.1 C语言体系介绍
1.1.1 C语言概述
C语言是一门面向过程(分析出解决问题的步骤，一步一步解决问题)的通用的计算机高级编程语言，C语言一般用于底层硬件的驱动程序的编写，以及编写操作系统(C语言->unix系统->Linux->andriod)。
C语言高效 灵活度比较高à编写操作系统具有天然优势。C语言 汇编指令(平台不一致汇编指令不一致) C语言编写大大缩小开发周期(汇编指令);
C语言缺点:可维护性比较低、可复用性比较低;
面向对象:分析问题结局问题步骤:划分成一个一个对象处理问题;
机器人行走:按照C去写:先迈左腿，抬高30度，往前跨30度，落脚；
按照C++去写:只调用对象中的行为行走(行走行为函数:底层还是面向过程实现的)
大大节省了开发的周期;
C面向过程高级语言与C++面向对象高级语言：
C: 可维护性比较低、可复用性比较差;优势:灵活度高(适合于操作系统开发)，节省内存消耗(比较适合单片机开发:单片机内存容量比较小)
C++：可维护性比较高、可复用性比较好;缺点:灵活度降低，耗费内存空间(对象中无用的属性也需要进行开辟空间)
C++与C语言:
单一的功能/单片机开发C最占优势:更加快捷 C语言偏向于底层;
C++高级编程语言:刚开始比较慢，但是对于后期应用开发比较快;
Python也可以编程单片机:运行效率远低于C；
1.1.2 C语言程序组成与结构
- C语言编辑器&&编译器使用
- 创建一个文件夹，用来存放程序源文件，命名自定义;一般采用时间命名法:20220419
- 在这个文件夹中创建.c源文件(touch),或者gedit xxx.c创建打开源文件;
- 编写程序，写完之后ctrl+s保存代码,然后关闭C文件(ctrl+q);
- 使用编译器gcc(C语言编译器 C++编译器g++都是GNU套件(革奴计划 开源免费)中编译器)
- 具体编译步骤:gcc 要编译的文件 -o 要生成的可执行文件名
gcc 要编译的文件 默认生成文件名 a.out
编译时会出现警告或者错误:
使用”./可执行文件名”来运行编译好的可执行程序
注：如果gcc后的“-o 要生成可执行文件名“不写，默认生成a.out。
gedit编辑器首选项配置现阶段的root用户是无法实现的(由于管理员身份是临时身份);如果”虚拟机安装”手册配置成root为登录身份是可以使用gedit首选项配置的；
- C语言程序组成
主函数
main函数：是一个程序的入口地址，在程序运行时自动运行，一旦主函数运行结束，整个程序运行结束。在C语言中，主函数的名称规定了必须是“main“，编程人员不能自定义主函数名称。主函数有且只有一个。
分析: 主函数的名称规定了必须是“main“;
分析: 主函数有且只有一个
- 头文件
头文件中存放了被调用的功能函数的声明（让编译器知道有哪些函数可以使用），头文件不会被编译执行，只能在预处理中，搭配#include来使用。在C语言中每一个标准库函数都有一个对应的头文件。使用哪个就要包含对应的头文件。
函数:函数定义 函数声明 函数调用 在头文件中放:函数声明;
#表示预处理阶段(编译过程:预处理(替换) 编译(C语言编译为汇编指令) 汇编(汇编指令到二进制指令) 链接(将.c源文件编译成的.o文件进行链接)本类知识->预处理阶段)
include：包含
经常使用C库中的输入输出函数:标准库C库 使用标准输入输出函数要包含输入输出头文件
#include
<>:寻找头文件的路径，头文件在软件安装目录下进行寻找
linux寻找的路径(/usr/include/i386-linux-gnu/bits/stdio.h)
“”：寻找头文件的路径，头文件首先在工程目录下查找，如果查找不到需要通过软件安装目录进行查找;
#include “stdio.h” 寻找花费的时间大于#include
#include “stdio.h”如果你的工程目录下有stdio.h会影响编译的结果(编译出错)
| #include int main() //主函数 { printf(“hello C\n”); //函数调用语句 return 0; } Int:函数具有返回值 return 0;程序结束 0所代表的的退出状态 通知给操作系统，本进程已经结束退出状态值为0，可以进行清理程序中堆区开辟； |
- C语言程序结构
C语言运行范围
C语言程序只能在“{}“范围内执行。
- C语言语句
C语言程序的执行部分是由语句组成。程序的功能是由执行的语句实现，使用分号“;“来表示一条语句的结束。C语言语句分为：控制语句、函数调用语句、表达式语句和空语句。
控制语句:if() for() break;----------------相关章节(九条语句章节)
函数调用语句:printf(“%s\n”,”hello”)； fun(); strlen();---------相关章节(函数章节)
表达式语句:c=a+b; a++； a+=2； a=b*3;------------------相关章节(运算符章节)
- 空语句: ;分号为空语句 ; ;
1.1.3 C语言编程规范
一条语句中，不同内容之间使用空格间隔;
int A = 10；if( a > b ) 太拥挤不利于程序员阅读;
每条语句不要顶格写，使用table键自动缩进。向右缩进：Tab；向左缩进：Shif+Tab。
| #include int main() //主函数 { TAB键printf(“hello C\n”); //函数调用语句 TAB键return 0; } |
每一条语句各自占一行，大括号“{}”每个占一行
对代码进行注释，多行注释使用“/* 要注释的内容 */”，单行注释使用“//要注释的内容”
| #include /*********************************************************** 函数名称:主函数 函数功能:…. 函数参数:… 返 回 值:…. ***********************************************************/ int main() //主函数 { TAB键printf(“hello C\n”); //函数调用语句 TAB键return 0; } |
1.2嵌入式C语言主要知识点:
C语言的基本概念、C语言的基本结构和编程规范;
基本数据类型(原码反码补码 进制 基本数据类型) -------重点掌握
运算符(单目 双目运算符 三目运算符) -------重点掌握
九条语句(选择语句if switch 循环语句for while dowhile 跳转语句) -------重点掌握
32个关键字
数组(一维数组二维数组) -------重点掌握
函数(函数定义编写通用 函数声明 函数调用 库函数介绍) -------重点掌握
指针(C语言中重点 指针数组 数组指针 函数指针 指针函数等等) -------重点掌握
结构体(块 结构体成员对齐等) -------重点掌握
链表(指针与结构体结合) --------重点掌握
共用体、枚举和预处理、模块化编程 -------重点掌握
期末考试
1.2.1嵌入式C语言学习建议
先敲代码---照敲(搞懂程序逻辑)，加上自己的理解注释。-------成功了70% 不要眼高手低
自己写代码---根据题目要求去写;成功了----20%
上机调试—自己先去分析，计算你的逻辑结果，再去执行程序，对比结果.
1.2.2嵌入式C语言作业要求
每天按时完成作业早8点前需要提交
在上课的时候遇到不懂的问题及时提出，当堂解决;下课连线方式解决;
1.2.3 C语言原码、反码、补码(了解)
计算机中最小的存储单元为比特(位);计算机在存储时会按照8个比特位为一个字节进行存储，手机中的128G(所代表的的为128G字节)；一个比特位能够表示两种信息，一个字节能够表示的信息量为2^8次方个。
计算机中进行数值运算时:
数值:1+2=3算数结论:3
如果不考虑原码反码补码:1+2 = 0000 0001 +0000 0010 =0000 0011 数值为3;
数值:1-1=0算数结论:0
如果不考虑原码反码补码:1-1=0000 0001 – 0000 0001 = 0计算机中没有减法运算器(无法实现减法);减法运算器电路相当复杂;
人为规定1+(-1)操作即可:将数值符号参与到加法运算中;
人为规定:最高位为符号位:0表示正数 1表示负数
1+(-1) = 0000 0001[原码] +1000 0001[原码]=1000 0010 数值:-2 ×
当前知识不能够满足咱们以上运算；
涉及出新的知识点:反码
正数的反码与原码是一致，负数的反码是对原码按位取反，只有最高位符号位不变;
1+(-1)=0000 0001[原码]+1000 0001[原码]=0000 0001[反码]+1111 1110[反码]=1111 1111[反码]=反码到原码进行显示给使用者1000 0000[原码] = -0(根据咱们高数知识:-0等同于0)
人为理解-0与+0是一致，但是0一般不带符号(+-对0没有任何意义)
计算机识别+0或者-0是比较麻烦的过程；
涉及出新的知识点:补码
正数的补码与原码一致；负数的补码是反码+1；
1+(-1)=0000 0001[原码]+1000 0001[原码]=0000 0001[反码]+1111 1110[反码]=0000 0001[补码]+ 1111 1111[补码] = 0000 0000(最高位溢出:不要了)=0000 0000[补码与原码一致]=0算数运算为0;
通过补码运算:计算机只需要有加法运算器就OK；
补码出现，解决了0的符号:导致两种编码问题-0 +0
数值:(-1) +(-127)=-128 算数结论:
-1 +(-127)=1000 0001[原码]+1111 1111[原码]=1111 1110[反码]+1000 0000[反码]
= 1111 1111[补码]+1000 0001[补码]=1000 0000[补码]数值-0:编译器规定了-0 数值应该-128
不要造成学习的负担:直接记忆:-128
笔试:一份最多为1个原码反码补码题 题目:-2 的补码是多少?
总结:
原码:最高位为符号位，0代表正数，1代表负数，无符号的最高位会成为数据位;
反码:正数的反码与原码一致；负数的反码与原码除符号位不变其它位进行取反;
补码:正数补码与原码一致;负数的补码是该数的反码加+1;
注意*运算器由算术逻辑单元（ALU）、累加器、状态寄存器、通用寄存器组等组成。算术逻辑运算单元（ALU）的基本功能为加、减、乘、除四则运算，与、或、非、异或等逻辑操作，以及移位、求补等操作。计算机运行时，运算器的操作和操作种类由控制器决定。
1.3 进制转换(熟悉)
进制也就是进位计数制，是人为定义的带进位的计数方法
学习：二进制、八进制、十六进制
进制是学习计算机语言最基本的知识，所以一定要掌握。其实它很简单，我们日常生活中有很多进制的例子，例如：
一分钟六十秒，逢六十进一，就是六十进制；
一天二十四小时，逢二十四进一，就是二十四进制；
一星期七天，逢七进一，就是七进制；
一年十二个月，逢十二进一，就是十二进制；
小学数学是逢十进一，就是十进制；
而计算机中的数据只有 0 和 1，逢二进一，就是二进制。
1.3.1十进制转二进制/八进制/十六进制
整数部分：转 N 进制:除 N，取余，倒排
十进制转二进制/八进制/十六进制
十进制数值 21 为例:转为二进制 八进制 十六进制
| 十进制转二进制 |
十进制转八进制 |
十进制转十六进制 |
小数部分:十进制小数转二进制 八进制 十六进制 小数乘以 N，取整，小数部分继续乘以 N，取整，得到小数部分 0 为止，将整数顺序排列。
| 十进制转二进制 |
十进制转八进制 |
十进制转十六进制 |
1.3.2 二进制转八进制/十进制/十六进制
二进制转十进制方法为：把二进制数按权展开、相加即得十进制数。
二进制转八进制方法为：3 位二进制数按权展开相加得到 1 位八进制数。(注意事项，3 位二进制转成八进制 是从右到左开始转换，不足时补 0)。
二进制转十六进制方法为：与二进制转八进制方法近似，八进制是取三合一，十六进制是取四合一。(注意 事项，4 位二进制转成十六进制是从右到左开始转换，不足时补 0)。
| 二进制转十进制 |
二进制转八进制 |
二进制转十六进制 |
1.3.1 八进制转二进制/十进制/十六进制
八进制转二进制方法为：八进制数通过除 2 取余法，得到二进制数，对每个八进制为 3 个二进制，不足时在
最左边补零。
八进制转十方法为：把八进制、十六进制数按权展开、相加即得十进制数。
八进制转十六进制方法：将八进制转换为二进制，然后再将二进制转换为十六进制，小数点位置不变。
| 八进制转二进制 |
八进制转十进制 |
八进制转十六进制 |
| 八进制转为二进制: 0001 0101 二进制转十六进制: 0x15 |
1.3.4 十六进制转二进制/八进制/十进制(课间练习)
十六进制转十方法为：把八进制、十六进制数按权展开、相加即得十进制数。
| 十六进制转八进制 |
十六进制转十进制 |
十六进制转二进制 |
| 十六进制需要先转为二进制:0001 0101 通过二进制转为八进制: 025 |
1.4 C语言数据类型
1.4.1 C语言数据类型概述
数据类型主要是为了定义数据在内存中所占的空间大小（字节数）以及分配数据的存储位置以及确定其作用范围（数据大小范围）。1字=2字节 1字节=8位(1byte=8bit)
1.4.2 C语言数据类型分类
在C语言中，数据类型可以分为：基本数据类型、构造数据类型以及空类型。
基本数据类型:整型int(短整型{关键字:short}、长整型{关键字:long})、浮点型(单精度浮点型{关键字:float}、双精度浮点型{关键字:double})、字符型({关键字:char})
构造数据类型:数组、结构体、共用体、枚举、指针;
空类型:void ->(万能型指针:void*p)
整型
整型数据类型概述
整型数据是指不包含小数部分的数值型数据（例如：123、-123、567），整型数据类型使用关键字“int”来表示。C语言规定了一个“int”整型数据至少占用2个字节的空间大小，通常占用4个字节的空间。(8位16位单片机int 占2字节大小，对于32位单片机或者PC4字节空间 后期工作中在51单片机中:int数值范围)
整型数据类型分类
整型数据根据是否支持符号（正负号）形式分为：有符号类型（signed）和无符号类型（unsigned），缺省表示为有符号类型（int 等价于 signed int）。
有符号类型:关键字signed int==等价于signed int
无符号类型:关键字unsigned
有符号类型---32位为例(4字节为例)
有符号类型的整型数据使用最高位来表示符号为（0：正、1：负），其余31位用来表示数据。数据的取值范围是：-231～+231-1。(需要了解数值范围: -2,147,483,648--- 2,147,483,647 记忆:21亿)为什么记忆相关的数值范围:
Int A =0； A++； if(A > 22亿)永远不成立;
记忆范围对于将来设定条件是非常有必要的;
| 原码反码补码:8位数据 最高位为符号位 其余7位为数据位； 2^7=128 -128 -0 补码 0—127 -1—128(-0) |
无符号类型
无符号类型的整型数据只能表示正整数，所有32位都用来表示数据。数据的取值范围是：0～232-1。(0- 4,294,967,296 42亿)
思考题：如果数值超出了取值范围，会出现什么情况（无符号最大值为4294967295，如果存入的数值为4294967296，那结果会怎么样？）
| #include int main() { unsigned int num = 4294967298; //2 printf("%u\n",num); return 0; } |
| unsigned int num_1 = 4294967296; /* 无符号整型数值范围 0～4294967295*/ unsigned int num_2 = -1; /* 无符号整型数值范围 0～4294967295*/ int num_3 = 2147483650; /* 有符号整型数值范围-2147483648～2147483647*/ int num_4 = -2147483651; /* 有符号整型数值范围-2147483648～2147483647*/ printf(“%u\n”,num_1); 打印出的数值为:0 归位溢出:4294967296(当前数值)> 4294967295(最大值),从范围(0～4294967295)最大值超出需要从范围最小值0开始, 4294967296====0； printf(“%u\n”,num_2); 打印出的数值为: 4294967295 归位溢出:-1(当前值)<0(范围最小值),从范围(0～4294967295)最小值超出，需要从最大值4294967295开始,-1=======4294967295； printf(“%d\n”,num_3); 打印出的数值为: -2147483646 归位溢出: 2147483650(当前值)> 2147483647(范围最大值)，从范围(-2147483648～2147483647)最大值超过，需要从最小值-2147483648开始，2147483650====== -2147483646 printf(“%d\n”,num_4); 打印出的数值为: 2147483645 |
注：C语言中的整型数据类型默认为有符号类型，所以“signed”可以省略，直接使用“int”来表示，但如果需要表示为无符号类型，必须写“unsigned”。并且计算机的溢出属于归位溢出，一旦出现溢出情况，那么计算机会从最值（最小值或最大值）开始重新计算。超出多少位 从最值开始数几位显示（4294967296超出1位，从最小值数一位即0）
- 其他整型数据类型
- 短整型
短整型数据类型使用关键字“short”来表示，C语言中规定了短整型占2个字节大小的空间，同样短整型也分为“有符号短整型（short/signed short，数据的取值范围是：-215～+215-1）数值范围(-32768~32767)”和“无符号短整型（unsigned short，数据的取值范围是：0～216-1）数值范围(0~65535)”。
- 长整型
长整型数据类型使用关键字“long”来表示，C语言中规定了长整型占4个字节大小的空间，同样长整型也分为“有符号长整型（long/signed long，数据的取值范围是：-231～+231-1）(数值范围: -2,147,483,648--- 2,147,483,647)”和“无符号长整型（unsigned long，数据的取值范围是：0～232-1）(数值范围: 0～4294967295)”。
- 长长整型
长整型数据类型使用关键字“long long”来表示，C语言中规定了长长整型占8个字节大小的空间，同样长长整型也分为“有符号长长整型（longlong/signed longlong，数据的取值范围是：-263～+263-1）”和“无符号长长整型（unsigned longlong，数据的取值范围是：0～264-1）”。但需要注意，长长整型数据类型只有在C语言的C99标准中存在，在C89标准中是不存在的。 C语言协议标准C11 C99 C89
定义您购买苹果的数目:int/long/short a=100;
但是在后期单片机开发/操作系统开发中:考虑内存使用(如何节省内容,通过合理的数据类型达到节省内存的第一步);
建议咱们同学后期定义变量时数据类型分配要合理;
- 浮点型
- 浮点型数据类型概述
浮点型数据类型也称为“实型数据类型”，来用存储带有小数点的数据（必须有小数点），例如：-12.0、23.456、25.。浮点型数据中不区分“有符号”和“无符号”，固定为“有符号”类型（数据的最高位为符号位）。
注意点:浮点型数据中不区分”有符号”和”无符号”;固定为有符号类型;
- 浮点型数据类型
浮点型数据类型根据小数点的精确位数，分为“单精度浮点型”和“双精度浮点型”。
单精度浮点型
单精度浮点型使用关键字“float”来表示，C语言中规定“float”占4个字节的大小空间，小数点至少精确到小数点后的7位左右。
双精度浮点型
双精度浮点型使用关键字“double”来表示，C语言中规定“double”占8个字节的大小空间，小数点至少精确到小数点后的16位左右。
验证小数点后7位左右/16位左右:
字符型
字符型数据类型概述
字符型数据使用关键字“char”来表示。字符型数据是在存储空间中通过存储一个特定的整数来表示一个特定的字符（整数和字符之间是一一对应的，通过“ASCII码表”进行转换）。
字符型数据意义
存放整数
C语言中规定“char”占1个字节空间大小，字符型同样分“有符号（char/signed char，数据的取值范围是：-27～+27-1）”和“无符号（unsigned char，数据的取值范围是：0～28-1）”。
有符号的数据的取值范围: -27～+27-1 -128~+127
无符号的数据取值范围:0~28-1 0-255
存放字符
C语言中字符分为两类，一类为打印字符（可见字符，普通字符），使用单引号（’’）括起来，例如：‘a’、‘1’；另一类为控制字符（不可见字符，转义字符），使用反斜杠（\）+字符来表示。例如：\n（换行）、\r（回车）、\b（退格）、\t（tab）、\0（字符串结束标志位）。
| #include int main() { printf("%d\t%d\t%d\t\n",1,2,3); char buff[]="he\0llo"; printf("%s\n",buff); return 0; } |
注：字符型属于两种表示方法，可以表示一个整数，也可以表示一个字符，字符使用的原则是：只要在程序中，凡是看到字符，其实就是一个整数，当整数来使用。
1.4.3 关键字“sizeof”
sizeof是C/C++中的一个操作符(operator)，简单的说其作用就是返回一个对象或者类型所占的内存字节数。
sizeof主要是计算数据类型所占用的字节空间大小。
sizeof(基本数据类型、变量名);
| #include int main() { int A =10; float B; double C; short D; long E; printf("int:%u A:%u\n",sizeof(int),sizeof(A)); printf("float:%u B:%u\n",sizeof(float),sizeof(B)); printf("double:%u C:%u\n",sizeof(double),sizeof(C)); printf("short:%u D:%u\n",sizeof(short),sizeof(D)); printf("long:%u E:%u\n",sizeof(long),sizeof(E)); return 0; } |
1.5 课程回顾
1.原码 反码 补码
2.进制转换 十进制转为二进制/八进制/十六进制
3.数据类型:基本数据类型整型(短整型short 长整型 long 整型 int) 浮点型(单精度浮点型float 双精度浮点型 double) 单精度浮点型，精确到小数点后7位左右(不同编译器精确位数有所差异:浮点型float {符号位0正 1负 小数部分.314159 指数部分 10^1=3.14159} 浮点型没有有符号和无符号之分，固定为有符号)双精度浮点型 double:精确到小数点后16位左右;
字符型:ASCII表:0-31控制字符 32-127打印字符(可见字符)
控制字符:\t横向制表 1\t2\t3\t4\n 1 TAB键 2 TAB键 3 TAB键 4
\n换行符: printf(“hello C\n”);
\0字符串结束标志 hello\n he\0llo\n
关键字占用空间大小(字节数):sizeof(类型/变量名);
-
- 数据常量和数据变量
- 数据常量
- 数据常量和数据变量
- 数据常量概述
数据常量是指在程序运行的过程中，其中是不可改变的数据。因为常量的数值不可改变，一般使用一个固定的数值去表示一个常量。例如：12、-78、12.89、‘s’。
printf(“%d\n”,12);
- 数据常量分类
数据常量分为“数值型常量”和“字符型常量”两种，通过数据的形式可以判断常量的类型，常量的数据类型使用默认类型。
- 数值型常量
整型常量类型默认为“int（有符号整型）”，浮点型常量默认为“float（单精度浮点型）”。可以通过尾缀的形式改变数值常量的类型，如：12L表示为“long（长整型）”，12ul表示为“无符号长整型”。
- 字符型常量
字符型常量分为“字符常量”和“字符串常量”。
- 字符常量：使用单引号（‘’）引起来的单个字符。如：‘a’、‘1’，在存储器中占1个字节的空间。
- 字符串常量：使用双引号（“”）引起来的单个或多个字符。如：“a”、“Hello”，在存储器中占的空间大小为字符串字符个数+1个字节。
字符常量:单一字符，单一字符需要使用单引号;
字符串常量:使用双引号,多个字符或者单一字符，所占空间=字符数目+1(\0)；
printf(“%c\n”,’a’); printf(“%s\n”,”hello”); int A = 10; A =20L;
注：在字符串结束的时候，编译器会在字符串的最后面加上一个字符串结束字符‘\0’。
-
-
- 数据变量
-
- 数据变量概述
数据变量是指在程序运行的过程中，其值可以改变的数据。因为变量的数值是可以变化的，不是固定不变的，一般使用一个固定的名称（标识符）来表示一个变量。变量在使用前一定要先提前定义。
- 数据变量组成
数据变量由变量名（标识符）和变量值（常量数值）两部分组成。
Int(数据类型) A(标识符)=100(常量值);
A(标识符)=200(常量值);
- 变量（标识符）的命名规则
- 变量名组成：可以由字母（严格区分大小写）、数值、下划线以及美元符号（$）组成。
- 变量名开头：不能以数字开头。
- 变量重名：不能与关键字重复（重名）。
| #include int main() { //1）变量名组成：可以由字母（严格区分大小写）、数值、下划线以及美元符号（$）组成。 //2）变量名开头：不能以数字开头。 //3）变量重名：不能与关键字重复（重名）。 int A; //对 //int 4GCount; //不对 int _4GCount; //对 int $4GCount; //对 //int int; //不对 int a; //不同与A int A_B; //对 int A$B; //对 int _12345678912345678912345678912wertyuidfghkfghjfghjkfghjfghjfghgh3456789;//对 return 0; } |
注：在定义变量名的时候，遵循“望文生义”的原则，尽量使用突出“内容”、“功能”以及“含义”等词汇来对变量进行命名（可参考华为C语言规范.pdf文档）。
Int A； int cnt;
在计算机编程中，推荐使用“驼峰法”和“匈牙利命名法”来对变量进行命名。
| “匈牙利命名法是一种编程时的命名规范。 基本原则是：变量名=属性+类型+对象描述; 其中每一对象的名称都要求有明确含义，可以取对象名字全称或名字的一部分。要基于容易记忆容易理解的原则。保证名字的连贯性是非常重要的。” 属性部分： 全局变量 g_ 常量 m_ 局部变量 l_ 静态变量 s_ 类型部分: 指针 p 函数 f 无效 n 长整型 l 布尔 b 浮点型（有时也指文件）f 双字 dw 字符串 sz 短整型 n 双精度浮点 d 计数 c(通常用cnt) 字符 ch (通常用c) 整型 i(通常用n) 字节 by 字 w 无符号 u 描述部分： 最大Max 最小Min 初始化Init 临时变量T (或Temp) 源对象Src 目的对象Dest g_ nMax |
| 驼峰命名法:是一种命名规范，广泛用于各种计算机开发场景中。帮助开发人员清晰的命名各个文件。 1.分类 •大驼峰命名法 •小驼峰命名法 2.使用 这种命名法长得很像骆驼的驼峰，因此叫做驼峰命名法。 驼峰命名法指的是将文件名通过英文命名，除了第一个单词以外，其他单词的第一个首字母都为大写状态。 int nameArray; //小驼峰命名法 nameArray名字数组 存放名字; int NameArray; //大驼峰命名法 NameArray 大驼峰命名法 大驼峰和小驼峰的区别在于，第一个单词的首字母是否大写，如果大写，则为大驼峰命名，反之，为小驼峰。 |
编程:写作文
- 数据变量定义
变量定义的格式：数据类型 变量名;
例如：int age /* 定义了一个整型变量age */
- 数据类型：规定了变量能够保存什么样类型的数据。使用“基本数据类型”、“构造数据类型”以及“空类型”来作为变量的数据类型。
- 变量名：数据变量的标识符，代表该变量的空间（地址）。
- 数据变量赋值（初始化赋值 赋值语句赋值 用户输入）
- 初始化赋值：在定义变量的时候，使用“赋值运算符（=）”来直接给变量进行赋值，不用的变量一般初始化为0。Int A =10;
- 赋值语句赋值：在程序运行的过程中，通过赋值语句给变量进行赋值。 A=20;
- 用户输入：通过调用输入函数（scanf）来对变量进行赋值。 scanf(“%d”,&A)；
- Printf函数和Scanf函数使用
- Printf函数
- Printf函数和Scanf函数使用
- 函数功能
printf函数是一个标准输出函数，可以将内容输出到电脑屏幕上。
- 函数应用场合
- 输出提示信息，在用户自定义输入之前，提示需要或根据场合输出一定的提示信息。
- 输出程序的运行结果，用于检测程序是否正确。
- 用于调试程序printf(“%s-%d\n”,__FILE__,__LINE__);
| #include int main() { //1）变量名组成：可以由字母（严格区分大小写）、数值、下划线以及美元符号（$）组成。 //2）变量名开头：不能以数字开头。 //3）变量重名：不能与关键字重复（重名）。 int A; //对 printf("%s\n",__TIME__); printf("%s-%d\n",__FILE__,__LINE__); int _4GCount; //对 printf("%s-%d\n",__FILE__,__LINE__); int $4GCount; //对 int a; //不同与A printf("%s-%d\n",__FILE__,__LINE__); int A_B; //对 printf("%s\n",__TIME__); int A$B; //对 int _12345678912345678912345678912wertyuidfghkfghjfghjkfghjfghjfghgh3456789;//对 return 0; } |
- 函数使用
- 使用printf函数必须包含“stdio.h”头文件。
- 打印函数格式：
printf(“输出内容”)
printf(“格式符”,变量名)
printf(“格式符格式符”,变量名,变量名) //普通输出，格式化输出
- 打印函数常用格式符：
- %d：以十进制格式输出 printf(“%d\n”,12);->12
- %x：以十六进制格式输出
- %o：以八进制格式输出
- %c：以字符格式输出
- %s：以字符串格式输出
- %f：以单精度格式输出（只能用于输出浮点型数据）
- %lf：以双精度格式输出（只能用于输出浮点型数据）
- %.nf：输出n个小数位（只能用于输出浮点型数据）
- %nd：整数输出要占n位
- %%：输出一个%
- %p：输出变量的地址或者指针地址
| #include int main() { float l_fnum=10.0; double l_dnum=10.0; printf("以%%d打印数据:以十进制格式输出：\n"); printf("%d\n",12); printf("以%%u打印数据:以无符号整形格式输出：\n"); printf("%u\n",12); printf("以%%x打印数据:以十六进制格式输出：\n"); printf("0x%x\n",12); printf("以%%o打印数据:以八进制格式输出：\n"); printf("0%o\n",12); printf("以%%c打印数据:以字符格式输出：\n"); printf("%c\n",50); printf("以%%s打印数据:以字符串格式输出：\n"); printf("%s\n","hello"); //%s需要使用到字符串首地址 printf("以%%f打印数据:以浮点型格式输出：\n"); printf("%f\n",l_fnum); printf("以%%lf打印数据:以双精度浮点型格式输出：\n"); printf("%lf\n",l_dnum); printf("以%%.nlf打印数据:以双精度小数点后n位浮点型格式输出：\n"); printf("%.20lf\n",l_dnum); printf("以%%nd打印数据:以十进制格式输出 占n位：\n"); printf("%10d\n",12); printf("以%%0nd打印数据:以十进制格式输出 占n位空位补0：\n"); printf("%010d\n",12); printf("以%%p打印数据:地址值：\n"); printf("%p\n",&l_dnum); return 0; } |
注：打印函数中双引号（“”）中的内容，除了格式符和转义字符以外，其他内容是什么就会被打印输出什么。在使用printf()后面要加\n如果不加不能进行输出;
-
-
- Scanf函数
-
- 函数功能
scanf函数是标准输入函数，可以按用户指定的格式从键盘上把数据输入到指定的变量中。
- 函数应用场合
对变量进行自定义赋值时使用
- 函数使用
- 使用scanf函数必须包含“stdio.h”头文件。
- 输出函数的格式：scanf(“格式符”, &变量名);scanf(“格式符格式符”，&a,&b)双引号里便只能有格式符
- 使用 “取地址符（&）”来对变量进行地址取址。
| #include int main() { int l_iinput=0; printf("请输入一个整形数值:\n"); scanf("%d",&l_iinput);//要想对变量进行赋值操作,需要知道变量首地址，这一步为改变变量内容 //无需了解变量内容 printf("l_iinput：%d\n",l_iinput); return 0; } |
| #include int main() { int l_iinput1=0; int l_iinput2=0; int l_iinput3=0; printf("请输入3个整形数值:\n"); scanf("%d%d%d",&l_iinput1,&l_iinput2,&l_iinput3);//要想对变量进行赋值操作,需要知道变量首地址，这一步为改变变量内容，无需了解变量内容 printf("l_iinput1：%d %d %d\n",l_iinput1,l_iinput2,l_iinput3); return 0; } |
作为结束标志:TAB键 空格 回车
咱们同学经常犯错的地方:
| #include int main() { int l_iinput1=0; int l_iinput2=0; int l_iinput3=0; printf("请输入3个整形数值:\n"); scanf("%d %d %d ",&l_iinput1,&l_iinput2,&l_iinput3);//在scanf函数格式符字符串中间可以出现空格但是最后字符不能出现空格，否则会多输入 printf("l_iinput1：%d %d %d\n",l_iinput1,l_iinput2,l_iinput3); return 0; } |
| #include int main() { int l_iinput1=0; int l_iinput2=0; int l_iinput3=0; printf("请输入3个整形数值:\n"); scanf("%d %d %d\n",&l_iinput1,&l_iinput2,&l_iinput3); //在scanf函数格式符字符串中间可以出现空格但是最后字符不能出现空格，否则会多输入 printf("l_iinput1：%d %d %d\n",l_iinput1,l_iinput2,l_iinput3); return 0; } |
| #include int main() { int l_iinput1=0; int l_iinput2=0; int l_iinput3=0; printf("请输入3个整形数值:\n"); scanf("l_iinput1：%d %d %d\n",&l_iinput1,&l_iinput2,&l_iinput3);//只能有格式符不能有其它字符或者控制字符 否则会出现程序异常 printf("l_iinput1：%d %d %d\n",l_iinput1,l_iinput2,l_iinput3); return 0; } |
| #include int main() { int l_iinput1=0; int l_iinput2=0; int l_iinput3=0; printf("请输入3个整形数值:\n"); scanf("%d%d%d",l_iinput1,l_iinput2,l_iinput3);//未取地址出现段错误(地址访问错误) printf("l_iinput1：%d %d %d\n",l_iinput1,l_iinput2,l_iinput3); return 0; } |
-
- 运算符和表达式概念
- 运算符概念
- 运算符和表达式概念
运算符的本质是一个符号,一个能够进行运算的特殊符号。根据运算符进行运算操作数的数量,把运算符分为以下几种类型：
- 单目运算符：又被称为“一元运算符”，是指在运算过程中只需要一个操作数的运算符。
- 双目运算符：是指在运算过程中只需要两个操作数的运算符。
- 三目运算符：是指在运算过程中需要三个操作数的运算符。
在C语言中，只有一个三目运算符：“ ? :”
-
-
- 表达式概念
-
表达式的本质是一个式子，在C语言中的定义是用C语言运算符将运算对象连接起来的式子就叫表达式。
表达式与语句区别:a = b ;
使用的时候需要注意3点：
- 表达式的最终结果只能有一个。
- 在程序中遇到表达式的时候，必须先计算出表达式的结果或值。
- 在计算表达式的时候，需要考虑运算符的优先级、结合性以及操作数等条件。
优先级:1-15
运算符的结合性:
单目、条件运算符、赋值运算符具有右结合性:
单目运算符:!a++ 相当于!(a++);
条件运算符:a?b:c?d:c;相当于 a?b:(c?d:c);
赋值运算符:a = b = c;相当于 a=( b = c );
其它运算符都是左结合性; a+b+c
-
- C语言常用的运算符
- 赋值运算符:“=”
- C语言常用的运算符
(1)运算符的作用： 赋予数值，写入到内存空间。
(2)运算符格式： 变量 = 变量、变量 = 常量、变量 = 表达式
(3)运算符结合性： 右结合性，即先计算运算符右边的变量或表达式的值，写入左边的内存空间。
注：赋值运算符左边不能是常量或表达式，只能是变量(存储空间)。
示例1.c：
| #include int main() { int inputA=1,inputB=2,inputC=3; //变量等于变量 inputA = inputB; //变量等于常量 inputA =1; //变量等于表达式 inputC = inputA + inputB; printf("%d %d %d\n",inputA,inputB,inputC); inputA = inputB = inputC; printf("%d %d %d\n",inputA,inputB,inputC); return 0; } |
-
-
- 算术运算符：+、-、*、/、%
-
(1)运算符作用： 四则运算
(2)算数运算符3条操作原则：
-
- 整型跟整型运算：结果只能是整数，不会得到浮点型数据。
-
- 求余运算：浮点型不能进行求余运算。
| #include int main() { int inputA=3; printf("%d\n",inputA%2); //求余运算 3%2 1 return 0; } |
-
- 类型不同：在C语言中，只有类型相同的数据才能进行算术运算，如果类型不同，低精度的数据类型会自动向高精度的数据类型转换，数据类型精度从低到高排列：char – short – int – long – float – double – long double。
示例1.c：
| #include int main() { float inputA=3.0; int inputB=4; printf("%d\n",inputA+inputB); //求余运算 3%2 1 return 0; } |
常量: 数值固定不变
变量: 可以发生改变
定义变量: 格式 数据类型 变量名(标识符) =(初始化赋值) 常量;
变量名 = 常量;赋值
变量名(标识):可以为英文大小字母、数字、下划线、美元$
数字不能作为标识开始;
标识不能与关键字重名;
标准输入输出:
头文件:#include
标准输出函数:printf()
Printf()使用格式: printf(“字符串\n”); printf(“格式符\n”,变量名);printf(“格式符格式符\n”,变量名,变量名);
格式符:
%d:是以十进制格式进行输出;
%u:以无符号整型格式进行输出;
%x:以十六进制格式进行输出;
%o:以八进制格式进行输出;
%ld:是以长整型格式进行输出;
%lld:以长长整型格式进行输出;
%f:以浮点型格式进行输出;
%lf:以双精度浮点型格式进行输出;
%.nlf: 以双精度浮点型小数点后精确到n位格式进行输出;
%nd:是以整型十进制整型部分占n位进行输出;
%0nd: 是以整型十进制整型部分占n位无数值用0进行补全进行输出;
%c:是以字符格式进行输出
%p:打印地址值
%s:以字符串进行打印
标准输入函数:scanf()
标准输入函数scanf()函数格式:scanf(“格式符”,变量地址); scanf(“格式符格式符”,变量地址,变量地址);
注意点: 格式符与格式符之间可以有空格(不推荐)
格式符后面不能出现空格或者字符;
格式符字符串中不能出现其它字符否则程序崩溃;
判定输入结束标志:TAB键、空格、回车;
运算符:
优先级1-15
结合性:单目运算符、赋值运算符、条件运算符(右结合:自右向左) !a++
单目运算符、双目运算符、三目运算符:
依据操作数个数进行判定:单目:只有一个操作数;双目运算符:仅有两个操作数/表达式; 三目运算符:需要三个操作数/表达式;
赋值运算:格式 变量=常量 变量=变量 变量=表达式 赋值左侧只能是变量;
算数运算符:+-*/%
+:双目运算符 a+b
*:双目运算符 a*b
%:取余运算符(注意:不能应用于浮点型) 3%2 1
算数运算符:相关运算有规则:
整型与整型运算结果只能是整型;
低精度与高精度进行运算，首先先将低精度转为高精度，再进行运算;
Char->(short)->int->long->float->double
练习1：在键盘上任意输入一个3位数，要求分别输出每一位上的数值。例如：输入123，输出bai = 1,shi = 2,ge = 3
| #include int main() { //在键盘上任意输入一个3位数，要求分别输出每一位上的数值。例如：输入123，输出bai = 1,shi = 2,ge = 3 int inputNum =0; int bai,shi,ge; //输入 printf("请输入3位整数数值\n"); scanf("%d",&inputNum); //运算 bai = inputNum /100 ; //123/100 整型与整型进行运算 结果整型 1 shi = inputNum % 100 /10; //(inputNum -bai*100)/10 2 (inputNum %100 /10) ge = inputNum % 10; //输出 printf("百位:%d十位:%d个位:%d\n",bai,shi,ge); return 0; } |
作业:
1.对于下面的各种值，最合适使用何种类型的变量来存储？
A、人的年龄 数据类型:short 数据类型一定要合理: 关心数值范围 内存消耗
B、人的体重（单位为克）； 千克:浮点型 克:long
C、圆的半径 数据类型:单精度浮点型float
D、你的年薪 数据类型:short
E、商品的价格（元） 数据类型:float
F、考试的最高分（假设总是为100） 数据类型:short
G、温度 数据类型:单精度浮点型float 温度传感器 0.01
H、个人的净资产； 数据类型:单精度浮点型 float
I、到某个星球的距离（单位为英里） 数据类型:double
2.下面的那些变量名是合法的
a. 123variable × 数字不能作为标识符开头
b. x √
c. lotal_score √
d. Weight_in_*s ×*不能作为标识
e. one √
f. gross-cost ×-不能作为标识
g. RADRUS √
h. Radius √
i. radius √
j. this_is_a_variable_to_hold_the_width_of_a_box √
long类型 int 类型区别:
如果处理器/系统:8/16位int 2字节 long 4字节
如果处理器/系统:32位int long 4字节
-
-
- 关系运算符：>、<、>=、<=、==、!=
-
(1)运算符作用： 判断数据之间的关系(大小)
(2)运算符格式：(变量/表达式/常量) 运算符 (变量/表达式/常量) 双目运算符
(3)关系运算符4条操作规则：
-
- 关系运算符的运算结果：逻辑结果：逻辑真(1)、逻辑假(0)
逻辑结果:真默认采用1表示 逻辑假默认采用0表示
真假说明: 非零值即为真(1真 2真 -1真 -2真) 假:0
-
- 关系运算符的数据：关系运算符运算的时候只关心数据的大小，不关心数据的类型。
数据大小是关系运算符唯一评判标准;
-
- 关系运算符跟算术运算符混合使用：先计算后判断。
由于算数运算优先级处于3 4优先级，关系运算符优先级处于6优先级;先运算后判断
-
- 关系运算符应用场合：常用于条件选择
示例3.c：
| #include int main() { int A = 1; int B = 2; printf("常量与常量对比:%d\n",10<1); printf("常量与常量对比:%d\n",10>1); printf("表达式常量:%d\n",A + B < 4); printf("表达式变量:%d\n",A + B < B); printf("常量变量:%d\n",10 < B); printf("常量==常量%d\n",10 == 10); printf("常量==常量%d\n",10 == 1); printf("常量!=常量%d\n",10 != 1); printf("常量!=常量%d\n",10 != 10); return 0; } |
-
-
- 逻辑运算符：&&、||、！
-
(1)运算符作用：多个条件的判断，得到多个条件的逻辑结果。逻辑运算符的运算结果为逻辑值：真(1)，假(0)
(2)逻辑运算符操作原则：
(3)逻辑与(&&)：并且关系
- 逻辑与运算符格式：变量1或表达式1 && 变量2或表达式2 && …… && 变量n或表达式n
- 逻辑与运算符规则： 所有变量或表达式的值都为真时，整体为真；有一个为假，整体为假
- 逻辑与运算过程： 首先计算变量1或表达式1的值，判断真假，如果为假，整体为假，后边的变量或表达式都不再进行计算和判断；如果为真，继续判断变量2或表达式2的值，以此类推，直到所有的值都为真，整体为真，或者有一个为假，整体为假。
示例4.c：
| #include int main() { int A = 1; int B = 2; //③逻辑与运算过程：首先计算变量1或表达式1的值，判断真假，如果为假，整体为假，后边的变量或表达式都不再进行计算和判断；如果为真，继续判断变量2或表达式2的值，以此类推，直到所有的值都为真，整体为真，或者有一个为假，整体为假。 printf("%d\n",A && (A = 5) && -1 && 0 && (B=10) && (A = 9)); printf("A:%d B:%d\n",A,B); return 0; } |
(4)逻辑或(||)：或者关系
||符号如何通过键盘进行输出: ||shift+(回车上面按键 |\)
- 逻辑或运算符格式：变量1或表达式1 || 变量2或表达式2 || …… || 变量n或表达式n
- 逻辑或运算符规则：所有变量或表达式的值都为假时，整体为假；有一个为真，整体为真
- 逻辑或运算过程： 先计算变量1或表达式1的值。如果为真，整体为真；后边变量或表达式不在进行计算和判断。如果为假，继续判断变量2或表达式2的值，以此类推，直到所有的值都为假，整体为假，或者有一个为真，整体为真。
示例5.c：
| #include int main() { int A = 1; int B = 2; //③逻辑或运算过程： 先计算变量1或表达式1的值。如果为真，整体为真；后边变量或表达式不在进行计算和判断。如果为假，继续判断变量2或表达式2的值，以此类推，直到所有的值都为假，整体为假，或者有一个为真，整体为真。 printf("%d\n",!A || (A == 5) || -1 || (B=10) || 0 || (A = 9)); printf("A:%d B:%d\n",A,B); return 0; } |
(5)逻辑非(!)：取反关系
- 逻辑或运算符格式：!数据或表达式
- 逻辑非运算规则： 真变假，假变真。
示例6.c：
| #include int main() { int LED =0; LED = !LED; printf("%d\n",LED); LED = !LED; printf("%d\n",LED); return 0; } |
-
-
- 复合运算符：+=、-=、*=、/=、%=、<<=、>>=、&=、|=、^=、~=
-
(1)运算符作用：赋值运算符与其他双目运算符结合的写法
(2)运算符作用格式： 变量 复合运算符 变量或常量或表达式(右结合性)
(3)运算符使用原则：先计算运算符右边的变量或表达式的值，然后带入左边进行计算。
例 int A =3； A+=2; A = A+2; A=5;
示例7.c：
| #include int main() { //+=、-=、*=、/=、%=、 <<=、>>=、&=、|=、^=、~=(单片机前讲解) int A =3; int C = 0; C += A; printf("C:%d\n",C); C -= 4; printf("C:%d\n",C); C *= 4; printf("C:%d\n",C); A /= 2; printf("A:%d\n",A); A = 3; A %= 2; printf("A:%d\n",A); return 0; } |
-
-
- 自加自减运算符：++、--
-
(1)运算符作用：让变量的值自加或自减1
(2)运算符格式：变量++(后置自增)、++变量(前置自增)、变量--(后置自减)、--变量(前置自减)
(3)运算符位置：
- 运算符后置A++：先使用变量的值，语句执行结束之后，在让变量加1；
示例8.c：
| #include int main() { //先使用变量的值，语句执行结束之后，在让变量加1； int A =3; printf("A:%d\n",A); //3 printf("A:%d\n",A++); //3 printf("A:%d\n",A); //4 return 0; } |
- 运算符前置： 先让变量的值加1，在执行语句。
示例9.c：
| #include int main() { //先让变量的值加1，在执行语句。 int A =3; printf("A:%d\n",A); //3 printf("A:%d\n",++A); //4 printf("A:%d\n",A); //4 return 0; } |
|
| Gcc编译器规则 |
g++编译器规则 |
| 前置 |
前置 |
| #include int main() { //先让变量的值加1，在执行语句。 int A =3; printf("A:%d\n",A); //3 printf("A:%d\n",(++A)++); //错误 printf("A:%d\n",A); //4 return 0; } |
#include using namespace std; int main() { int A =3; cout<<(++A)++< cout<<(A)< } |
| 后置 |
后置 |
| #include int main() { int A =3; printf("A:%d\n",A); //3 printf("A:%d\n",(A++)++); //错误 printf("A:%d\n",A); //4 return 0; } |
#include int main() { //先让变量的值加1，在执行语句。 int A =3; printf("A:%d\n",A); //3 printf("A:%d\n",(A++)++); //4 printf("A:%d\n",A); //4 return 0; } |
前置自增与后置自增区别:
①由于前置自增没有新空间开辟，造就了前置自增效率要比后置自增高;
②设计方式:应用场景 先引用/先计算 先引用->临时变量(不节省空间)
(4)自加自减运算符3条操作规则：
- 自加或自减运算符可以操作的类型：可以操作整型数据，也可以操作浮点型数据(常用于整型)。(浮点型进行前置自加自减或者自加自减只能对整数部分进行操作)
- 自加或自减运算符对内存空间的操作过程：先读出变量的值，自加或自减之后，再写入内存空间。
- 遇到自加自减运算符时的处理方法：先把自加自减运算符剥离出来，如果在前(在变量之前)，就让变量加1或减1之后再参与运算；如果在后(在变量之后)，先进行运算，再让变量自加或自减1。
示例10.c：
| #include int main() { //先让变量的值加1，在执行语句。 float A =3.7; printf("A:%f\n",A); //3 printf("A:%f\n",A++); //4 printf("A:%f\n",A); //4 return 0; } |
-
-
- 逗号运算符：“,” 第十五优先级
-
(1)运算符作用：将多条语句变成一条语句
(2)运算符格式：语句1,语句2，……，语句n
(3)运算符操作原则：
- 运算方向：从左到右依次运算，所有的表达式都要运算
- 运算结果：最后一个变量或表达式的值作为整体的值。
示例11.c
| #include int main() { //① 运算方向：从左到右依次运算，所有的表达式都要运算 //② 运算结果：最后一个变量或表达式的值作为整体的值。 int inputA,inputB,inputC; printf("%d\n",(inputA = 1,inputB = 2 ,inputC = 3)); printf("%d %d %d\n",inputA,inputB ,inputC); printf("%d\n",(4,5,6,7)); return 0; } |
-
-
- 条件运算符：“ ? : ” 唯一三目运算符
-
(1)运算符作用：用于表达式或者条件操作的2选1
(2)运算符格式：条件表达式 ? 表达式1 : 表达式2；
(3)运算符操作原则：
- 首先计算条件表达式的值，判断真假
- 如果为真：执行表达式1，并将其结果作为整体的值
- 如果为假：执行表达式2，并将其结果作为整体的值
到后期:三目运算符优于条件选择语句
C89与C99有所区别: C89 不支持:inputC = 1
示例12.c
| #include int main() { //条件表达式 ? 表达式1 : 表达式2； int inputA = 5,inputB = 4 ,inputC = 3; printf("%d\n",inputB > inputA ? (inputC = 1): (inputC = 2)); printf("%d\n",inputC); return 0; } |
| #include int main() { //条件表达式 ? 表达式1 : 表达式2； int inputA = 5,inputB = 4 ,inputC = 3; inputB > inputA ? printf("成立") : printf("不成立"); return 0; } |
-
- C语言运算符优先级(方便记忆优先级)
1.括号优先级最高（当不确定运算符优先级时，加括号）。
2.运算符的操作数越少，优先级越高（单目运算符高于双目运算符）。
3.算术运算符 > 关系运算符 > 位运算符 > 逻辑运算符。
4.非运算符>与运算符 > 异或运算符 > 或运算符（包括逻辑运算符和位运算符）
参考资料：C语言学习资料\学习文档\运算符优先性
-
- 数据类型转换
- 数据类型转换
- 数据类型转换
是指数据的数据类型发生了变化。
-
-
- 数据类型转换方式
-
数据类型转换的方式有两种：自动类型转换、强制类型转换
(1)自动数据类型转换
- 含义：又称为隐式类型转化，自动按照从低到高的顺序转换(编译器自动转换)。Char +short ->int
特例： char和short类型的数据参与运算的时候，会自动转换成int类型。
(2)强制类型转换
- 含义：又被称为显式类型转换，是指原本数据类型不会发生变化，强制让其数据类型按照要求进行转换。
格式：(要求的数据类型)数据或表达式。 int a; (char)a;
示例13.c
| #include int main() { int A =1; int B =10; char C = (char)A+ (char)B; float Num =1.23456789; printf("%d\n",(int)Num); //显示类型转换 return 0; } |
-
-
- 数据类型转换原则
-
(1)char向int、float转换
- char向int转换，直接根据ASCII表转换成相应的整数；
- char向float转换，整数部分根据ASCII表转换成相应的整数，小数部分由0补齐。
(2)int向char、float转换
- int向char转换：使用int数据和256求余，将结果赋值给char型变量(赋值给unsigned char，int%256+0)
- int向float转换：保留整数位，小数位由0补足
(3)float向char、int转换
- float向char转换：先擦除小数位，再用整数位对256求余
- float向int转换：保留整数位，擦除小数位。
示例14.c：
| #include int main() { /********************************************************* (1)char向int、float转换 ① char向int转换，直接根据ASCII表转换成相应的整数； ② char向float转换，整数部分根据ASCII表转换成相应的整数，小数部分由0补齐。 (2)int向char、float转换 ③ int向char转换：使用int数据和256求余，将结果赋值给char型变量(赋值给unsigned char，int%256+0) ④ int向float转换：保留整数位，小数位由0补足 (3)float向char、int转换 ⑤ float向char转换：先擦除小数位，再用整数位对256求余 ⑥ float向int转换：保留整数位，擦除小数位。 ***********************************************************/ //char向int、float转换 char c_A = 50; int i_A = c_A; float f_A = c_A; printf("%d\n",i_A); printf("%f\n",f_A); //int向char、float转换 //C99支持中间定义变量 C89不支持中间定义变量 int i_B = 259; char c_B = i_B; float f_B = i_B; printf("%d\n",c_B); printf("%d\n",i_B % 256);//原理性讲解:int向char转换：使用int数据和256求余，将结果赋值给char型变量 printf("%f\n",f_B); //float向char、int转换 float f_C = 259.789; char c_C= f_C; int i_C =f_C; printf("%d\n",c_C);//float向char转换：先擦除小数位，再用整数位对256求余 printf("%d\n",(int)f_C%256);//为什么加强制转换 原因是浮点性不能进行求余运算 printf("%d\n",i_C); return 0; } |
-
-
- 练习
-
定义int b = 7;float a = 2.5,c = 4.7,则表达式
a + (int)(b / 3 *(int)(a + c) / 2) % 4的值是什么？
| #include int main() { //定义int b = 7;float a = 2.5,c = 4.7,则表达式 //a + (int)(b / 3 *(int)(a + c) / 2) % 4的值是什么？ //=2.5+(int)(7 / 3 *(int)(2.5 + 4.7) / 2)%4 //=2.5+(int)(7 / 3 *7 / 2)%4 //自左向右集合 //=2.5+(int)(2 *7 / 2)%4 //=2.5+(int)(7)%4 //=2.5+3 //=5.5 int b = 7; float a = 2.5,c = 4.7; printf("%f\n",a + (int)(b / 3 *(int)(a + c) / 2) % 4); return 0; } |
-
- 课程回顾
运算符:
=赋值运算符: A= 10; 注:左侧一定是变量 右侧 常量/表达式/变量; A=10 à10
算数运算符:+-*/% 注意:整型与整型运算结果为整型 浮点型数据不能进行求余运算; 自左向右
关系运算符:<> =>= <= 注意:逻辑结果 得到结果数值0 1 真假 非零即为真 零为假
逻辑运算符:&& || ! 注意:&&全真为真 先判定条件1 再判定条件2 ….
||全假则为假 先判定条件1
自增自减运算符:++ -- 前置 后置引用时机不一致
逗号运算符:,, 注意:自左向右进行运算 最后一个表达式数值作为整体值
Char ->int
Int ->char
Float
-
- C语言9条语句介绍
- C语言9条语句概述
- C语言9条语句介绍
C语言的核心是数据和算法，数据就是指数据类型(基本数据类型 构造数据类型 空类型)和数值；算法包括运算符(优先级/结合性/规则)和9条控制语句。9条控制语句在程序中主要实现一定的控制功能和逻辑功能。
-
-
- C语言基本结构
-
C语言的基本结构有3种： 顺序结构、选择结构以及循环结构。
- 顺序结构
顺序结构是C语言中最基本的结构，是指程序按照从上到下、从左到右的顺序执行。需要注意的是，如果上一条语句没有执行完，后边的语句都不会被执行;
看程序:程序main函数从左到右运行，由上到下运行;
- 选择结构
是指对于给定的条件进行判断，根据判断的结果来控制程序的执行过程。
- 循环结构
是因为在程序中某些功能需要反复使用而设置的一种程序结构。循环结构常有两种模型来表示：一种是不达目的不罢休，只要达到想要的结果(只关心结果，不关心循环次数)，就停止循环；另外一种是不达次数不罢休，只要达到循环的次数(只关心循环次数，不关心循环结果)，就停止循环。
-
-
- C语言结构基本语句分类
-
- 顺序结构：0条;
- 选择结构：2条， if……else判断语句；switch……case……break选择语句；
- 循环结构：3条， for循环、while循环、do-while循环;
- 跳转语句：4条， break停止语句、return返回语句、continue中止语句、goto跳转语句。
1.14C语言9条控制语句应用
1.14.1选择结构
- if … else判断语句
(1)语句关键字：if（如果）、else（否则、其他）、else if（其他如果）
(2)语句格式
- 单条件选择：满足就执行，不满足就放弃（不做任何事）
| 格式： if(条件表达式) //条件只需要逻辑真假，如果为真则执行，如果为假则不执行; { /* 程序段 */ } 语句执行过程：首先计算条件表达式的值，判断是否为真，如果为真就执行大括号里的程序段；如果为假，跳过大括号，不执行任何操作。 |
| #include int main() { //① 单条件选择：满足就执行，不满足就放弃（不做任何事） if( 10 > 5 ) //只判定逻辑值 是否为真 满足(真)就运行 不满足(假)不运行 { printf("前面数值比后面数值大\n"); } return 0; } |
| 条件与运算符进行结合使用示例: #include int main() { int A=3,B =4; //① 单条件选择：满足就执行，不满足就放弃（不做任何事） if( A=4, 10 > 5 ,B = 0) //条件语句 还考察 逗号运算符 { printf("成立\n"); } printf("A:%d B:%d\n",A,B); return 0; } |
单条件选择：满足就做规定的事情，不满足就做另外一件事情。
| 格式： if(条件表达式) { /* 程序段1 */ } else { /* 程序段2 */ } 语句执行过程： 先判断条件表达式的值，如果为真，就执行程序段1；如果为假，就执行程序段2。 |
| #include int main() { //① 单条件选择：满足就执行，不满足就放弃（不做任何事） if( 10 > 5 ) //只判定逻辑值 是否为真 满足(真)就运行 不满足(假)不运行 { printf("前面数值比后面数值大\n"); } else { printf("前面数值不比后面数值大\n"); } //推荐采用三目运算符替换 10 > 5 ? printf("前面数值比后面数值大\n"):printf("前面数值不比后面数值大\n"); return 0; } |
| 条件表达式与逻辑与联合使用:注意 #include int main() { int A=3,B =4; //简单结构分析 if(A && (B = 0) &&(A =8)) //条件语句 还考察 逗号运算符 { printf("成立\n"); } else { printf("不成立\n"); } printf("A:%d B:%d\n",A,B); return 0; } |
- 多条件选择：
| 格式： if(条件表达式1) { /* 程序段1 */ } else if(条件表达式2) { /* 程序段2 */ } …… else { /* 程序段n*/ } 语句执行过程：首先计算条件表达式1的值，如果为真，就执行程序段1，后边所有条件表达式都不在进行计算和判断；如果为假，继续判断条件表达式2的值……以此类推，直到所有的条件表达式都不为真，就执行else下的程序段n。或者是直到有一个条件表达式为真，执行相应的程序段。 |
| #include int main() { int inputNum; printf("请输入一个数值:\n"); scanf("%d",&inputNum); if(inputNum> 0 && inputNum < 10) { printf("在0与10范围内\n"); } else if(inputNum>= 10 && inputNum < 20) { printf("在10与20范围内\n"); } else if(inputNum>= 20 && inputNum < 30) { printf("在20与30范围内\n"); } else if(inputNum >= 30 ) //如果成立就执行该if后的{}内的执行语句，以后的if不再判断执行，直接跳出这个结构 { printf("在30以上范围内\n"); } else if(inputNum>= 30 && inputNum < 40) { printf("在30与40范围内\n"); } else { printf("不在范围内\n"); } return 0; } |
//if条件设定是有原则可言的:
//坐标 页
If else if(条件) 首先 设置大类:判定页 设定小类:再判定坐标
注：在一条if..else判断语句中if(){}必须存在且只能有一个，else if(){}根据需要，可以有任意个，else{}在一条判断语句中最多只能有一个（也可以没有）。判断if()内的条件表达式是否成立，如果成立就执行该if后的{}内的执行语句，以后的if不再判断执行，直接跳出这个结构。
示例1.c：输入成绩，判断该成绩的等级(0~59：不及格；60~89：良好；90~100：优秀)
| #include int main() { //输入成绩，判断该成绩的等级(0~59：不及格；60~89：良好；90~100：优秀) int inputNum; printf("请输入一个数值:\n"); scanf("%d",&inputNum); if(inputNum>= 0 && inputNum <= 59) { printf("不及格\n"); } else if(inputNum>= 60 && inputNum < 90) { printf("良好\n"); } else if(inputNum>= 90 && inputNum <= 100) { printf("优秀\n"); } else { printf("不在范围内\n"); } return 0; } |
练习1：输入一个年份，判断该年份是否为闰年（闰年的条件：年份是4的倍数同时不是100的倍数，或年份是400的倍数）。例如：2000、2004、2008、2012、2016、2020是闰年。
| #include int main() { //输入一个年份，判断该年份是否为闰年（闰年的条件：年份是4的倍数同时不是100的倍数，或年份是400的倍数）。例如：2000、2004、2008、2012、2016、2020是闰年。 int inputYear; printf("请输入一个年份:\n"); scanf("%d",&inputYear); if( (inputYear % 4 == 0 ) && (inputYear % 100 !=0 )||(inputYear % 400 ==0)) { printf("%d为闰年\n",inputYear); } else { printf("%d为平年\n",inputYear); } return 0; } |
练习2：输入两个数，判断这两个数的大小关系
| #include int main() { //输入两个数，判断这两个数的大小关系 int inputNum1,inputNum2; printf("请输入两个数值:\n"); scanf("%d%d",&inputNum1,&inputNum2); if(inputNum1 > inputNum2) { printf("第一个数%d大于第二个数%d\n",inputNum1,inputNum2); } else if(inputNum1 < inputNum2) { printf("第一个数%d小于第二个数%d\n",inputNum1,inputNum2); } else { printf("第一个数%d值等于第二个数%d\n",inputNum1,inputNum2); } return 0; } |
- switch … case…default选择语句
- 语句关键字：switch（开关）、case（情况）、break（打断、停止）、default（默认）。
- 语句格式：
| switch(整型表达式)// { case 整型常量表达式1:程序段1;break; case 整型常量表达式2:程序段2;break; case 整型常量表达式3:程序段3;break; …… case 整型常量表达式n:程序段n;break; default:程序段n+1;break; } //switch选择语句要比if选择语句效率高;switch一一匹配 if(范围匹配) 注意点: 整型常量表达式i:表达式的结果为整型不能出现字符串，不能为变量，只能常量(数值不能发生改变的); 每一条case语句后面都追加一条break;否则会出现多条case语句执行; |
注：整型表达式：表达式的结果为整型；整形常量表达式：常量表达式，结果是整型。
- 语句执行过程：
首先计算整型表达式的值，并往下传递。然后验证传递的值跟整型常量表达式的值是否相同，如果相同，就执行对应的case后的程序段1，执行完毕之后，break跳出这个结构；如果不同，继续往下传递，跟整型常量表达式2进行判断…………依次类推，直到跟所有的整型常量表达式的值都不相同，就执行default后的程序段。
注：使用switch语句时，必须向switch语句传递一个值(这个值必须是确定的，不能是随机数)，如果没有break，顺序判断表达式跟case后面的整形常量表达式是否相等，如果相等了，执行其后面的语句。以后的case不再判断，直接执行后面的语句。case后的值必须是常量，并且是唯一。
示例2.c：输入一个数，打印对应的内容
| #include int main() { //输入1个数 int inputNum1; printf("请输入1个数值:\n"); scanf("%d",&inputNum1); switch(inputNum1) { case 0:printf("数值为0\n");break; case 1:printf("数值为1\n");break; case 2:printf("数值为2\n");break; case 3:printf("数值为3\n");break; default :printf("数值非0-3范围\n");break; } return 0; } |
| #include int main() { //输入1个数 int inputNum1; printf("请输入1个数值:\n"); scanf("%d",&inputNum1); switch(inputNum1) { default :printf("数值非0-3范围\n");break; case 0:printf("数值为0\n");break; case 1:printf("数值为1\n");break; case 2:printf("数值为2\n");break; case 3:printf("数值为3\n");break; } return 0; } |
练习：
使用if语句完成：
- 输入两个整数，判断第一个数是否能把第二个数整除。
| #include int main() { //1、输入两个整数，判断第一个数是否能把第二个数整除。 int inputNum1,inputNum2; printf("请输入两个整数\n"); scanf("%d%d",&inputNum1,&inputNum2); //处理 if(inputNum1 % inputNum2 == 0) { printf("第一个数能被第二个数整除\n"); } else { printf("第一个数不能被第二个数整除\n"); } return 0; } |
2、判断用户输入的整数，输出对应的情况
1）如果输入负数，打印输出“负数”。
2）如果输入正偶数，打印输出“正偶数”。
3）如果输入正奇数，打印输出“正奇数”。
| #include int main() { //判断用户输入的整数，输出对应的情况 //1）如果输入负数，打印输出“负数”。 //2）如果输入正偶数，打印输出“正偶数”。 //3）如果输入正奇数，打印输出“正奇数”。 int inputNum; printf("请输入一个整数\n"); scanf("%d",&inputNum); //处理 if(inputNum < 0) { printf("%d:负数\n",inputNum); } else if(inputNum %2 == 0) { printf("%d:正偶数\n",inputNum); } else { printf("%d:正奇数\n",inputNum); } return 0; } |
使用switch语句完成：
3、编写一个简单的计数器，输入整数，计算表达式，并输出结果
输入格式：data1 op data2 data1和data2是参加运算的两个数，op为运算符(+、-、*、/)
例：2+3，输出5。
| #include /******************************************* 编写一个简单的计数器，输入整数，计算表达式，并输出结果 输入格式：data1 op data2 data1和data2是参加运算的两个数，op为运算符(+、-、*、/) 例：2+3，输出5。 **********************************************/ int main() { int data1,data2,result; char op; printf("请输入数运算符数\n"); scanf("%d%c%d",&data1,&op,&data2); //处理 switch(op) { case '+':result = data1 + data2;break; case '-':result = data1 - data2;break; case '*':result = data1 * data2;break; case '/':result = data1 / data2;break; } printf("%d\n",result); return 0; } |
4、输入一个成绩，如果输入的成绩小于60分，打印不合格，60～69，打印及格，70～79，打印中等，80～89，打印良好，90～99，打印优秀，100分，打印满分。如果不在范围内，提示输入错误。
| #include /******************************************* 输入一个成绩，如果输入的成绩小于60分，打印不合格，60～69，打印及格，70～79，打印中等，80～89，打印良好，90～99，打印优秀，100分，打印满分。如果不在范围内，提示输入错误。 **********************************************/ int main() { int data; printf("请输入成绩\n"); scanf("%d",&data); //处理 if(data < 60) { printf("不合格\n"); } else if(data <70) { printf("合格\n"); } else if(data <80) { printf("中等\n"); } else if(data <90) { printf("良好\n"); } else if(data <100) { printf("优秀\n"); } else { printf("满分\n"); } return 0; } |
Switch不能做范围的选定; if是一个范围;
1.14.2循环语句
- While循环语句
- 语句关键字：while（当…的时候）。
- 语句格式
| while(条件表达式) { /* 程序段 */ } |
- 语句执行过程：首先判断条件表达式的值，如果为真(非0)，就执行大括号里的程序段，如果为假，跳过不执行任何操作。
- 示例：循环打印9~0
| #include /******************************************* 循环打印9~0 **********************************************/ int main() { int num = 10; while(num)//不达目的不罢休 ()内条件满足就运行,不满足即不运行; 先判断后执行 { printf("数据%d\n",--num); } return 0; } |
/* 运行步骤
首先判断条件表达式i--，自减运算符在变量后，先使用变量，然后执行自减操作，这时i=9。
*/
| #include /******************************************* 循环打印9~0 **********************************************/ int main() { int num = 10; while(num--)//不达目的不罢休 ()内条件满足就运行,不满足即不运行; 先判断后执行 { printf("数据%d\n",num); } return 0; } |
- do-while循环语句
- 语句关键字：do（做）、while（当…的时候）。
- 语句格式：
| do { 循环体执行语句; } while(表达式/循环条件);（特别注意：while之后要加上“;”） |
语句执行过程：先无条件执行一次大括号（{}）里面的循环体执行语句，再计算表达式的值，判断真假或验证循环条件是否为真，如果为真（非0），再执行一次大括号（{}）里面的循环体执行语句，如果为假（0），结束当前循环语句。
| #include /******************************************* 循环打印9~0 **********************************************/ int main() { int num = 9; int data = 0; do{ printf("%d\n",num); }while(data++,num--); //num--后置自减 先引用后减1 printf("data:%d\n",data); return 0; } |
注：while和do-while的区别：
- 语句运行过程： while先判断后执行，do-while先执行后判断
- 语句运行次数： while可能会不执行；do-while至少会执行一次。
- 示例：打印9~0
| #include /******************************************* 循环打印9~0 **********************************************/ int main() { int num = 9; int data = 0; do{ printf("%d\n",num); }while(data++,num--); //num--后置自减 先引用后减1 printf("data:%d\n",data); return 0; } |
- for循环语句
- 语句关键字：for（为每个 for each）。
- 语句格式：
| for(语句1;语句2;语句3) { /* 循环体执行语句 */ } 语句1:初始化条件 初始化只运行一次; 语句2:判断条件 每循环一次判断一次; 语句3:修正条件 for(int I = 0 ; I < 10; I++) { /* 循环体执行语句 */ } |
| 示例循环打印0-9数值: #include int main() { //C89不支持中间定义变量 int i ; for(i = 0; i < 10 ;i++) { printf("%d\n",i); } //C99支持中间定义变量 for(int i = 0; i < 10 ;i++) { printf("%d\n",i); } return 0; } |
- 语句含义：
- 语句1： 循环变量的初始化，如果循环变量已经被赋值了，可以省略不写,只写“;”即可；
| #include int main() { //C89不支持中间定义变量 // 循环变量的初始化，如果循环变量已经被赋值了，可以省略不写,只写“;”即可； int i = 0 ; for( ; i < 10 ;i++) { printf("%d\n",i); } return 0; } |
- 语句2： 循环条件表达式，规定了执行循环的条件；
| #include int main() { //C89不支持中间定义变量 // 循环变量的初始化，如果循环变量已经被赋值了，可以省略不写,只写“;”即可； int i = 0 ; for( ; ;i++) { printf("%d\n",i); } return 0; } 使用组合键:ctrl+c终止程序运行； |
- 语句3： 对循环变量进行操作。
| #include int main() { //C89不支持中间定义变量 // 循环变量的初始化，如果循环变量已经被赋值了，可以省略不写,只写“;”即可； int i = 0 ; for(; ;) //===while(1) { printf("%d\n",i); } return 0; } |
- 语句执行过程： 首先根据语句1赋予循环变量的初值，按照语句2的条件表达式的规则，判断是否满足循环条件，如果满足，就执行循环体执行语句，循环体执行语句执行完后，根据语句3对循环变量进行相应的操作。
| #include int main() { int count = 0; //C89不支持中间定义变量 for(printf("初始条件\n");printf("循环条件\n");printf("修正条件\n")) { printf("循环体\n"); if(count > 1)break; count++; } return 0; } |
注：while循环的循环次数是不可知的，但循环的结果可知，一般主要用与未知次数的循环（只知道条件，不知道循环次数）或空语句的死循环；for循环的循环次数可知，但结果不可知（注重循环次数），一般用于已知次数的循环。
示例5：循环输入10个数，小于5时 打印 这个数；大于5 打印 超出范围
| #include int main() { int inputNum; //循环输入10个数，小于5时 打印 这个数；大于5 打印 超出范围 for(int i = 0 ;i < 10;i++) { printf("请输入一个数值:\n"); scanf("%d",&inputNum); inputNum < 5?printf("%d\n",inputNum):printf("超出范围\n"); } return 0; } |
练习7：求1～N之间的奇数之和（N为键盘上输入的数值），分别用while、do-while和for来实现。
| While()循环示例: #include int main() { int inputNum,sum = 0 ,at_i= 0 ; //求1～N之间的奇数之和（N为键盘上输入的数值），分别用while、do-while和for来实现。 printf("请输入一个N值\n"); scanf("%d",&inputNum); while(at_i <= inputNum) { if(at_i %2 != 0 ) { sum += at_i; } at_i++; } printf("%d\n",sum); return 0; } |
| Dowhile()循环示例: #include int main() { int inputNum,sum = 0 ,at_i= 0 ; //求1～N之间的奇数之和（N为键盘上输入的数值），分别用while、do-while和for来实现。 printf("请输入一个N值\n"); scanf("%d",&inputNum); do { if(at_i %2 != 0 ) { sum += at_i; } at_i++; }while(at_i <= inputNum); printf("%d\n",sum); return 0; } |
| For循环示例: #include int main() { int inputNum,sum = 0 ,at_i= 0 ; //求1～N之间的奇数之和（N为键盘上输入的数值），分别用while、do-while和for来实现。 printf("请输入一个N值\n"); scanf("%d",&inputNum); for(at_i = 0;at_i <= inputNum;at_i++) { if(at_i %2 != 0 ) { sum += at_i; } } printf("%d\n",sum); return 0; } |
1.14.3 转移语句(控制语句)
- break语句
- 语句关键字：break（打断、终止），放在循环语句体内，用于提前终止当前的循环操作。
- 语句格式：break;
注：一个break只能结束一个循环语句，break会结束靠近它的循环语句（就近原则）。break不能结束if语句，但可以使用if来控制break的发生，实现次数和结果的双重控制。
| #include int main() { //注：一个break只能结束一个循环语句，break会结束靠近它的循环语句（就近原则）。break不能结束if语句，但可以使用if来控制break的发生，实现次数和结果的双重控制。 for(int i = 0;i <= 10;i++) { printf("i:%d\n",i); if(i == 5 ) { break; } } return 0; } |
| #include int main() { //注：一个break只能结束一个循环语句，break会结束靠近它的循环语句（就近原则）。break不能结束if语句，但可以使用if来控制break的发生，实现次数和结果的双重控制。 for(int f = 0 ;f < 10 ; f++) { for(int i = 0;i <= 10;i++) { printf("i:%d\n",i); if(i == 5 ) { break; //就近原则:for(int i = 0;i <= 10;i++) } } } return 0; } |
| 易错点: #include int main() { //注：一个break只能结束一个循环语句，break会结束靠近它的循环语句（就近原则）。break不能结束if语句，但可以使用if来控制break的发生，实现次数和结果的双重控制。 for(int f = 0 ;f < 10 ; f++) { for(int i = 0;i <= 10;i++) { printf("i:%d\n",i); switch(i) { case 5: break;break; //这种写法错误 } } } return 0; } |
- continue语句
- 语句关键字：continue（继续，中止，继续下一次），放在循环语句体内，用于提前中止结束本次的循环操作。
- 语句格式：continue;
注：break是停止整个的循环语句的运行，而continue是不会结束整个循环语句，只会结束当前这一次循环体的执行过程。
| #include int main() { for(int i = 0;i <= 10;i++) { if(i == 5) { continue; } printf("i:%d\n",i); } return 0; } |
- return语句
- 语句关键字：return（返回），放在函数体内，用于结束函数的运行（如果是在主函数的内部，则就会结束整个程序）。
- 语句格式：return、return表达式/变量/常量值。例如：return (a + b)、return 0、return val、return;
注：break主要用于结束循环语句，而return主要用于结束函数(函数) return结束程序(主函数)。return除了可以结束函数以外，还可以返回一个数据给上一级函数。(在函数时具体讲解)
| #include int main() { for(int i = 0;i <= 10;i++) { if(i == 5) { return 1; } printf("i:%d\n",i); } printf("return前\n"); return 0; } |
- goto语句
- 语句关键字：goto（去哪），主要用于让程序无条件跳转到指定的标签位置，然后开始往下执行语句。
- 语句格式：
标签名:
程序段…..；
goto 标签名;
| #include int main() { for(int i = 0;i <= 10;i++) { if(i == 5) { goto P1; } printf("i:%d\n",i); } printf("P1前\n"); P1: printf("return前\n"); return 0; } |
注：标签名本质意义上是一个标识符，给跳转做一个位置的标记。跳转位置的标签名后面需要跟“:”，跳转标签名后跟“;”
- 语句应用：
- 往下跳转：忽略某些语句，让某些语句不执行，类似选择结构的效果，常用于快速的跳出多层循环体。
- 往上跳转：让某些语句重复执行多次，类似循环结构的效果，常用于模拟循环结构。
注：由于goto是一种无条件跳转，在底层驱动级程序中能不用就不要用，如果使用了，不要使用过多的goto标签。在系统级程序中，不建议使用goto。
| #include int main() { printf("P1前\n"); P1: printf("return前\n"); goto P1; return 0; } |
练习：
- 使用break实现求1～100之间能把17整除的最大值。
| #include int main() { int i; //1、使用break实现求1～100之间能把17整除的最大值。 for( i =100; i >= 0; i--) { if(i %17 == 0) { break; } } printf("能把17整除的最大值:%d\n",i); return 0; } |
2、使用goto语句（不能用循环），求n的阶乘（n为输入值，最大值不超过13）。
N的阶乘就是从1到n之内所有数的乘积。
| #include int main() { int input,base =1,mul =1; //使用goto语句（不能用循环），求n的阶乘（n为输入值，最大值不超过13）。N的阶乘就是从1到n之内所有数的乘积。 //10! 10*9*8*7*6*5*4*3*2*1 printf("请输入一个数值:\n"); scanf("%d",&input); P1: mul = mul *base; if(base == input )goto P2; base++; goto P1; P2: printf("%d\n",mul); return 0; } |
1.14.4课程回顾
- 数据类型 ->运算符->九条语句
- 数据:数据类型 算法:九条语句+运算符
- C语言中程序结构:顺序结构 0条(从上到下 自左向右运行)
- 条件选择语句: if else if else(关系 逻辑值 范围) switch acse break(确定的数值)
- 循环语句:不达目的不罢休while() do{} while(); for(;;) 都可以省略
- 转移语句:break continue return goto