计算机培训,c语言知识点概要

C语言章节复习 第一章：C语言概述 1、C语言的特点 1）任何一个C程序有且有一个main()函数 。

2）任何一个C程序文件有且有一个main()函数 ， 一个C程序总是从main()函数开始执行。

3）C程序的基本单位是 函数 。

4）C函数的基本单位是 语句 。

5) C程序的每个语句必须以 ；

结束。

6）C程序的以 /* */ 作注释的开始和结尾。

7）C程序的每个语句可以写多行 。

8）C程序的每行可以写多个语句 如：a=10; printf(“%d＼n”,a); 9）C语言区分大小写 。

_ 10）C语言没有输入输出语句，由函数代替 。

11）“#”为编译以预处理，“include”包含语句。

12）在C只能识别半角语言字符，不能用全角。如果想输出汉字，必须在函数内用“”括起来。

第二、三章：数据类型、运算符和表达式及标准输入输出 1、 C程序的标识符只能由 字母 、 数字 、 下划线 组成、并且第1个字符必须为 字母 和 下划线____。

2、 常量 整型：三种表示形式：a）十进制整数，例：12；
b）八进制整数，例：012；
c）十六进制整数，如0、258、-3875、0357、0x35b、-6945L 实型：两种表示形式：a）十进制小数形式，例：123.456；
b）指数形式，例：1e3,2.3e-3。13.6795、-0.58、-.45、100.、0.5e5、-12.4e-10、12.5E-2 注意：1）E后的指数部分必须为整数 2）在字母E或e的前后必须有数据 3）在字母E或e的前后及数字之间不能有空格 字符型：用‘ ’括号括起来的单个字符 1）普通字符：’a’、’B’、’;’、’%’、’#’、’:’ 2) 转义字符：’＼n’、 ’＼t’、 ’＼r’、 ’＼b’、 ’＼＼’、 ’＼’’、 ’＼”’ 3) 用”＼”加上1~3位八进制表示一个字符（范围0~377），如’＼54’、’＼127’、 ’＼07’ 用”＼x”加上1~2位16进制表示一个字符，如’＼x54’、’＼xa7’、 ’＼xaf’ 字符串型：用” ”括号括起来的多个字符,c语言自动在后面加上’＼0’。

如”This is a map!”、“bdWQ＼＼hm＼bab＼’89＼”4A＼tOU” 符号常量：#define PI 3.14 #define EOF (-1) 3、 一个变量包含五个要素类型、名称、内容、地址、存储类型。

4、填写下表
类型 表示 占用字节数 （视系统而定）　 表数范围／有效位数 输出格式 整型 Int 2 -32768--+32767 %d %o %x 无符号整型 unsigned 2 0~65535 %u %o %x 长整型 Long 4 -2147483648 +2147483647 %ld %lo %lx 单精度浮点型 Float 4 %f %e %g 双精度浮点型 Double 8 %lf %f %e 字符型 Char 1 0~255 %c 字符串型 char N n %s 5、 不同类型的数据进行混合运算时，数据的转换方式有两种：自动转换和强制类型转换，其中前一种转换方式的规则是：低类型转换成高类型、赋值号右边的类型转换成左边的类型 6、 printf(“格式控制”，输出列表) 1）
格式控制包括：原样输出字符、格式符、转义字符、 格式符包括（d、o、x或X、u、f、e或E、g或G、c、s、p）
2）
输出列表可以是常量、变量、表达式，都是输出它们的值，各项之间用”，”分隔。

3）
格式控制与输出列表类型和项数相同 4）
指定宽度m或m.n A) m表示输出的总宽度。实际宽度<m时左边补0, 实际宽度>m时则按实际位数输出。如printf(“%6d,%3d＼n”,3587, 3587); B) n表示按四舍五入输出的小数位数，或表示只取字符串左端n个字符。

如printf(“%7.3f,%5.4s”,590.5327,”abcderf”); 5）
加L或l：用于输出long型和double型 6）
加减号-：左对齐 7）
加0：左边补0 7、 scanf((“格式控制”，输入的地址列表) 1）
格式控制包括：格式符、原样输入字符 2）
地址列表一定是地址：普通变量地址、字符串数组名（首地址）
3）
输入的各项之间用空格、Tab键、回车分隔。

4）
格式符前加l，表示输入长整型数据（可用%ld、%lo、%lx、%lu）及double数据（可用%lf、%le）。

5）
格式符前加数字m，用来指定输入数据的宽度，但不能指定精度m.n。

如：scanf(“%3d%4d”,&a,&b); 6）%后加*m，表示跳过（丢掉）m列。

如：scanf(“%4d%*3d%4d”,&a,&b); （分别输入12 345 67和123456789）
7）scanf（）输入字符串时，遇空格则输入结束。如 8、 算术运算 （+、-、*、/、%、++、--）
1）两个整数相除”/”,结果为整数，两个实数相除”/”,结果为double实数。

如：50/8 值：__6_____， 50./8 值：___6.125____ printf(“%d,%f＼n”,50/8,50./8); 结果_______ 2）
取余运算%只适用于整数，且余数的符号与被除数的符号相同。

如：50%8 值：_______， -50%8 值：_______ 50%-8 值：_______， -50%-8 值：_______ 3）自增自减运算 A）++i、--i：变量的值先加1或减1，然后以新值进行其他运算。

B）i++、i--：变量先以原值参与其他运算，然后其值再加1或减1，新值在下一个表达式或语句生效。如：
main() {int i=3,j,k; j=i++,k=i;i++; printf(“%d,%d,%d＼n”,i,j,k); } 执行i=3;j=(i++)+(i++)+(i++);后i的值是___6____、j的值是___9____ 执行i=3;j=( ++ i)+(++i)+(++i);后i的值是___6____、j的值是___18____ C)++、--运算只能用于变量，不能用于常量和表达式。

