2022C语言知识点大全【详细、必备】

超、凢脫俗 2024-03-31 12:18 73阅读 0赞

#### C语言期末必背知识点汇总【全】 ####

*   *  C语言最重要的知识点（一）《图片彩版》
     *  《C语言程序设计》必背基本知识点（二）
     *  C语言程序设计复习资料（三）

### C语言最重要的知识点（一）《图片彩版》 ###

`建议收藏！方便下次再看哦！`  
![在这里插入图片描述][19b46069e7ef4da0865ee4a9a62ac913.png]  
`整理不易，喜欢的点赞收藏哦！`  
![在这里插入图片描述][85f353f7daed4bf18adaf603551ccf0c.png]  
![在这里插入图片描述][05aee9ec72a44e5ba7ff3a7cd72afc97.png]  
![在这里插入图片描述][967ea3cd88104b0fbd17f16fc00877a2.png]  
![在这里插入图片描述][5919082ca94444699107aea93543adea.png]  
![在这里插入图片描述][00eefec4eae74cc1bff8cfcba4dc4fff.png]  
![在这里插入图片描述][1ef11838488d49e98d87e8e0f4f0f787.png]  
![在这里插入图片描述][28aeede12c084693bf92da9e4274f383.png]  
![在这里插入图片描述][40dcba7ce9a84fbaac88a1dace376939.png]  
![在这里插入图片描述][1024fab9f7e64fcdba9a80dd6f960fb1.png]  
![在这里插入图片描述][01a946f70ed0491a8b044006ae27505e.png]  
![在这里插入图片描述][b70d4d647d81452eba9a5ae27a86b07f.png]  
![在这里插入图片描述][07cc65652e1940dca2259440254d319c.png]  
![在这里插入图片描述][d2914727f9f244ba813573f09e254107.png]  
![在这里插入图片描述][508566c936b747a69ac1a08faf1b5e5f.png]  
![在这里插入图片描述][bbc80f5995034e60960a999cb32b4df7.png]  
![在这里插入图片描述][d01a88b83cd7412789115c490c3e9bbe.png]  
![在这里插入图片描述][c0efdff19e38486b87adfa0d1f62de7a.png]  
![在这里插入图片描述][c2f22a2aad7e4e92a8258a30fbb596f6.png]  
![在这里插入图片描述][fc913d2285b849e98c8ca44a98aac8ad.png]

### 《C语言程序设计》必背基本知识点（二） ###

**第一章 C语言基本知识**  
**1.C源程序的框架**  
尽管各个C源程序的功能千变万化，但框架是不变的，主要有：编译预处理、主函数()、函数n()等，主函数的位置不一定在最前面，可以在程序的中部或后面，主函数的名字固定为main。

**2.C语言源程序的书写规则：**  
(1)C源程序是由一个主函数和若干个其它函数组成的。  
(2)函数名后必须有小括号，函数体放在大括号内。  
(3)C程序必须用小写字母书写。  
(4)每句的末尾加分号。  
(5)可以一行多句。  
(6)可以一句多行。  
(7)可以在程序的任何位置加注释。

**3.语句种类**  
语句是程序的基本成分，程序的执行就是通过一条条语句的执行而得以实现的，根据表现形式及功能的不同，C语言的基本语句可以分为五大类。  
**(1)流程控制语句**  
流程控制语句的功能是控制程序的走向，程序的流程有三种基本结构：顺序结构、分支结构和循环结构，任何复杂的程序都可以由这三种基本结构复合而成。其中后两种结构要用特定的流程控制语句实现。  
**(2)表达式语句**  
表达式语句的形式是：表达式；，即表达式后跟一分号“；”，分号是语句结束符，是一个语句必不可少的成分。表达式和表达式语句的区别在于表达式代表的是一个数值，而表达式语句则代表一种动作。最常见的表达式语句是赋值语句。  
**(3)函数调用语句**  
函数调用语句实际上也是一种表达式语句，形式为：在一次函数调用的小括号后面加上一个分号。  
**(4)空语句**  
空语句的形式就是一个分号，它不代表任何动作，常常作为一个意义转折点使用。  
**(5)复合语句**  
复合语句从形式上看是多个语句的组合，但在语法意义上它只相当于一个语句，在任何单一语句存在的地方都可以是复合语句。注意复合语句中最后一个语句末尾的分号不能少。复合语句右大括号后面没有分号。  
**4.运算符**  
用来表示数据各种操作的符号称为运算符。运算符实际上代表了一种类型数据的运算规则。不同的运算符具有不同的运算规则，其操作的数据类型必须符合该运算符的要求，运算结果的数据类型也是固定的。  
根据参加操作的数据个数多少，可以将C语言的运算符分为单目运算符，双目运算符和三目运算符(三目运算符只有条件运算符一个)。  
根据运算对象和运算结果的数据类型可分为算术运算符、关系运算符、逻辑运算符等。  
**5.表达式**  
表达式是由常量、变量、函数，通过运算符连接起来而形成的一个算式。一个常量，一个变量或一个函数都可以看成是一个表达式。  
表达式的种类有：  
算术表达式、关系表达式、逻辑表达式、赋值表达式、字位表达式、强制类型转换表达式、逗号表达式(顺序表达式)、条件表达式、指针表达式。  
**6.数据的输入/输出**  
C语言本身没有输人/输出语句，数据的输入/输出是通过调用库函数来实现的。

**第二章 数据类型知识点**  
划分数据类型的意义是编译系统对每个不同类型的数据在内存中分配的字节数不同，不同类型的数据可以按规定参加不同类型的运算。  
**1.C语言的数据类型**  
数据类型有：整型、字符型、实型单精度型、双精度型、构造类型数组类型、结构体类型、共用体类型、枚举类型、指针类型、空类型，其中整型、实型、字符型是C语言中的基本类型。  
**2.各种类型数据的定义方法**  
定义形式：数据类型 变量名1，变量名2，……变量名n；  
**3.常量与变量**  
(1)常量——在程序执行期间其值不变的量。它不能被赋值。  
(2)变量——在程序运行期间其值可以改变的量。  
**4.各种类型数据的混合运算**  
各类数据运算前会自动转换成同一类型。规律如右图示：从右向左的箭头表示必定的转换，如float型数据运算前化成double型，以提高运算精度，结果也为double型，short或char型数据运算前化成int型，结果也为int型；从下向上的箭头表示转换方向是向级别高的靠拢。  
**5.强制类型变换**  
当我们需要对数据进行类型变换，而机器又不能自动完成时，就要用强制类型变换，形式为：(数据类型符)(被转换对象)。

**第三章 选择知识点**  
C语言中实现选择结构的控制语句有两种：条件分支语句if和开关分支语句switch。  
**1.if语句的三种形式：**  
(1) if(表达式)语句；  
(2) if(表达式)语句1;  
else语句2;  
(3) if(表达式1)语句1;  
else if(表达式2)语句2;  
else if(表达式3)语句3;  
…  
else if(表达式n)语句n;  
**2.开关分支语句switch**  
(1)形式  
switch(表达式)  
\{ case e1:语句1；break;  
case e2:语句2；break;  
case e3:语句3；break;  
……  
case en:语句n；break;  
default :语句n+1;  
\}  
(2)功能  
当表达式的值等于e1时，执行语句1；  
当表达式的值等于e2时，执行语句2；  
……  
当表达式的值等于en时，执行语句n；  
当表达式的值与常量e1、e2……en谁都不等时，就执行default后的语句