D)注意区别普通变量的自增、数组指针变量和结构数组指针变量的自增自减的意义。

如：int a=3，b[5]，*p=b；

则a++、p++的意义是 4）算术运算的优先级++ --、* / % 、 + - 9、 赋值运算（=、+=、-=、*=、/=、%=、…）
a) 赋值号左边必须是变量，右边可以是常量、变量、表达式。

b) 赋值后变量的值变为新赋的值，原值被冲掉且无法恢复。

c) 赋值运算的结合性为“自右至左“。

如：执行a=10; a+=a-=a*a;后a的值：________ a=5,则执行a+=a*=a-3后,a的值是__________ 4)区别a-10、与a=a-10,~a,a<<2 10、 关系运算（>、<、>=、<=、= =、!=）
a) 关系运算的结果为：0或1 b) 关系运算把非零数都看成为了1 c) >、<、>=、<=的优先级高于= =、!= 11、 逻辑运算（与&&、或||、非!）
a) 与&&：两数都为”1’结果为”1”。

b) 或||：两数都为”0’结果为”0”。

c) 非!：”0”的非是”1”， ”1”的非是”0”。

d) 优先级：！最高、&&居中、||最低。

e) 注意短路现象。

12、条件运算（式1?式2：式3）
1）
条件运算的优先级仅高于赋值运算和逗号运算。

2）
如：x=4,y=6，z=x>y?x+y:x-y，z的值是________ x=4,y=6，z=x+5>y?x+y:x-y，z的值是________ x=4,y=6,z=5,z+=x+5>y+3?x+y:x-y，z的值是________ 13、逗号运算（式1，式2，…，式n）; 1）
依次计算各表达式的值，最后一个表达式的值作为整个逗号表达式的值。

2）
逗号运算的优先级最低 如：表达式(x=(a=2,a+7),b=5))的值是________ a=5;执行语句x=a+7,b=5;后 x= ; 3）
一个逗号表达式可以与另一个表达式构成新的逗号表达式。

如：表达式(x=2*5,x*5),x+5的值是 4）
并不是所有出现“，”的地方都作逗号运算符。（int、printf、scanf）
如：printf(“%d,%d＼n”,(x,y,z),z)；

14、sizeof（）运算符 1）计算各类数据所占存储空间的字节数。

2）括号可以是常量、变量、类型说明符等 若int a,b[20]；
char *p=”abcdefghi”；

如sizeof（5）、sizeof（5.2）、sizeof（‘a’）、sizeof（“abcde”）、 sizeof（a）、sizeof（b）、sizeof（p）
sizeof（char）、sizeof（double）、sizeof（strucu student）
15、所有运算的优先级。

1级、（）、[ ]、.、-> 2级、单目运算~、!、*、&、++、-- 从右向左 3、4级算术运算：*、/、%、+、- 5级、移位运算：<< >> 每左移一位，等于该数*2，每右移一位，等于该数/2取整。

6、7级关系运算：>、<、>=、<=、= =、!= 8、9、10级位运算：&位与、^(异或)、|位或 先化二进制，再进行位运算。其中异或算法是两位相同则为0，两位相异则为1 11、12级逻辑运算：&&、|| 13级、条件运算：式1？式2：式3；
从右向左 14级、赋值运算：=、+=、*=、/=、%=，结合性从右向左。

15级、逗号运算：式1，式2，… 式n；

第四章：选择结构 特别要注意：C语言中是用非0表示逻辑真的，用0表示逻辑假的。

C语言有构造类型，没有逻辑类型。

关系运算符号：注意<=的写法，==和=的区别！（考试重点）
if只管后面一个语句，要管多个，请用大括号！ If(a), if(!a)表示什么意思 1、单分支：if (表达式) 语句；

功能：先计算表达式的值，若为“1”，则执行“语句”，然后再执行后续语句；

若为“0”，直接执行后续语句；

2、双分支：if (表达式) 语句1；

else 语句2；

功能：先计算表达式的值，若为“1”，则执行“语句1”，然后再执行后续语句；

若为“0”，则执行“语句2”，然后执行后续语句；

说明：1）应把if语句看成一条语句，分为两部分，写两行，并后缩。

2）语句包含多个条时，用{}括起来组成复合语句。

3）多分支由双分支构成。

4）else总是与最靠近的if结合。

5）多分支的形式有多种，构成if…else嵌套。

6）任何多分支都可用多个单分支完成。

7）”条件表达式”中若为与运算&&，若&&前面的式子值为0，则不再运算&&后面的式子。如：
main() {int a,b,k; a b 结果 -1 5 5 0 -4 5 4 -3 -4 0 -3 -1 if(++a<0&& b--<=b--+1) printf(“%d,%d＼n”,a,b); else printf(“%d,%d＼n”,b,a); printf(“%d,%d＼n”,a,b); } 3、多分支：if (表达式1) 语句1；