**第四章 循环知识点**  
循环就是在程序执行过程中，反复多次的执行同一段程序。C语言中有三种循环语句。  
**1.while循环语句**  
形式为：while(表达式)  
\{  
循环体  
\}；  
执行过程是：先计算表达式的值，当表达式的值非0时就执行循环体，之后再判断表达式的值，且重复以上过程；当表达式的值为0时就结束循环。  
**2.do-- while循环语句**  
形式为：do  
\{  
循环体  
\} while(表达式)；  
执行过程是：先执行循环体一次，再判断表达式的值，当表达式的值非0时就再执行循环体，之后再判断表达式的值，且重复以上过程；当表达式的值为0时就结束循环。  
**3.for循环语句**  
形式为：for(表达式1;表达式2;表达式3)  
\{ 循环体 \}  
**4.三种循环语句的比较**  
三种循环语句可以完成同一件事，可任选其一。  
使用while和do-- while循环时，要提前给循环变量赋初值。而for循环是在表达式1中赋初值的。  
while循环和for循环都是先判断条件后执行循环体，有可能一次也不执行循环体，do-- while循环是先执行循环体，后判断条件，即循环体至少也得执行一次。for循环不限于计数循环，其循环条件可以是逻辑表达式和字符表达式等。  
**5.循环嵌套**  
三种循环控制语句可以互相嵌套，即在一个循环体内部又可以出现另一循环，这种嵌套在理论上来说可以是无限的。注意必须是一个循环完整的套住另一个循环。  
**6.break语句**  
break语句只能出现在三种循环语句和switch多分支语句中，其作用是用来中断这四种语句的执行。当程序执行到break语句时，会跳出break语句所在的循环或switch分支，而直接执行紧跟在它们后面的语句。  
**7.continue语句**  
continue语句只能出现在三种循环语句中，当程序执行到continue语句时，其作用是提前结束本次循环，自动跳过循环体中后半部剩余的语句的执行，而直接回到循环条件判断。根据判断的结果决定是否继续执行下次循环。  
**8. goto 语句**  
goto语句是一种非结构化语句，其作用是使程序的执行无条件的转移到某一处。使用格式为: goto 标号；利用goto语句与if条件语句配合，也可以实现条件循环。C语句允许在任何语句前添加标号，作为跳转目标，标号的构成是标识符后面加一个":"。

**第五章 数组知识点**  
数组就是同类型的一批数据的集合，用一个变量名存放，区分各元素的办法是用下标。  
**1.一维数组**  
类型说明符数组名\[数组长度\]；  
(1)数组命名要符合标识符的命名规则。  
(2)数组名后的括号必须是方括号，不能是圆括号。  
(3)数组长度必须是正整数,可以是个表达式，但不能有变量，C语言不支持动态数组。  
(4)数组长度表示数组中元素的个数  
(5)数组元素的下标从0开始数，所以最大下标是数组的长度减1。  
**2．多维数组(以二维为例)**  
类型说明符数组名\[第一维长度\]\[第二维长度\]；  
(1)数组命名要符合标识符的命名规则。  
(2)数组名后的括号必须是两个方括号，定义时不能写成inta\[3，4\]；。  
(3)数组长度必须是整型常量表达式。  
(4)第一维长度表示数组行数，第二维长度表示数组列数。  
(5)每个数组元素都有两个下标，第一维表示该元素所在的行，第二维表示该元素所在的列，每一维的下标都从0开始数。  
二维数组的初始化：C语言规定只有静态数组和外部数组才允许在定义时赋初值，赋初值形式如下：  
static类型说明符数组名\[第一维长度\]\[第二维长度\]=\{初值表\}；  
二维数组的引用：二维数组不能整体引用，要引用数组的单个元素，形式为：数组名\[下标\]\[下标\]和普通变量的使用无任何区别。  
**3．字符数组**  
C语言中没有字符串变量，字符串是靠字符数组实现的，所谓字符数组就是元素的数据类型为字符型的数组。  
(1)字符数组的定义形式：char数组名\[数组长度\]；  
因为C语言中的整型数据和字符型数据是相通的，所以也可以这样定义：int数组名\[数组长度\]；  
(2)字符数组的初始化：给字符数组的初始化有两种方式，一种是用字符常量，另一种是用字符串。形式如下：  
staticchar数组名\[数组长度\]=\{字符常量表\}；  
staticchar数组名\[数组长度\]=\{字符串常量\}；  
**4.数组与函数**  
数组经常作为函数的参数，数组做函数的参数有两种形式，一是数组元素做函数的参数，一是数组名做函数的参数，当用数组名做函数的实参时传送的是首地址。  
5.常用的字符串处理函数  
C语言提供了一些处理字符串的标准函数，用以完成一些常见的操作。对以下几个函数要掌握其功能和调用形式。  
(1)gets(字符数组名)此函数功能是从键盘输入一串字符，回车后送到字符数组中，注意定义数组时数组长度要足够大。  
(2)puts(字符数组名)此函数功能是将字符数组的内容输出到屏幕上。  
(3)strcat(字符数组名1，字符数组名2)此函数功能是将字符数组1中的’\\0’去掉后将字符数组2的内容连接到字符数组1的末尾。  
(4)strcpy(字符数组名1，字符数组名2)函数功能是将字符数组2的内容(包括’\\0’)拷贝到字符数组1中，字符数组2处也可以是字符串常量。strcpy函数可以实现拷子串。  
(5)strcmp(字符数组名1，字符数组名2)函数功能是两个字符串(ASCII码)比大小。  
(6)strlen(字符数组名)此函数功能是求字符串的长度，注意不包括’\\0’。  
(7)strlwr(字符数组名)此函数功能是将字符串中的所有大写字母都变成小写。  
(8)strupr(字符数组名)此函数功能是将字符串中的所有小写字母都变成大写。

**第六章 函数知识点**  
每个C源程序都是由函数组成的，一个主函数和若干个其它函数，C语言程序设计的基础工作就是函数的具体编写，C语言中的函数就相当于其它高级语言中的子程序。  
**1.函数的概念**  
函数就是一个数据加工厂,从函数外部接收数据，在函数内部加工处理，然后得到一个结果返回给外部的调用者。所以函数就是对语言功能的扩充，对函数的调用就是对功能的调用。  
**2.标准函数**  
各种高级语言都定义了一些标准函数，C语言中的标准函数称为库函数，是将一些基本的、常用的功能编成了函数，供大家使用方便。使用库函数时必须把它的头文件用\#include命令包含进来，每个库函数的功能及对应的头文件都会在手册中给出。  
**3.自定义函数**  
C 语言也允许用户自己编写函数以实现C库函数中没有提供的功能，称作自定义函数。  
**4．定义函数**  
C语言规定每个函数都要独立定义,函数定义不能嵌套。  
函数定义的形式：数据类型函数名(形参表)  
形参说明语句序列  
\{ 说明语句序列  
可执行语句序列 \}  
**5．函数调用**  
函数调用的形式是： 函数名(实参表)。当实参表中有多个参数时，要用逗号隔开，若被调函数无参数，调用时小括号也不能省。函数调用过程是:将实参的值传给形参，在函数体内进行加工处理，然后由return语句将函数值返回调用处。  
**5．全局变量和局部变量**  
局部变量：在函数内部定义的变量称为局部变量，只在本函数中有效。  
全局变量：在函数外部定义的变量称为全局变量，它的作用范围是从定义开始到本文件结束。  
**6．动态存储与静态存储**  
内存中的用户数据区分为动态存储区和静态存储区，动态存储区是指程序运行期间给变量临时分配存储单元，变量用完后立即释放单元的区域，动态存储区放的是函数的形参、自动变量、函数调用期间的现场保护数据和返回地址。  
静态存储区是指程序运行期间给变量分配固定的存储单元，放的是全局变量和局部静态变量。  
一个变量除了它的数据类型以外还有存储类型，定义一个变量时应该说明这两种类型。

**第七章 预处理知识点**  
对高级语言编译连接就是把源程序转换成机器语言，C语言在进行编译之前还要预先处理三件事：宏定义命令、文件包含命令和条件编译命令，统称为预处理命令，其特点是：  
1.所有的预处理命令都放在程序的头部，以\#开头，且\#号后面不留空格。  
2.预处理命令不是C的语句，行尾不加分号。  
3.预处理命令是在编译预处理阶段完成的，所以它们没有任何计算、操作等执行功能。  
4.预处理命令有所变动后，必须对程序重新进行编译和连接。  
**1．宏定义**  
宏定义命令的作用是给一些常用的对象重新命名，在程序中可以用宏名来引用这些对象，预处理时宏名会被代表的内容替换，此过程称为宏展开或宏替换。宏定义有两种形式：  
**2．文件包含**  
使用文件包含命令可以将另—个C源程序的全部内容包含进来，其形式为：  
\#include ＜文件名＞或\#include “文件名”  
通常可以把经常用到的，带公用性的一些函数或符号等集合在…起形成一个源文件，然后用此命令将这个源文件包含进来，这样可以避免在每个新程序中都要重新键入这些内容。  
**3．条件编译**  
顾名思义满足条件时进行编译，为了解决程序移植问题，C语言提供了条件编译命令，它能使源程序在不同的编译环境下生成不同的目标代码文件。条件编译命令有3种形式。