else if (表达式2) 语句2；

else if (表达式3) 语句3；

else 语句4；

4、多分支：switch （表达式）
{case 常量表达式1：语句1；

break; case 常量表达式2：语句2；

break; …… case 常量表达式n：语句n；

break; default: 语句n+1；

} 1)功能：先计算表达式的值，与case后的常量表达式相同时，则进入，若都不相同则从default中进入。进入后顺序执行，遇break则退出switch语句。

2）default语句可有可无，位置可先可后。

3）表达式的结果只能是整型值或字符值，case后面一定要只能是整型常量或字符常量 表达式，如0、4、-5、3+2、50、‘A’、‘b‘等，不能i+3、“abcd”等。

例：main() {int a; scanf(“%d“,&a); switch(a-3) {case 1: a+=1; case 2: a+=2; case 3: a+=3; case 4: a+=4; case 5: a+=5; default: a+=10; } printf(“a=%d“,a); } 4）写出下列程序的结果 main() {int x,y; scanf(“%d”,&x); 输入x值 Y值 5 -1 0 0 -4 1 y=1; if (x<=0) if (x=0) y=0; else y=-1; printf(“%d＼n”,y); } 第五章：循环结构 1、while循环 while (表达式) 循环体；

2、do…while循环 do { 循环体；

} while (表达式); 3、for循环 for (表达式1；
表达式2；
表达3) 循环体；

4、说明 1）理解三种循环的执行过程 条件为“1”，执行循环体；
条件为“0”，退出循环，执行后续语句。

2）整个循环语句作为一个语句，写成两行，注意后缩。

3）注意与if语句区别：都有条件表达式，if语句只判断并执行一次，循则多次判断执行 4）注意用简易方法分析循环。

5）注意与if语句连用时的分析 6）理解双循环的执行过程。

7）进入循环前，注意某些变量赋初值，如：求和s=0,求积n=1,排序、求最大公约数等。

8）”条件表达式”中若为与运算&&，若&&前面的式子值为0，则不再运算&&后面的式子。如：
main() a b 结果 7 7 8 6 8 4 {int a=5,b=8; while(++a>7&&--b<7) printf(“%d,%d＼n”,a,b); printf(“%d,%d＼n”,a,b); } 5、break;：①用于结束整个循环， ②它只能跳出其所在的循环不能跳出外层循环， ③只能用于循环和switch语句。

6、continue;:用于结束本次循环，开始下一次循环。

7、程序举例：
1）判断一个数是否为素数，输出 100~200之间所有素数的个数；
（例5.7，5.8）
2）计算∏的值（见例5.4，p100）
3）计算级数的值（见习题5-8，P113）
4）求阶乘n！。

第六章：数组 数组 一、一维数组 1、定义、意义 格式：数据类型 数组名[整型数]；

如：int a[10]; 意义：定义了10个变量(元素)，每个变量存放一个整数。

a[0]、a[1]、a[2]、a[3]、a[4]、a[5]、a[6]、a[7]、a[8]、a[9] 说明：下标从0开始，定义时的下标可以是整型数、整型数的表达式或符号常量。不能使用变量。

如：#define N 10 int a[10], score[N],b[4+6]; 2、赋值：
1）直接赋值: a[0]=6; a[1]=5, a[2]=a[0]+a[1]; 2）定义时赋值 int a[10]={7,5,3,8,9,1,2,10,6,4}; float b [20]={6.5,8.9,4.6}; 注意：A）定义时不赋初值，所有元素的值不确定。赋值一部分，其余元素值为0或‘＼0’。

B）可以省略下标 int a[ ]={7,5,3,8,9,1,2,10,6,4}; C）赋值个数不能多于下标数,否则系统会报错。

D）不能int a[10]={ };或int a[10]={7,5, , ,9,1,2 }; 3）键盘赋值：scanf(“%d”,&a[0]);(可用循环对所有元素赋值) 3、输出：数值数组，必须一个个单独输出。如printf(“%d”,a[0]); 4、数组的存储：按元素的先后顺序存储。数组名表示首地址，是常量，定义后不能赋值。

5、注意区别：定义时赋值与非定义时赋值。

如：int a[10]={7,5,3,8,9,1,2,10,6,4}; a[10]={7,5,3,8,9,1,2,10,6,4};（错误！！）
6、例题：
1）找出下列数据的最小值输出（用三种方法编程）。

3 2 5 9 6 4 7 10 8 1 2）输入10个整数，找出它们的最小值，输出最小值和位置。

3）从键盘输入10个整数，输出它们并计算它们的平均值。

4）从键盘输入10个整数，存入一个数组中，然后对其数据倒置并输出。

5）对下列数据按从小到大排序输出。（分别用选择排序、冒泡排序、直接交换排序编程）
3, 8,5,9,6,2,10,7,1,4 二、字符数组 1、字符数组的作用：用于存放字符串(string)。字符串是用双引号括起来的一串字符，后面自动加’＼0’，如”ABCDE”、”Student” 、”This is a map” 2、字符数组的定义、意义 格式：数据类型 数组名[整型数]；

如：char s[10]; 意义：定义了10个变量(元素)，每个变量存放一个字符。

s[0]、s[1]、s[2]、s[3]、s[4]、s[5]、s[6]、s[7]、s[8]、s[9] 3、赋值：
1）直接赋值: s[0]=’A’; s[1]=’m’, s[2]=’7’; 2）定义时赋值 char s[10]={‘A’,’B’,’C’,’D’,’E’,’F’,’G’,’H’,’I’,’’,’＼0’}; /*需手工加’＼0’*/ char s[10]={”ABCDEFGHI”}; char s[10]=”ABCDEFGHI”; 注意：定义时不赋初值，所有元素的值不确定。赋值一部分，其余元素值为0或‘＼0’。

3）键盘赋值：
scanf(“%c”,&s[0]); /*可用循环对所有元素赋值。可以接收任意字符*/ scanf(“%s”,s); /*后面只写数组名，输入时以空格、回车、Tab键作结束，字符串自动加’＼0’*/ gets(s); /*输入时以回车键作结束，字符串自动加’＼0’*/ strcpy(s,”ABCDE”); 4、输出：
printf(“%c”,s[i]); /*用循环一个个输出*/ printf(“%s”,s); /*整体输出，后面写数组名，遇’＼0’则结束*/ puts(s); /*整体输出，后面写数组名，遇’＼0’则结束，输出完后换行*/ 5、数组的存储：按元素的先后顺序存储。数组名表示首地址，是常量，定义后不能赋值。

6、字符串的处理：从前到后一个个看一遍。

7、例题 1）输入一个字符串，然后输出。（用三种方法输入输出“ABCDEFGIHJ”）
2）输入一句英文，统计出英文字符的个数 3）输入一段文字，将其中的小写字母转换为大写，然后输出。

4) 输入一行字符，统计其中字母、数字和其他字符的个数。

5) 输入一行字符串，把它复制到另一个字符数组中 6 ) 输入两个字符存入S、t数组中，把t连接到s后面 三、字符串处理函数 1、输入一个字符 格式：c=getcher() scanf(“%c”,&c);相同 功能：从键盘接收一个字符存到变量C中。可以接收任意字符。

2、输出一个字符 格式：putchar(c) 功能：把C中的字符显示到屏幕上。

如：这putchar (‘A’); char c=’A’; putchar(c); 3、输入一个字符串 格式：gets(s); 功能：接收一个字符串存入数组s中。输入时以回车键作结束，字符串后自动加’＼0’ 4、输出一个字符串 格式：puts(s); 功能：把数组s中的字符串输出到屏幕上，遇’＼0’则结束，输出完后换行。

5、求字符串长度 格式：strlen(s) 功能：返回字符串所含字符个数（长度），’＼0’不记。

如：char s[50]=”ABCDEF”; strlen(s) 结果为：6 strlen(“This is a map!”) 结果为：14 6、字符串的复制 格式：strcpy(s,t); 功能：把数组t（源）中的字符串复制到s（目标）中。

如：char s[20],t[20]=”ABCDE” strcpy(s,t); strcpy(s,”student”); 说明：源一定是字符串变量，目标可以是字符串变量，也可以字符串常量。

7、字符串连接 格式：strcat(s,t) 功能：把字符串t连接到字符串s之后。

如：char s[50]=”abcde”,t[20]=”m123” strcat(s,t) 结果：”abcdem123” strcat(s,”xyz”) 结果：”abcdexyz” 说明：源一定是字符串变量，目标可以是字符串变量，也可以字符串常量。

8、字符串比较 格式：strcmp(s,t) 功能：对s、t中字符一个个比较，s大则返回正整数n, s小则返回负整数n，相等则返回0。

如：strcmp(“abcf”,”abcdefg”); 结果 2 strcmp(“abcd”,”abcdefg”); 结果-101 strcmp(“ABCDE”,”ABCDE”); 结果 0 说明：两个字符串都可以是字符串变量，也可以字符串常量。

9、说明：
getcher()、putchar(c)、gets(s)、puts(s)包含在stdio.h中。

strlen(s)、strcpy(s,t)、strcat(s,t)、strcmp(s,t) 包含在string.h中 10、例：
任意输入两个字符串，把大的存入a中，小的存入b中然后输出。

四、二维数组 1、定义、意义 格式：数据类型 数组名[m][n]；

如：int a[3][4]; 意义：定义了3行4列3*4个变量(元素)，每个变量存放一个整数。

a[0][0]、a[0] [1]、a[0] [2]、a[0] [3] a[1][0]、a[1] [1]、a[1] [2]、a[1] [3] a[2][0]、a[2] [1]、a[2] [2]、a[2] [3] 2、赋值：
1）直接赋值: a[0][0]=6; a[0][1]=5; 2）定义时赋值 int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}; int a[][4]={{1,2,3},{5,6},{9}}; 注意：A）定义时不赋初值，所有元素的值不确定。赋值一部分，其余元素值为0或‘＼0’。

B）可以省略第一个下标 int a[ ][4]= {1,2,3,4,5,6,7,8,9,10 }; 3）键盘赋值：scanf(“%d”,&a[0][0]);(只能一个个输入，可用双循环对所有元素赋值) 3、输出：数值数组，必须一个个单独输出，可用双循环输出所有元素。

如printf(“%d”,a[0][0]); 4、数组的存储：按行顺序存储。数组名表示首地址，是常量，定义后不能赋值。

如：main() {int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12},i,j; for(i=0;i<3;i++) for(j=0;j<4;j++) printf(“%d “,a[i][j]); printf(“＼n%u “,a); } 5、例 1）编程：求5行5列矩阵对角线元素之和。