**第八章 指针知识点**  
**1.什么是指针和指针变量？**  
指针就是内存地址，因为通过“地址”可以找到变量，所以内存“地址"形象的称为指针。  
指针变量就是存地址的变量。在C语言中用一个变量存另一个变量的地址，那么就称这个变量为指针变量，指针变量的值就是地址。通常指针变量被简称为指针。  
指针变量是有类型的，即指针值增1表示指向下一个数据，如整型数据在内存中占两个字节，它的指针变量增1是增两个字节。如实型数据在内存中占4个字节，它的指针变量增1是增4个字节。  
**2.怎样定义指针变量？**  
定义形式为：数据类型*指针变量名1，指针变量名2……；  
**3.指针的有关运算**  
指针为内存地址是整数，可以进行一些算术运算、关系运算、赋值运算、特殊运算等，但要注意运算代表的实际意义。  
**4．指向数组的指针变量**  
(1)指向数组元素的指针变量定义形式为：inta\[10\];  
intp=a;  
(2)指向一维数组的指针变量  
定义形式为：inta\[3\]\[4\];  
int(p)\[4\];  
p=a;  
(3)指向字符串的指针变量  
定义形式为： charp=“字符序列”；  
C语言中的字符串是以隐含形式的字符数组存放的，定义了指针变量p并不是将整个字符串都存放在p中了，而p中存放的是字符串的首地址。  
**5．指向函数的指针变量**  
一个函数在编译时被分配一个入口地址，这个地址就是函数的指针，可以用一个指针变量指向它。指向函数的指针变量定义形式为：  
数据类型(指针变量名)；  
**6.指针变量做函数的参数**  
(1)指针作函数的参数可以传送地址，如数组的首地址，函数的入口地址等。  
(2)指针作函数的参数也可以用地址方式传送数据。  
**7．返回值是指针的函数**  
即函数的返回值是内存的地址，利用这种方法可以将一个以上的数据返回给函数的调用者。定义形式如下：  
数据类型函数名（形参表）  
**8.指针数组**  
定义形式为：数据类型*数组名\[数组长度\]；  
数组中的每个元素都是指针类型的数据，这种数组被称为指针数组。  
**9.指向指针的指针**  
定义形式为：数据类型\*\*指针变量名；  
指向指针数据的指针变量称为指向指针的指针。  
**10.main函数的形参**  
main函数可以带两个形参，如：  
main(argc,argv)  
intargc；  
char *argv\[\]；  
\{  
……  
\}  
**11.指向结构体的指针变量**  
结构体变量的指针就是该变量所占据的内存段的首地址。指向结构体的指针变量定义形式为：struct结构体类型名*指针变量名；  
**12.指向共用体的指针变量**

共用体变量的指针就是该变量所占据的内存段的首地址。指向共用体的指针变量定义形式为：union共用体类型名\*指针变量名；  
替换了的字符时(这里为正中间的字符"4")，原来的字符己不复存在。  
第九章 结构体与共用体知识点  
结构体类型是C语言的一种构造数据类型，它是多个相关的不同类型数据的集合，相当于其它高级语言中的记录。

**1.结构体类型定义**  
结构体类型的形式为：  
struct结构体类型名  
\{ 数据类型成员名1；  
…  
数据类型成员名n；  
\}  
**2.结构体变量的定义**  
结构体变量有三种定义形式：  
(1)先定义结构体类型，后定义结构体变量。  
(2)定义结构体类型的同时定义结构体变量。  
(3)不定义结构体类型名，直接定义结构体变量。  
**3.结构体变量的引用**  
(1)结构体变量的初始化：许多C版本规定对外部或静态存储类型的结构体变量可以进行初始化，而对局部的结构体变量则不可以，新标准C无此限制，允许在定义时对自动变量初始化。  
(2)结构体成员的引用：由于C语言一般不允许对结构体变量的整体引用，所以对结构体的引用只能是对分量的引用，结构体变量中的任一分量可以表示为：结构体变量名·成员名  
**4.结构体与数组**  
C语言中数组的成员可以是结构体变量，结构体变量的成员也可以是数组。  
结构体数组有三种定义形式：  
(1)先定义结构体类型，后定义结构体数组。  
(2)定义结构体类型的同时定义结构体数组。  
(3)不定义结构体类型名，直接定义结构体变量。  
**5.结构体与指针**  
一方面结构体变量中的成员可以是指针变量，另一方面也可以定义指向结构体的指针变量，指向结构体的指针变量的值是某一结构体变量在内存中的首地址。  
结构体指针的定义形式:struct结构体类型名\*结构体指针变量名。  
由结构体指针引用结构体成员的方法  
**6.用指针处理链表**  
结构体的成员可以是指针类型，并且这个指针类型就是本结构体类型的，这样可以构造出一种动态数据结构—成为链表。所谓动态数据就是指在编译时不能确定数据量的多少，而是在程序执行时才确定的数据，动态数据可以比较方便的进行数据插人或删除等操作。  
**7.结构体与函数**  
结构体变量的成员可以作函数的参数、指向结构体变量的指针也可以作函数的参数。虽然结构体变量名也可以作为函数的参数，将整个结构体变量进行传递，但一般不这样做，因为如果结构体的成员很多，或者有些成员是数组，则程序运行期间，将全部成员一个一个的传递，既浪费时间，又浪费空间，开销太大。  
**8.结构体与共用体**  
结构体变量中的成员可以是共用体，共用体变量中的成员可以是结构体。  
共用体  
为了节省存储空间，C语言允许将几种不同类型的数据存放在同一段内存单元，它们共用一个起始地址，称做共用体。  
**1.共用体类型定义**  
union共用体类型名  
\{ 数据类型成员名1;  
…  
数据类型成员名n；  
\}  
**2.共用体变量定义**  
(1)先定义类型，后定义变量。  
(2)定义类型的同时定义变量。  
(3)不定义类型名，直接定义变量。  
**3.共用体变量的引用**  
(1)共用体变量不能整体引用，只能引用其成员，形式为：共用体变量名·成员名  
(2)共用体变量的成员不能初始化，因为它只能放一个数据。  
(3)共用体变量存放的数据是最后放入的数据。  
(4)共用体变量的长度是最大的成员的长度。  
(5)可以引用共用体变量的地址、各个成员的地址，它们都是同一个地址。  
(6)共用体变量不能当函数的参数或函数的返回值，但可以用指向共用体变量的指针作函数的参数。  
(7)共用体变量的成员可以是数组，数组的成员也可以是共用体变量。

**第十章 位运算知识点**  
位运算就是按二进制位进行操作的运算，运算的对象只能是整型或字符型，不能是实型。不同长度的变量进行位运算，系统会自动右对齐，而左端的不齐部分，对于无符号数左端补满0，对于有符号数则：正数左端补满0，负数左端补满1。

**第十一章 文件知识点**  
操作系统是以文件为单位对数据进行管理的，任何一种计算机高级语言都要有和磁盘文件打交道的能力，否则该语言的功能充其量是算一算、显示显示而已。在C语言中没有单独的文件操作语句，所有对文件的操作都是通过库函数来完成的，所以本章的重点是学会使用有关文件操作的库函数。  
1.文件的基本概念  
2.文件类型指针  
3.文件的操作

### C语言程序设计复习资料（三） ###

**一、C 语言的特点：**