2）编程：对4行4列矩阵转置。

3）某班有30人，有四门课程语文、数学、英语、专业课。编程输入各人的成绩，求各人的总分、平均分及各科科平分。

五、二维字符数组 1、定义、意义 格式：数据类型 数组名[m][n]；

如：char s[3][10]; 意义：定义了3行10列3*10个变量(元素)，每个变量存放一个字符。

每行存放一个字符串，存到s[0]、s[1]、s[2]中 s[0] s[0][0]、s[0] [1]、s[0] [2]、s[0] [3]……s[0] [9] s[1] s[1][0]、s[1] [1]、s[1] [2]、s[1] [3] ……s[1] [9] s[2] s[2][0]、s[2] [1]、s[2] [2]、s[2] [3] ……s[2] [9] 2、赋值：
1）直接赋值: s[0][0]=’A’; s[0][1]=’B’; 2）定义时赋值 int s[3][10]={‘A’,’B’,’C’,’＼0’}; int s[3][10]={“ABC”,”XYZ”,”MNOPQ”}; int s[][10]={“chism”,”change”,”chank”,”char”,” check” }; 3）键盘赋值：
一次输入一个字符：scanf(“%c”,&s[0][0]); s[0][0]=getchar(); 一次输入一个字符串：scanf(“%s”,s[0]); gets(s[0]); 3、输出：
一次输出一个字符：printf(“%c”, s[0][0]); putchar(s[0][0]); 一次输出一个字符串：printf(“%s”,s[0]); puts(s[0]); 4、例 1)输入下列五个字符串，从小到大排序输出 “chism”,”change”,”chank”,”char”,” check” 第七章 函数 1、函数的定义 1) 函数的定义格式 类型 函数名（形参列表）
/*函数首部*/ {语句组；

/*函数体*/ return 式子；

} 2)类型：指函数返回值的类型，可以是int、float、char、long、void、… 其中int型可以省略。

3) 形参列表：是子函数要从主调函数接收数据的变量（等同于赋值的左边），每个形参要说明其类型，且用”，”分隔。可以没有形参。

4) 函数体：用于完成相应的功能。

2、函数的调用：
1）格式：函数名(实际参数)；

2）说明：实际参数是主函数要传递到子函数的数据，等同于赋值的右边，可以是数、变量、式子。

3）调用形式：
①函数作为单独一行语句进行调用mj(a,b); printf(…); ②函数作为表达式的部分使用 x=mj(a,b); n=sqrt(x); ③函数作为另一个函数的参数进行调用：printf(“%f＼n”, mj(a,b)); printf(“%f＼n”, sqrt(x)); 3、函数的返回：函数返回可以使用return返回，也可以执行到函数尾自动返回调用函数。函数无返回值时，须将函数定义为void型。

4、函数的说明：
A)一般地，子函数应写在前面，主函数写在后面。如果函数定义在调用之后，则应先进行说明，才能正确调用。

B)说明方法：与定义时的函数首部相似，加分号，可以省略形参。int型函数可以不说明。如float mj(float a,float *b); 或float mj(float,float *); C)说明位置：在函数内部或外部。

5、函数的运行过程：
运行主函数前部→调用子函数→运行子函数→返回主函数→运行主函数后部 6、函数的参数传递（特别注意主函数与子函数中的变量同名一同意的情况）
1）赋值调用：赋值调用时，函数将实参的值复制一份传递给形参，只进行单向传递。实参可以是常量、变量、表达式。

2）传址调用：传址调用的函数，主调函数把变量的地址传到子函数中，调用语句采用swap(&a,&b)传递内存地址。子函数的参数一般为指针型，如swap（int *a,int *b）
7、数组的调用 1）一维数组 如int a[10]={ 1,2,3,4,5,6,7,8,9,10}; ①调用时一般传递数组名和数组大小到子函数，如fun(a,10); ②子函数首部形式：fun(int a[],int n)或fun(int *a,int n); 不论哪种形式，都是子函数用指针指向主函数的首地址。

2）二维数组 如int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; ①调用时一般传递数组名和行数到子函数，如fun(a,３); ②子函数首部形式：fun(int a[][4],int n)或fun(int （*a)[4],int n); 3）字符串数组，一般只传递数组名。

8、函数的嵌套 1）意义：在一个函数中调用另一个函数，叫函数的嵌套 如main()调用a()函数，a()函数调用b()函数, b()函数调用c()函数…. 2)函数的递归调用：
函数自身调用自身,即main()调用a()函数，a()函数再调用a()函数，…. 9、局部变量和全局变量 1）
局部变量：在函数内定义或函数块内定义，只在函数内或块内有效，当退出函数或块内时自动释放。定义后初值不定。

2）
全局变量：定义在函数外，从变量定义开始，到程序文件结束，变量一直有效。初值为0 3）
分析下列程序的运行结果 练习1 练习2 int m=13; main() int fun2(int x,int y) {int a=3,b=2,c=1; {int m=3; c-=++b; return(x*y-m); b*=a+c; } {int b=5,c=12; c/=b*2; main() a-=c; {int a=7,b=5; printf(“%d,%d,%d,”,a,b,c); printf(“%d＼n“,fun2(a,b)/m); a+=--c; } } printf(“%d,%d,%d＼n”,a,b,c); } 10、变量的存储类型 动态存储 自动变量：auto 1)变量的存储类型 寄存器变量:register 静态存储 静态变量:static 外部变量:extern 2)特点 名称 表示 初值 函数结束后，其存储空间 各自特点 自动变量 auto 不定 自动释放 默认为auto变量 寄存器变量 register 不定 自动释放寄存器 存放在cpu寄存器中，cpu寄存器不够时，转为auto 静态变量 static 0或’＼0’ 不释放 多次进入，只进行一次定义和初始化 外部变量 extern 0或’＼0’ 不释放 1）对外部变量进行说明 2）后面定义的变量提前使用 3）多个程序文件之间变量的引用 11. 程序举例 P184-185：习题1、3、9、11 第八章：指针 一、指针的基本知识 引例：int a,b,x[10]={1,2,3,4,5,6,7,8,9,10},*p,*q; 通过下列程序可以看到各变量的名称、内容、地址。

#include <graphics.h> #define N 10 main() {int x=100,y=200,a[N]={1,2,3,4,5,6,7,8,9,10},*p=&a,*q=x,i; printf(“＼n＼n＼n＼n＼n＼n＼n＼n＼n＼n＼n＼n＼n＼n＼n x y “); /*显示x、y的名称*/ for (i=0;i<N;i++) /*显示数组元素的名称*/ printf(“a[%d] “,i); printf(“＼n%6d%6d“,x,y); /*显示x、y的内容*/ for (i=0;i<N;i++) /*显示数组元素的内容*/ printf(“%6d“,a[i]); printf(“＼n%6u%6u“,&x,&y); /*显示x、y的地址*/ for (i=0;i<N;i++) /*显示数组元素的名称*/ printf(“%6u“,&a[i]); } 1、指针变量：定义时带*号的变量，它用于存放变量地址，这种变量称为指针变量。

指针变量存放哪个变量的地址，我们就说它指向哪个变量。

2、指针的定义方式和意义 类型 *变量名；

如：int a=5,b=10,*p=&a,*q=&b; float m,n,*x; char s[10]=”ABCD”,*ch; int *p[5]; 意义是：
int (*p) [5]; 意义是：
int **p1; 意义是：
一个指针变量有六个属性：
指针变量名称、类型、内容、地址、存储类型、指针变量指向的内容。

3、指针的赋值（赋值后要能画指向图）
1）
把一个变量的地址赋给指针变量。如：int a,*p; p=&a; 2）
数组名赋给指针变量：float a[10],*x,; x=a; 3）
一个指针变量赋给另一个指针变量。

如：int a=10,*p=&a,*q; q=p; 4）赋空值：（0、’＼0’、NULL）如：char *c; c=NULL; 5）赋值的形式有：定义时赋值 int a,*p=&a; 定义后赋值 p=&a; 6）注意：指针变量的值只能是内存中的一个地址，不能用数值或表达式给指针变量赋值。指针变量只能存放同类型变量的地址。

如：int *p; p=1000; p=400+1500; (错) char c; p=&c; (错) 4、指针的引用：用取值运算符“*”来存、取指向的变量的值。

如：*p=5; *x=45.65; b=*p+*x; printf(“%d %d＼n”,*p,*x); 5、说明：
1）注意区别定义时的*p和引用时的*p。

如int *a; *a=8; 2）一个任何类型的指针变量，占用存储空间2个字节。（因为内存地址只有0~65535）
6、例从键盘输入两个整数，用交换它们的值后输出。

二、指针与数组（把数组的首地址或某元素的地址给指针后，指针与数组则建立了联系）
1、一维数组：如 int a[10]={2,4,6,8,10,12,14,16,18,20},*p=a; 内容：a[0]~a[9]、p[0]~p[9] *a、*(a+0)~ *(a+9) 、*p、*(p+0)~ *(p+9) 地址：&a[0]~&a[9]、&p[0]~&p[9] a、 (a+0)~ (a+9) 、p、 (p+0)~ (p+9) 2、指针的运算（指针运算前，必须先将指针指向一个数组）
指针加（减）一个整数，结果是指向该数组的另一个元素。

指针自增（自减），结果是指向该数组的下（上）一个元素。

两个指针相减，结果是相距的元素个数。

3、二维数组与指针：
1）二维数组转化为一维指针。

如 int a[3][4]={2,4,6,8,10,12,14,16,18,20,22,24},*p=a; 内容：a[0][0]~a[2][3]、p[0]~p[11] **a、*(*(a+0)+0)~ *(*(a+2)+3) 、*p、*(p+0)~ *(p+11)、*(a[i]+j)、*(a+i)[j]。