1、C 语言源程序的基本组成单位是函数；一个 C 程序可由若干个函数组成，其中必须有且仅有一个以 main 命名的主  
函数，其余的函数名称可由编程者自行设定。

2、C 程序的执行总是由 main()函数的第一个可执行语句开始，到 main（）函数的最后一个可执行的语句结束；而其他  
函数都是在 main（）函数开始执行以后，通过其他函数的调用才得以运行。

3、C 语言系统提供了丰富的库函数，用户在程序中需要调用某个库函数时，必须用\#include 编译预处理命令将描述该  
库函数的头文件包含进去。

**二、C 程序的书写格式：**  
**1、语句可从分开放在任意多行内；**  
如：printf(“To C,”);  
printf(“ or not to C:”);  
与 printf(“To C , or not to C:”);是等价的  
**2、一行中可以有若干个语句；**  
如：a=123;b=345;  
**3、每个语句和数据定义的最后必须有一个分号；**  
**三、C 语言程序的运行：**  
\*\*1、编译(Compile)：\*\*将 C 源程序文件翻译成能被计算机识别的二进制形式的“目标”文件；编译时，编译器将检查源程  
序每一条语句的语法错误。  
**2、建造(Bulid)：**  
C 语言程序示例：显示“Hello” \#include<stdio.h>

int main(void)
    {
        
    printf(“Hello.\n”);
    return 0;
    }