如：a[1][2]可以表示为：*(p+7)、p[7]、*(*(a+1)+2)、*(a[1]+2)、*(a+1)[2] 地址：& a[0][0]~&a[2][3]、&p[0]~&p[11] a、 (a+0)~ (a+2) 、*a、 *(a+0)+0~* (a+2)+3、p、 (p+0)~ (p+11) 2）二维数组a[n][m]转化为二维指针：建立一个行指针(*p)[m] 3）二维数组a[n][m]转化为二维指针：建立一个指针数组*p[n] 已知int a[4][5]={1, 2, 3, 4, 5,6, 7, 8, 9, 10,11,12,13,14,15,16,17,18,19,20} 数组a[n][m] 一维指针p 行指针(*q)[m] 数组指针*r[n] int a[n][m], *p, (*q)[m], *r[n]; 赋值 p=a; q=a r=a(赋值错误) r[0]=a[0] r[1]=a[1]… a[1][2] p[6] q[1][2] r[1][2] *(a[1]+2) *(p+6) *(q[1]+2) *(r[1]+2) (*(a+1))[2] (*(q+1))[2] (*(r+1))[2] *(*(a+1)+2) *(*(q+1)+2) *(*(r+1)+2) 4、例题：
例1：用多种方法显示一维数组内容（或地址）。(共4种方法) 2,4,6,8,10,12,14,16,18,20 例2：用多种方法显示下列二维数组内容（或地址）。

int a[4][5]={1, 2, 3, 4, 5,6, 7, 8, 9, 10,11,12,13,14,15,16,17,18,19,20}; main() { int *p,(*q)[5],*r[4],i,j; p=a; q=a; for (i=0;i<4;i++) /*不能用r=a赋值*/ r[i]=a[i]; //行地址 for (i=0;i<4;i++) {for(j=0;j<5;j++) printf(“%4d“,(*(a+i))[j]); /* 注意(*(a+i))的外括号不能少 */ printf(“＼n“); } } 例3：int i,j,a[3][4]={2,4,6,8,10,12,14,16,18,20,22,24},*p=a,*q=a+1; 如何显示内容14，如何显示14的地址。

三、字符数组与指针 1、一维字符数组与指针 1）字符串的两种存储方式及意义：
char a[10]，*p=a; 采用字符数组方式 char *p=”Student”; 采用字符指针方式 p=”xyz” 2）字符串数组与字符串指针的区别 (1)字符数组已经事先预备了空间，字符串一定要存入它的空间里，且数组名是常量。

(2)字符指针不事先预备空间，字符串放在哪里，它就指向哪里，指针名是变量。

注意：如果指针没有指向，则不能一个个赋值。

如：char *p; p[0]=’a’;p[1]=’b’是错误的。

(3)赋值方法：
定义时赋值 char a[10]=”abcd”,*b=”abcde”; 键盘输入赋值 gets(a) gets(b) 直接赋值 a[0]=’a’;a[1]=’b’; b=”xyz” a=”Student”;（错误）
b=”Student”; （正确）
2、二维字符数组与指针 1）定义和意义 char s[5][20]; char *p[5]; 二维字符数组,第一维表示有多少个字符串，第二维表示每个字符串最多有多少个字符 字符指针数组，表示多少个指针，每个指针可以指一个字符串。

2）赋值方法：
定义时赋值：char s[5][20]={“abc“,“mnopq“,“xyxze“,“1235“,“m1235“} char *p[5] ={“abc“,“mnopq“,“xyxze“,“1235“,“m1235“} 键盘输入赋值：scanf(“%s“,s[i]); scanf(“%s“,p[i]); 直接赋值：s[0][0]=＇a＇; p[0]=“abcdef“; 3、注意区别数值数组和字符数组， 1）数值数组名只表示首地址，字符数组名表示首地址，同时也表示整个字符串。

int a[]={1,2,3,…}; char b[]=”This”; printf(“%d＼n%s”,a,b); (a的使用错误) 2）在定义并赋初值时不同 int a[10]={1,2,3,…}; char b[10]={“Student”},c[]=”map”; 3）输入输出时的方式不同。

数值数组只能一个个输入输出，字符数组既可一个个输入输出，也可整体输入输出。

4）一维字符数组表示一个字符串，二维字符数组表示多个字符串。如50个姓名 4、例：1）从键盘输入五个整数，找出最大的整数输出。

main() {int a[5],i,max; for(i=0;i<5;i++) scanf(“%d“,&a[i]); max=a[0]; for(i=1;i<5;i++) if(max<a[i]) max=a[i]; printf(“max=%d＼n“,max); } 2）从键盘输入五个字符串，找出最大的字符串输出。

#include <stdio.h> #include <string.h> main() {char a[5][20],max[20]; int i; for(i=0;i<5;i++) scanf(“%s“,a[i]); strcpy(max,a[0]); for(i=1;i<5;i++) if(strcmp(max,a[i])<0) strcpy(max,a[i]); printf(“max=%s＼n“,max); } 四、二重指针：存放指针变量的地址的变量称二重指针 如：
main() {int a,b,*p=&a,**q=&p; a=10; *p=20; **q=100; printf(“%d＼n“,a); } 五、区别与练习 1、区别 int *p; p、 *p、 *p++、 *(p++)、 (*p)++、 *p+1、 *(p+1) 2、练习：
1）定义int a[]={12,23,31,47,5,9},*p=a, *q=&a[4];后 *p的值_________ *q的值_________ *p++的值_________ *q++的值_________ (*p)++的值_________ *(q--)的值_________ *p+1的值_________ *(q-1)的值_________ 2）若定义int a[2][3]={1,2,3,4,5,6},*p=a; a[1][0] 的值________ *(*(a+0)+1) 的值________ p[4] 的值________ *(p+2) 的值________ 第九章 结构体、共用体、枚举 一、结构体 1、结构体的定义、意义 struct 结构体名 {类型 成员变量表1；

类型 成员变量表2；

类型 成员变量表3；

…… }；

1）学生信息包括学号、姓名、年龄、性别、地址、语文、数学、英语、总分、平均分。

struct student {int num; char name[10]; int age; char sex[3]; char addr[20]; int yw,sx,yy,sum; float avg; }; 2）说明：见课本p249 3）结构体在定义时可以嵌套，但不能递归。

2、结构体变量的定义的四种方法、意义及存储。

1）定义结构体后，再定义结构体变量 struct student s1,*p; 2）定义结构体的同时定义结构体变量 struct student {int num; char name[10]; int age; char sex[3]; char addr[20]; int yw,sx,yy,sum; float avg; } s1,*p; 3）定义结构体的同时定义结构体变量，省略结构体名 struct {int num; char name[10]; int age; char sex[3]; char addr[20]; int yw,sx,yy,sum; float avg; } s1={1,”zs”,18,”n”,”cz”,85,90,77},*p=&sl,a; a=sl 4）先对结构体取一个别名，再用别名定义结构体变量 typedef struct student {int num; char name[10]; int age; char sex[3]; char addr[20]; int yw,sx,yy,sum; float avg; }ST; ST s1,*p; 3、结构体变量的引用。

结构体变量.成员名 如s1.name s1.sum 结构体指针变量->成员名 如p->name p->sum 4、结构体变量的赋值| 1) 定义变量的同时赋值。（初始化）
2) 直接单独赋值 s1.age=18; s1.yw=85; p->sx=96; strcpy(s1.name,”WangJun”) /*错误：p->name=” WangJun”*/ 3）从键盘赋值  scanf(“%s%d%d”,s1.name,&s1.yy,&s1.sx); gets(s1.addr); 5、对结构体变量名的使用 1）
一个变量名赋给另一个变量名，即整体赋值。b=a; 2）
一个变量的地址赋给一个变量指针变量。如p=&a; 如：struct student {int num; char name[10]; int age; char sex[3]; char addr[20]; int yw,sx,yy,sum; float avg; }; main() {struct student s1={1001,“王小艳“,18,“女“,“郴州“,86,97,79},s2,*p; s2=s1; printf(“%s＼n“,s2.addr); p=&s1; p->sex=“男“; /*本语句使用错误 */ printf(“%s＼n“,p->sex); printf(“%s＼n“,p->addr); printf(“%u,%u,%u,%u＼n“,&s1,&s2,&p,p); printf(“%u,%u,%u,%u,%u,%u,%u,%u“,&s1.num,s1.name,&s1.age, s1.sex,s1.addr,&s1.yw,&s1.avg,&s2); } 6、链表：
链表有一个头指针，它指向第一个结点；
链表的每个结点至少有一个数据项，还有一个指向下一个结点的指针。

如：1) struct link 2) struct link {int x; {int num; float y; char name[10]; struct link *next; struct link * next; }a,b,c；

}s；

a.x=5;a.y=6.5;a.next=&a; b.x=10;b.y=12.5;b. next =&c; c.x=12;c.y=15.5;c. next =NULL; 链表操作例题 #include <malloc.h> #include <stdio.h> typedef struct student {int data; struct student *next; }ST; ST *insert(ST *head); void liulan(ST *head); ST *delete(ST *head,int n); main() {ST a,b,c,d,*head,*p,*q,*s; int n=15; a.data=5; b.data=10; c.data=15; d.data=20; head=&a; a.next=&b; b.next=&c; c.next=&d; d.next=NULL; liulan(head); head=insert(head); printf(“＼n“); liulan(head); head=delete(head,n); printf(“＼n“); liulan(head); } void liulan(ST *head) {ST *p; p=head; while(p!=NULL) {printf(“%d “,p->data); p=p->next; } } ST *insert(ST *head)/*链表的插入*/ {ST *p,*q,*s; s=(ST *)malloc(sizeof(ST)); s->data=12; p=head; q=head; while(p!=NULL&&p->data<s->data) {q=p; p=p->next; } s->next=p; q->next=s; return head; } ST *delete(ST *head,int n) {ST *p,*q; p=head; q=head; while(p!=NULL&&p->data!=n) {q=p; p=p->next; } q->next=p->next; free(p); return head; } 例题：某班有50个学生，每生包含学号、姓名、语文、数学、总分、平均分，编程输入学生的基本信息、计算总分和平均分、输出所有学生信息。

struct student {int num; char name[10]; int yw,sx,sum; float avg; }; main() {struct student st[50]; int i; for (i=0;i<3;i++) {scanf(“%d%s%d%d“,&st[i].num,st[i].name, &st[i].yw,&st[i].sx); st[i].sum=st[i].yw+st[i].sx; st[i].avg=st[i].sum/3.0; } for (i=0;i<3;i++) printf(“%d %s %d %d %d%.1f＼n“,st[i].num,st[i].name,st[i].yw,st[i].sx, st[i].sum,st[i].avg); } 例1：union aa 例2:union aa 例3: union aa {char c[2]; {char c0,c1,c2,c3; {char c[4]; int d; int d; int d; } } } main() main() main() {union aa a,b; {union aa a,b; {union aa a,b; a.c[0]=＇a＇; a.c0=7>>2; a.c[0]=7>>2; a.c[1]=＇b＇; a.c1=8^10; a.c[1]=8^10; printf(“%d“,a.d); printf(“%d“,a.d); printf(“%d“,a.d); } } }