**说明：**\#include<stdio.h> 是必不可少的，它包含了 C 语言标准输入输出库的相关信息；  
printf 函数来自”标准输入输出库”，可以产生格式化输出；  
\\n 告诉 printf 函数执行完信息显示后要进行换行操作；  
return 0 表明程序终止时会向操作系统返回值 0；  
\{ \}来标出 main（）函数的起始和结束。  
02.数据类型  
**一、C 语言的特点：**  
1、C 语言源程序的基本组成单位是函数；一个 C 程序可由若干个函数组成，其中必须有且仅有一个以 main 命名的主  
函数，其余的函数名称可由编程者自行设定。  
2、C 程序的执行总是由 main()函数的第一个可执行语句开始，到 main（）函数的最后一个可执行的语句结束；而其他  
函数都是在 main（）函数开始执行以后，通过其他函数的调用才得以运行。  
3、C 语言系统提供了丰富的库函数，用户在程序中需要调用某个库函数时，必须用\#include 编译预处理命令将描述该  
库函数的头文件包含进去。  
**二、C 程序的书写格式：**  
1、语句可从分开放在任意多行内；  
如：printf(“To C,”);  
printf(“ or not to C:”);  
与 printf(“To C , or not to C:”);是等价的  
2、一行中可以有若干个语句；  
如：a=123;b=345;  
3、每个语句和数据定义的最后必须有一个分号；  
**三、C 语言程序的运行：**  
\*\*1、编译(Compile)：*将 C 源程序文件翻译成能被计算机识别的二进制形式的“目标”文件；编译时，编译器将检查源程  
序每一条语句的语法错误。  
**2、建造(Bulid)：**  
C 语言程序示例：显示“Hello” \#include<stdio.h>  
int main(void)  
\{  
printf(“Hello.\\n”);  
return 0;  
\}  
**说明：**\#include<stdio.h> 是必不可少的，它包含了 C 语言标准输入输出库的相关信息；  
printf 函数来自”标准输入输出库”，可以产生格式化输出；  
\\n 告诉 printf 函数执行完信息显示后要进行换行操作；  
return 0 表明程序终止时会向操作系统返回值 0；  
\{ \}来标出 main（）函数的起始和结束。  
**03,运算符和表达式**  
1、算术运算符和表达式  
\+：加法运算符，如 3＋5；  
\-：减法运算符，如 5-3；  
：乘法运算符，如 58；  
/：除法运算符，如 3/6；参与运算量均为整型时，结果也为整型，舍去小数；若运算量中有一个是实型，则结果为  
双精度实型。  
%：模运算符，也称“取余运算符”，用于计算两数相除后的余数，如 5%3=2；  
**2、赋值运算符和赋值表达式**  
赋值运算符：”＝”，其作用是将一个表达式的值赋给一个变量；  
其一般形式为：变量=表达式  
如：  
x=a+b;  
赋值表达式的功能是计算表达式的值再赋予左边的变量。赋值运算符具有右结合性。因此 a=b=c=5 可理解为  
a=(b=(c=5));  
复合赋值运算符：+=、-=、=、/=、%=、>>=、<<=、&=、^=、|= 构成复合赋值表达式的一般形式为：变量 双目运算符=表达式  
它等价于：变量=变量 运算符 表达式  
如：  
a+=5 等价于 a=a+5  
x=y+7 等价于 x=x(y+7)  
r%=p 等价于 r=r%p  
**3、类型转换**  
如果赋值运算符两边的数据类型不相同，系统将自动进行类型转换，即把赋值号右边的类型换成左边的类型。具体规定如  
下：  
1)实型赋予整型，舍去小数部分。前面的例子已经说明了这种情况。  
2)整型赋予实型，数值不变，但将以浮点形式存放，即增加小数部分(小数部分的值为 0)。  
3)字符型赋予整型，由于字符型为一个字节，而整型为二个字节，故将字符的 ASCII 码值放到整型量的低八位中，高  
八位为 0。整型赋予字符型，只把低八位赋予字符量。  
**4、自增、自减运算符：**  
自增运算符：“++”，功能是将变量的值加 1；  
自减运算符：“–”，功能是将变量的值减 1；  
可有以下几种形式：  
\++i i 自增 1 后再参与其它运算。  
–i i 自减 1 后再参与其它运算。  
i++ i 参与运算后，i 的值再自增 1。  
i-- i 参与运算后，i 的值再自减 1。  
注：  
（1）”++”、”–“的操作对象只能是变量；  
(2)”++”、”–“运算优先级相同，且结合方向自右向左；-i++应理解为-（i++），  
【例】自增、自减运算、  
\#include<stdio.h>  
main()  
\{  
int i=8;  
printf(“%d\\n”,++i); /* i 先加 1，再输出 i ，输出结果为 9 */  
printf(“%d\\n”,–i); /* i 先减 1，再输出 i ，结果为 8 */  
printf(“%d\\n”,i++); /* 先输出 i ，输出结果为 8，i 再加 1， */  
printf(“%d\\n”,i–); /* 先输出 i ，输出结果为 9，i 再减 1， */  
printf(“%d\\n”,-i++); /* 先加输出-i，输出结果为-8，i 再加 1 */  
printf(“%d\\n”,-i–); /* 先输出-i ，输出结果为-9，i 再减 1 */  
\}  
**5、求字节运算符**  
计算表达式的结果所占字节数或某种数据类型的定义字节数。  
一般格式：sizeof(数据类型标识符) 或 sizeof（表达式）  
如： sizeof（float）的值为 4，占 4 个字节；  
sizeof（2*3）的值为 2，占 2 个字节；  
**6、关系运算符和关系表达式**  
关系运算符：“<”(小于)、 “<=”(小于等于) 、”>”(大于)、”>=”(大于等于) 、” = =”（等于）、 “!=”（不等于）  
关系表达式：若关系表达式成立，其值为“真”，否则为“假”；在 C 语言中，用 0 代表“假”，用 1 代表“真”；  
**7、逻辑运算符和逻辑表达式：**  
逻辑运算符： “!” （非）、 “&&” （与）、 “||”（或）；运算优先级： !>&&>||  
逻辑表达式：用逻辑运算符将表达式连接起来的式子；逻辑表达式的结果仍然是逻辑量（“真”或“假”）  
**8、条件运算符：**  
一般格式： <表达式 1>?<表达式 2>:<表达式 3>  
先计算表达式 1，若表达式 1 的值为真，则计算表达式 2 的值，且表达式 2 的值为整个条件表达式的值；否则，计算  
表达式 3 的值，且表达式 3 的值即为整个条件表达式的值。  
**9、逗号运算符和逗号表达式**  
逗号运算符：”,”作为运算符，其功能是将多个表达式组成一个表达式；  
一般形式：表达式 1，表达式 2，…，表达式 n  
求解过程：先计算表达式 1，再计算表达式 2，依此计算表达式 n，最终，表达式 n 的值即为整个表达式的值。  
**04.顺序结构**  
**一、概述：**  
顺序语句按照语法形式分为：表达式语句、函数调用语句、复合语句、流程控制语句和空语句。  
**1、表达式语句：**  
语法格式：表达式；  
如：a+4；  
其中赋值语句为最典型的表达式语句，如：  
a=5;  
a=b+3;  
特别提示：分号（;）是表达式语句中不可缺少的一部分。  
**2、函数调用语句：**  
如：printf（”I am a student！”）;  
其中：printf()为系统提供的函数，用于显示信息。  
**3、复合语句：**  
所谓“复合语句”即由一对“\{\}”括起来的一组语句，也称“块语句”或“分程序”。  
一般形式为：  
\{  
语句 1  
语句 2  
… 语句 n  
\}  
如：  
\{  
i++;  
j=a+3;  
printf(“%d,j=”,i,j);  
\}  
特别提示：复合语句中的最后一条语句的分号不得缺少；复合语句的“\}”之后不得有分号。  
**4、空语句: “空语句”即为一个独立的分号。**  
如：  
main（）  
\{  
… ;  
… \}  
**二、数据的输入输出**  
C 语言提供了一些输入输出函数，如 printf()和 scanf()，在程序中调用这些输入输出函数时，必须将标准输入输出头文  
件“stdio.h”包含到用户所编写的源程序中。  
如：\#include <stdio.h>  
其中：\#include 命令一般写在程序的开头位置。  
**1、格式输入输出**  
**1、格式输出函数 printf()**  
(1)一般格式： printf(格式字符串，输出列表)  
其中：“格式字符串”包括“输出字符”和“格式控制字符”(由%和格式字符组成，指定输出项的输出格式）。  
• d 格式符：用于输出十进制整数；  
%d:以十进制形式显示输出变量的值；  
%5d：以十进制形式显示变量的值，且至少占用 5 个字符的空间，若不够 5 位数字，则左侧补空格；  
%-5d：以十进制形式显示变量的值，且至少占用 5 个字符的空间，左对齐；  
%5.3d：以十进制形式显示变量的值，且至少占用 5 个字符的空间并至少有 3 位数字,若不够 3 位数字，则左  
侧补 0；  
如：\#include<stdio.h>  
main()  
\{  
int i;  
i=40;  
printf(“%d\\n”,i);  
printf(“%5d\\n”,i);  
printf(“%-5d\\n”,i);  
printf(“%5.3d\\n”,i);  
\}  
• f 格式符：用于以小数形式输出实数；  
%10.3f:以定点十进制形式显示变量的值，且总共用 10 个字符，其中，整数位 6 位，小数位 3 位，小数点 1  
位；  
如：\#include<stdio.h>  
main()  
\{  
float x;  
x=839.21f;  
printf(“%10.3f\\n”,x);  
\}  
• c 格式符：用于输出一个字符；  
如： x=”a”,y =”b”, 则 printf(%c %c",x,y)的输出结果为：a b  
若变量的值为整数，则输出该整数值为 ASCII 码的字符：  
如 x=65,y=98，则 printf(“%c, %c”,x,y)的输出结果为： A, b;  
同理，一个字符的数据也可以以整数的形式输出；  
如 x=’a’,y=’B’，则 printf(“%d,%d”,x,y)的输出结果为：97,66  
• s 格式符：用于输出一个字符串。  
如：printf(“%s”,”I am a student !”) • e,E 格式符：用于以指数形式输出实数。  
如：printf(“%e”, 123.456)，则输出结果为：1.234560e+002; • g,G 格式符：用于输出实数，根据数值的大小自动选择 f 格式或 e 格式。  
**2、格式输入函数 scanf()**  
**(1)一般格式：**  
scanf(格式字符串，变量地址表)  
其中：格式字符串使用双引号括起来的字符串，包括“普通字符”（按原样输入）、“格式控制字符”（由%和格式  
字符组成，用来标定输入数据的格式）。  
变量地址表是由若干个变量地址组成的表列，可以是变量的地址，也可以使字符串的首地址。  
• d 格式：用于输入十进制整数；  
如：scanf(“%d,%d”,&x,&y);则输入格式为：123 ，3456  
•u 格式：用于输入十进制无符号整数；  
•f 格式：用于输入以小数形式的实数；  
如：scanf(“%f,%f”,&x,&y);则输入格式为：123.23,23.456  
•c 格式：用于输入一个字符；  
如:scanf(“%c,%c”,&x,&y);则输入格式为：a,b  
•s 格式：用于输入一个字符串；  
如：scanf(“%s”,a);假定 a 为字符数组，则输入格式为：abcdef  
注：输入的字符串中间不能包含空格。  
**特别说明：**  
• 对于变量，”&”加变量名即为该变量的地址；如：&a、&b 等分别表示变量 a 和变量 b 的地址；  
•对于字符串数组或字符指针型变量，数组名和指针变量名本身即为其地址；  
•可以在%和格式字符之间加表示位数的数字；如：scanf(“%5s”,p);表示只能输入 5 个字符给字符串指针 p；  
**3、字符数据的输入输出：**  
(1)putchar()函数：是向标准输入输出设备输出一个字符；  
其调用格式为：putchar(ch); 其中：ch 为一个字符变量或常量；  
putchar()函数作用等同于 printf(“%c”,ch)；  
(2)getch() getche()和 getchar()函数：  
•getch()：从键盘上读入一个字符，但不显示在屏幕上；  
•getche()：从键盘上读入一个字符，显示在屏幕上；  
•getchar()：从键盘上读入一个字符，并显示在屏幕上，但直到输入回车键时才结束输入，第一个字符为其函数的返  
回值。  
**05.选择结构**  
一、if 语句：  
一般格式：  
if(表达式) 语句；  
表示：当“表达式”成立时，则执行“语句”;否则跳过“语句”；  
如：if (a>b) printf(“a>b!”);  
例：若用户输入的数为 3 的倍数，则显示”OK” \#include<stdio.h>  
main()  
\{  
int a;  
scanf(“%d”,&a);  
if(a %3= =0) printf(“OK”);  
\}  
**二、if-else 语句：**  
一般格式：  
if (表达式)  
语句 1;  
else  
语句 2;  
例：给出用户输入的两个整数的较大者  
\#include<stdio.h>  
main()  
\{  
int a,b;  
scanf(“%d,%d”,&a,&b);  
if(a>b)  
printf(“the max=%d”,a);  
else  
printf(“ the max=%d”,b);  
\}  
**三、if 语句的嵌套**  
**1、if 子句中嵌套：**  
• if(表达式 1)  
if(表达式 2) 语句 1;  
else 语句 2;  
else 语句 3; • if(表达式 1)  
\{ if(表达式 2) 语句 1; \}  
else 语句 2;  
**2、else 子句中嵌套**  
• if (表达式 1) 语句 1;  
else  
if(表达式 2) 语句 2;  
else 语句 3; • if(表达式 1) 语句 1;  
else  
if(表达式 2) 语句 2;  
**3、嵌套一般格式：**  
if (表达式 1) 语句 1;  
else if (表达式 2) 语句 2;  
else if (表达式 3) 语句 3 ; …  
else if(表达式 n) 语句 n;  
else 语句 n+1;  
例：将用户输入的成绩按以下规则转换成等级成绩：  
分数： 90~100 等级：优  
分数： 80~89 等级：良  
分数： 70~79 等级：中  
分数： 60~69 等级：及格  
分数： 60 以下 等级：不及格

#include<stdio.h>
    main()
    {
        
    int d;
    printf(“输入分数：”);
    scanf(“%d”,&d);
    if(d>=90 ) printf(“优”);
    else if(d>=80) printf(“ 良”);
    else if(d>=70) printf(“ 中”);
    else if(d>=60) printf(“ 及格”);
    else printf(“ 不及格”);
    }

**四、条件语句：**  
表达式 1 ? 表达式 2 :表达式 3  
执行的过程：若表达式 1 的值为非 0 时，该条件语句的职位表达式 2，否则为表达式 3；  
例：求一个整数的绝对值

#include<stdio.h>
    main()
    {
        
    int i,absi;
    scanf(“%d”,&i);
    absi=i>0 ? i : -i;
    printf(“%d 绝对值是%d\n”,i,absi);
    }

**五、switch 语句**  
switch （表达式）  
\{  
case 常量表达式 1：  
语句 1 ;  
break;  
case 常量表达式 2：  
语句 2 ;  
break; …  
case 常量表达式 n：  
语句 n ;  
break;  
default:  
语句 n+1;  
\}  
例：商店卖货物，每一件 3.5 元，按购买的数量给与优惠：  
购买 100 件，优惠 5%；  
购买 200 件以上，优惠 6%；  
购买 300 件以上，优惠 8%；  
购买 400 件以上，优惠 10%；  
购买 500 件以上，优惠 15%；

#include<stdio.h>
    main()
    {
        
    int n;
    float p,price;
    scanf("%d",&n);
    switch(n/100)
    {
        
    case 1:
    p=0.05;
    break;
    case 2:
    p=0.06;
    break;
    case 3:
    p=0.08;
    break;
    case 4:
    p=0.10;
    break;
    case 5:
    p=0.15;
    break;
    }
    price=3.5*n*(1-p);
    printf("%应付款=%7.2f\n",price);
    }

**06.循环结构**  
**一、for 语句：**  
一般格式： for( 表达式 1 ;表达式 2;表达式 3) 语句;  
表示：先计算表达式 1 的值，再计算表达式 2 的值，若表达式 2 的值为 0，则跳出循环体，转去执行循环体后面的程序  
命令；若表达式 2 的值非 0，则执行循环体中的语句，接着计算表达式 3 的值；而后，再从计算表达式 2 的值开始重复上  
诉操作，直到表达式 2 的值为 0 时结束。  
例：计算 sum=1+2+3+…+100 的值” \#include<stdio.h>

main()
    {
        
    int i,sum;
    sum=0;
    for(i=1;i<=100;i++)
    sum=sum+i;
    printf(“sum=%d”,sum);
    }

**二、while 语句：**  
一般格式：  
while<表达式>  
语句;  
表示：先计算表达式的值，若为非 0，则执行循环体语句，然后再计算表达式的值，重复上述过程，直到计算表达  
式的值为 0 时结束循环。  
例：计算 sum=1+2+3…+100 的值

#include<stdio.h>
    main()
    {
        
    int i,sum;
    i=1;
    sum=0;
    while(i<=100)
    {
        
    sum=sum+i;
    i++;
    }
    printf(“sum=%d”,sum);
    }

**三、do-while 语句**  
**1、一般格式：**  
Do  
语句；  
While<表达式>;  
表示：先执行一次循环语句，然后计算表达式的值，若表达式的值非 0，则再执行循环语句，然后从计算表达式的值  
开始重复上述过程，直到计算表达式的值为 0，循环结束。  
例：计算 sum=1+2+3…+100 的值

#include<stdio.h>
    main()
    {
        
    int i,sum;
    i=1;
    sum=0;
    do
    {
        
    sum=sum+i;
    i++;
    }while(i<=100);
    printf(“sum=%d”,sum);
    }

**四、break 和 continue 语句：**  
**1、break 语句：**  
使用 break 语句可以提前结束由 while、for、do-while 语句构成的循环，而去执行循环下面的语句。  
例：判定用户输入的一个数是否为素数

#include<stdio.h>
    main()
    {
        
    int a,d;
    printf(“请输入一个整数：”);
    scanf(“%d”,&a);
    for(d=2;d<a;d++)
    if(a%d==0)
    break; // 跳出当前的循环，执行循环后面的语句
    if(d<a)
    printf(“%d 不是素数”, a);
    else
    printf(“%d 是素数 “,a);
    }

**2、continue：**  
continue 语句用于 for、while、do-while 语句中，其作用是结束本次循环，接着进入下一次是否执行循环的判断。  
例：输入 10 个非 0 的整数并求和。

#inclu de<stdio.h>
    main()
    {
        
    int i,n=0,sum=0;
    while(n<10)
    {
        
    printf(“ 请输入整数：”);
    scanf(“%d”,&i);
    if(i==0)
    continue; // 若为 0，则继续输入下一个数
    sum+=i;
    n++;
    }
    printf(“%d”,sum);
    }

**五、三种循环的比较：**  
1、三种循环可以处理同一个问题，一般情况下可以相互代替；  
2、while 和 do-while 循环语句只在 while 语句之后指定循环条件，在循环体内应包含使循环趋于结束的语句；for 循  
环语句可以在<语句 3>中包含使循环趋于结束的语句；  
3、对于 while 和 do-while 循环语句，循环变量的初始化应在 while 和 do-while 语句之前完成；for 循环语句可以在<  
表达式 1>中进行；  
4、while 和 for 语句是先判断表达式，后执行循环；do-while 循环语句是先执行循环，后判断表达式；  
**07 数组**  
数组是一组具有同一名字、不同下标的变量。数组中带下标的变量称为数组元素，每个数组元素由数组名字和下标唯一地  
来确定；同一数组中的元素数据类型相同。  
**一、一维数组：**  
1、定义：只有一个下标的数组。  
2、定义格式： 类型说明符 数组名\[常量表达式\]  
如： int a\[3\]; //定义了一个一维数组，名称为 a，数据类型为整型，含 3 个数组元素 a\[0\]、a\[1\]、a\[2\]；

> 说明： •类型说明符：是指数组的数据类型； •常量表达式：是一个值为正整数的表达式，用来表示该数组的元素的个数，即数组的大小；

3、数组的引用： 数组名\[下标\]; 如： a\[2\]  
4、数组的初始化：  
•对数组的全部因素赋初值：  
如： int a\[3\]=\{10,20,30\}; 则该语句执行后，a\[0\]=10,a\[1\]=20,a\[2\]=30；  
• 对数组的部分元素赋初值:  
如：int b\[3\]=\{12,11\}; 则该语句执行后，b\[0\]=12,b\[1\]=11,a\[2\]=0；  
•对数组的全部元素赋初值时，也可将数组定义为一个不确定长度的数组：  
如：int c\[ \]=\{10,15,20\};则该语句执行后，数组 c 的长度自动确定为 3，c\[0\]=10,c\[1\]=15,c\[2\]=20；  
例：将输入的 10 个整数按反序输出

#include<stdio.h>
    main()
    {
        
    int a[10],i;
    printf("请输入 10 个整数：");
    for(i=0;i<10;i++)
    scanf("%d",&a[i]);
    printf(" 反序输出:"）;
    for(i=9;i>=0;i--)
    printf("%d",a[i]);
    printf("\n");
    }

**例：计算 Fibonacci 数列的前 20 项**  
Fibonacci 数列定义：  
f(1)=1  
f(2)=1  
f(n)=f(n-1)+f(n-2) (n>2)

#include<stdio.h>
    main()
    {
        
    int f[21],i;
    f[1]=1;
    f[2]=1;
    for (i=3;i<=20;i++)
    f[i]=f[i-1]+f[i-2];
    for (i=1;i<=20;i++)
    {
        
    printf("%8d",f[i]); //每个数字占 8 位
    if(i%5==0) printf("\n"); //按 5 个一行输出
    }
    }

**二、二维数组：**  
具有两个下标的数组为二维数组。  
1、定义格式： 类型说明符 数组名\[常量表达式\]\[常量表达式\]  
如： int a\[3\]\[2\]; //定义了一个二维数组，名称数组名为 a，含有 6 个元素：a\[0\]\[0\]、a\[0\]\[1\]、a\[1\]\[0\]、a\[1\]\[1\]、a\[2\]\[0\]、  
a\[2\]\[1\]；  
**说明：**  
•第一个常量表达式指出的是数组的行数；第二个常量表达式指出的是数组的列数；  
•二维数组元素的顺序是：按行存放；即先顺序存放第一行的元素，再存放第二行的元素…以此类推；  
其存储格式：  
a\[0\]\[0\] a\[0\]\[1\]  
a\[1\]\[0\] a\[1\]\[1\]  
a\[2\]\[0\] a\[2\]\[1\]  
**2、二维数组的初始化：**  
同一维数组。  
•分行为二维数组赋初值：  
int a\[3\]\[2\]=\{ \{1,2\},\{3,4\},\{5,6\}\};则该语句执行后，a\[0\]\[0\]=1, a\[0\]\[1\]=2, a\[1\]\[0\]=3,a\[1\]\[1\]=4, a\[2\]\[0\]=5, a\[2\]\[1\]=6；  
•按数组在存储时的排列次序赋初值：  
int a\[3\]\[2\]=\{1,2,3,4,5,6\}; •对数组的部分元素赋初值：  
int a\[3\]\[2\]=\{ \{1\},\{2,3\},\{4\}\}; •忽略第一维的长度,对二维数组赋初值：  
int a\[\]\[2\]=\{1,2,3,4,5,6\}; 该语句执行后，C 语言系统自动计算出第一维的长度为 6/2=3，同样有：a\[0\]\[0\]=1, a\[0\]\[1\]=2,a\[1\]\[0\]=3,a\[1\]\[1\]=4, a\[2\]\[0\]=5, a\[2\]\[1\]=6；  
例：将两个 2 行 3 列的矩阵相加，并显示结果。

#include<stdio.h>
    main()
    {
        
    int a[2][3]={
        1,3,5,7,9,11};
    int b[2][3]={
        2,4,6,8,10,12};
    int c[2][3],sum=0,i,j;
    for(i=0;i<2;i++) //i 表示第 1 行到第 3 行
    for(j=0;j<3;j++) //j 表示第 1 列到第 3 列
    c[i][j]=a[i][j]+b[i][j];
    for(i=0;i<2;i++)
    for (j=0;j<3;j++)
    {
        
    printf(“%5d”,c[i][j]);
    if((j+1)%3==0) printf(“\n”);
    }
    }

**08 字符数组**  
字符数组是用来存放字符的数组，字符数组中的一个元素存放一个字符。  
**1、字符数组的定义：**  
char a\[10\];  
\*\*2、字符串：\*\*字符串是借助于字符数组来存放的，并规定以字符’\\0’(占用存储空间，但不计入字符串的长度)为字符串  
的结束标记。  
**3、字符串处理函数：**  
•scanf(“%s”,a); //以格式符%s 输入字符串，输入的字符串自动以’\\0’结尾；输入的字符数组名前不加”&”前缀；  
•printf(“%s”,a); //以格式符%s 输出字符串，输出的字符串以’\\0’结尾；  
•gets(a); //a 为字符数组名，输入的字符可以包含’\\0’字符；  
•puts(a); //a 为字符数组名，输入的字符可以包含’\\0’字符；  
•strcat(字符串 1,字符串 2); //把字符串 2 连接到字符串 1 后；  
•strcpy(字符数组 1,字符串 2); //把字符串 2 拷贝到字符数组 1 中；  
如：str 为字符数组，将字符常量赋予 str： strcpy （str ，“abcdef”); •strcmp(字符串 1,字符串 2); //比较两个字符串，若相等，则返回 0，若字符串 1>字符串 2，则返回 1，否则返回-1；  
如：比较两个字符串 str1、str2：if(strcmp(str1,str2)==1) printf(“str1>str2”); •strlen(字符数组); //返回字符数组中包含的字符串的长度；  
•strlwr(字符串); //将字符串的大写字符转换为小写；  
•strupr(字符串); //将字符串的小写字符转换为大写；  
例：不使用 strlen()函数，计算一个字符串的长度

#include<stdio.h>
    main()
    {
        
    int i=0;
    char str[30];
    printf(“ 输入一个字符串:”);
    gets(str);
    while (str[i]!=’\0’)
    i++;
    printf(“字符串长度为：%d\n”,i);
    }

例：将一字符串逆转

#include<stdio.h>
    #include<string.h>
    main()
    {
        
    char str[20],temp;
    int i,j;
    printf(“输入一个字符串：”);
    gets(str);
    for(i=0;i<strlen(str)/2;i++)
    {
        
    j=strlen(str)-1;
    temp=str[i];
    str[i]=str[j-i];
    str[j-i]=temp;
    }
    printf(“倒置的字符串为:%s\n”,str);
    }

**09 指针**  
字符数组是用来存放字符的数组，字符数组中的一个元素存放一个字符。  
**1、字符数组的定义：**  
char a\[10\];  
**2、字符串：** 字符串是借助于字符数组来存放的，并规定以字符’\\0’(占用存储空间，但不计入字符串的长度)为字符串  
的结束标记。  
**3、字符串处理函数：**  
•scanf(“%s”,a); //以格式符%s 输入字符串，输入的字符串自动以’\\0’结尾；输入的字符数组名前不加”&”前缀；  
•printf(“%s”,a); //以格式符%s 输出字符串，输出的字符串以’\\0’结尾；  
•gets(a); //a 为字符数组名，输入的字符可以包含’\\0’字符；  
•puts(a); //a 为字符数组名，输入的字符可以包含’\\0’字符；  
•strcat(字符串 1,字符串 2); //把字符串 2 连接到字符串 1 后；  
•strcpy(字符数组 1,字符串 2); //把字符串 2 拷贝到字符数组 1 中；  
如：str 为字符数组，将字符常量赋予 str： strcpy （str ，“abcdef”); •strcmp(字符串 1,字符串 2); //比较两个字符串，若相等，则返回 0，若字符串 1>字符串 2，则返回 1，否则返回-1；  
如：比较两个字符串 str1、str2：if(strcmp(str1,str2)==1) printf(“str1>str2”); •strlen(字符数组); //返回字符数组中包含的字符串的长度；  
•strlwr(字符串); //将字符串的大写字符转换为小写；  
•strupr(字符串); //将字符串的小写字符转换为大写；  
例：不使用 strlen()函数，计算一个字符串的长度

**例：将一字符串逆转**

**10 函数**  
C 程序是由函数组成的，有且只有一个主函数 main()，由主函数调用其他函数，其他各函数也可以相互调用。  
**1、函数的定义：**  
一般格式：  
类型说明 函数名(形式参数表) //函数头  
\{  
说明部分； //函数体  
执行部分；  
\}  
其中：类型说明：是指函数返回值的数据类型；默认为 int；  
函数名：为一标识符；代表了函数的入口地址；  
形式参数表：是用逗号分隔的一组变量说明，指出每一个形式参数的类型和名称；  
函数值的返回：有时，调用函数是为了计算一个结果，这是需要使用返回语句将就是结果返回给主调函数，  
此值即为函数的返回值；  
一般格式：return (表达式); 其中，圆括号可以省略；  
当函数不需要返回值时，可以写成：return;  
例：编写一个函数 power ()，用于计算 x 的 n 次方的值

#include<stdio.h>
    float power(float x,int n)
    {
        
    int i;
    float s;
    s=1;
    for(i=1;i<=n;i++)
    s=s*x;
    return (s);
    }

**2、函数的调用：**  
C 语言中函数调用的一般格式：  
函数名(实参表)；  
如：float f；  
f=power(3,10);  
**3、数组作为函数的参数**  
•数据元素作为函数实参  
在函数调用时，把数组元素作为实参传递给形参，实现单向的值传递；  
如：判别各个元素的值，大于 0，则输出该值，小于或等于 0，则输出 0

#include<stdio.h>
    void func(int x)
    {
        
    if (x>0)
    printf(“%4d”,x);
    else
    printf(“%2d”,0);
    }
    main()
    {
        
    int a[5],i;
    printf(“请输入 5 个数：”);
    for(i=0;i<5;i++)
    scanf(“%d”,&a[i]);
    for(i=0;i<5;i++)
    func(a[i]); //将数组元素作为实参传递
    }

•数组名作为函数参数  
（1）使用数组名作为函数参数时，形参和实参是同类型的数组；  
（2）在主调函数和被调函数中分别定义数组；  
（3）数组名代表了数组的起始地址，数组名作为函数参数传递的是该数组的起始地址，而不是该数组元素的值；  
例：将数组中的元素的和计算并显示出来。

#include<stdio.h>
    func(int b[])
    {
        
    int sum=0,i;
    for(i=0;i<10;i++)
    sum+=b[i];
    return sum;
    }
    main()
    {
        
    int a[]={
        1,2,3,4,5,6,7,8,9,10},s;
    s=func(a); //将数组 a 组为参数传递给函数 func
    printf("s=%d",s);
    }

**4、内部函数和外部函数**  
• 内部函数：在定义函数时，在其类型名之前加“static”，则所定义的函数为内部函数，只能被所在的源文件中的函数  
调用，其他源文件若有同名的内部函数，互不干扰。  
• 外部函数：在定义函数时，在其类型名之前加“extern”（也可省略），则所定义的函数为外部函数（也称全局函数），  
可被其他源程序的函数调用。  
如：static int func\_1() //内部函数  
\{  
… \}  
extern func\_2 （） //外部函数  
\{  
… \}  
**综合测试**  
给定程序为：猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个。以后每天早上都吃了前一天  
剩下的一半零一个。到第 10 天早上只剩一个桃子。求第一天共摘了多少桃子。由主函数输出第一天共摘桃子数。输出结  
果为 1534。

#include<stdio.h>
    int fun(int n)
    {
        
    }
    main()
    {
        
    int n=10,sum;
    sum=fun(n);
    printf("sum=%d",sum);
    }

**解析：** 根据题意，第 n+1 天剩下的桃子数为 x(n+1)，第 n 天剩下的桃子数为 x(n)，则满足：x(n)=2\*(x(n+1)+1);  
第十天剩下 1 个桃子，可推算出第九天剩下的数量；可利用 for 循环，递推出其他天数剩下的桃子数：

int fun(int n)
    {
        
    int x,i;
    x=1; //第十天剩下的数量
    for(i=n-1;i>=1;i--) //从第九天开始推算
    {
        
    x=2*(x+1);
    }
    return x;
    }

给定程序的功能是：从键盘输入 10 个整数求其中的最大值。

#include<stdio.h>
    main()
    {
        
    int fun(int b[],int n);
    int max;
    int i,a[10];
    for(i=0;i<10;i++)
    scanf("%d",&a[i]);
    max=fun(a,10);
    printf("max=%d",max);
    }
    int fun(int b[],int n)
    {
        
    }

\*\*解析：\*\*比较最大值的一般算法：设置一个变量 max，第一步：将第一个数赋予 max；第二步：利用 for 循环，将剩下的 9  
个数依次与 max 相比较，每次比较，max 均等于大的数；

int fun(int b[],int n)
    {
        
    int max,i;
    max=b[0]; //将第一个数赋予 max
    for(i=1;i<=n-1;i++) //将剩下的 9 个数依次与 max 比较；
    if(max<b[i]) max=b[i];
    return max;
    }

给定程序的功能是：将给定字符串中所有的小写字母转换成大写字母(大写字母 A 的 ASCII 码为 65，小写字母 a  
的 ASCII 码为 97）。

#include<stdio.h>
    #include<string.h>
    void hs(char c[])
    {
        
    }
    main()
    {
        
    char a[]={
        "AgRbhLfFGjI"};
    hs(a);
    printf("%s",a);
    }

\*\*解析：\*\*将给定字符串的每一个字符取出，判断是否介于’a’和’z’之间，若是，则将其转换为大写字符，即其 ASC 码值－32。

void hs(char c[])
    {
        
    unsigned int i;
    for(i=0;i<strlen(c);i++)
    if(c[i]>='a' && c[i]<='z')
    c[i]=c[i]-32;
    return;
    }

给定程序的功能是：求 1+2+3+4+5+6+…+n（n 的值由键盘输入）。

include<stdio.h>
    main()
    {
        
    int fac(int n);
    int n,sum;
    scanf("%d",&n);
    sum=fac(n);
    printf("sum=%d",sum);
    }
    int fac(int n)
    {
        
    }

**解析：** 函数 fac 的功能是计算 1-n 之间整数的累计和。

int fac(int n)
    {
        
    int i,sum;
    sum=0; //累计和的初始值为 0
    for(i=1;i<=n;i++)
    sum+=i; //将 1-n 之间的整数累加起来
    return sum;
    }

给定程序的功能是：从键盘输入 10 个整数,求其中的最小值。

#include "stdio.h" main()
    {
        
    int fun(int x[],int n);
    int a[10],i,min;
    printf("please input 10 numbers:\n");
    for(i=0;i<10;i++)
    scanf("%d",&a[i]);
    min=fun(a,10);
    printf("min=%d\n",min);
    }
    int fun(int x[],int n)
    {
        
    }

**解析：** 比较最小值的一般算法：设置一个变量 min，第一步：将第一个数赋予 min；第二步：利用 for 循环，将剩下的 9  
个数依次与 min 相比较，每次比较，min 均等于小的数；

int fun(int x[],int n)
    {
        
    int min,i;
    min=x[0]; //将第一个数赋予 min
    for(i=1;i<=n-1;i++) //将剩下的 9 个数依次与 min 比较；
    if(min>x[i]) min=x[i];
    return min;
    }

> ![请添加图片描述][e4c3e6b16feb4512991f8f6051e8bf75.gif]

[19b46069e7ef4da0865ee4a9a62ac913.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/08db191c1c05482e8a4c3ae73e2e6604.png
[85f353f7daed4bf18adaf603551ccf0c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/f18ff1ad89cb410fa1efb0ec2c899e51.png
[05aee9ec72a44e5ba7ff3a7cd72afc97.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/16ef5481ecd94429aae27de32a73e608.png
[967ea3cd88104b0fbd17f16fc00877a2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/7738e075f25b407a91bb5997708b222e.png
[5919082ca94444699107aea93543adea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/766fae851b3d44f4a1c9d191cca484c8.png
[00eefec4eae74cc1bff8cfcba4dc4fff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/e26d00e87b5545978b394b7c6296e6f8.png
[1ef11838488d49e98d87e8e0f4f0f787.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/162c747d04484e2a804198d71edcd1a9.png
[28aeede12c084693bf92da9e4274f383.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/34827232f9304e30b43f3483eb36b899.png
[40dcba7ce9a84fbaac88a1dace376939.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/2b2b385313044c338a9930d17bf64963.png
[1024fab9f7e64fcdba9a80dd6f960fb1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/df6a83c9bb7b432093084212aac183f7.png
[01a946f70ed0491a8b044006ae27505e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/bf6cafd9220742feb9698cfdf69cb5d2.png
[b70d4d647d81452eba9a5ae27a86b07f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/02e47647b6c843998df458a5ed05b36c.png
[07cc65652e1940dca2259440254d319c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/54d9daf0ca68488188ad92b3789c18df.png
[d2914727f9f244ba813573f09e254107.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/72ac8022c6e84dec9b2c7e53c71e1c46.png
[508566c936b747a69ac1a08faf1b5e5f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/c3030f2f8166457aac793a37a1948291.png
[bbc80f5995034e60960a999cb32b4df7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/206dd790b4ed4ab999c4803ad5b3c8cc.png
[d01a88b83cd7412789115c490c3e9bbe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/8d32f89087d84e13b2ab37d9c74436fd.png
[c0efdff19e38486b87adfa0d1f62de7a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/1ebe30ade4e541ed839de6fd08525b3c.png
[c2f22a2aad7e4e92a8258a30fbb596f6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/2ceff13f0cb54039957f8fbbedcd9663.png
[fc913d2285b849e98c8ca44a98aac8ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/8e3fc9c3d0e1455faa90b1a57bd27e78.png
[e4c3e6b16feb4512991f8f6051e8bf75.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/04271769181742e8a54031fea245e9d4.gif