计算机二级课程第 1章 程序设计基本概念

计算机二级课程

第1章程序设计基本概念

1.1程序和程序设计

1.1.1C程序

计算机语言：二进制

用户：自然语言

自然语言9英文助记符、数学表达式（C语言）分二进制指令（目标文件*.obj）

9可执行程序（*.exe）

C源程序（*.c）不能直接执行，只能进行编辑

源程序转换为目标文件的过程，叫做“编译compile"

目标文件（*.obj）也不能直接执行

目标文件转换为可执行程序的过程，叫做“连接link”

*.c---compile->*.obj---link->*.exe

1.1.2程序设计

1.2算法

算法：为解决某个问题而采用的确定且有限的步骤。

算法的特性：

1）有穷性：算法应该在有限的步骤内结束。

2）确定性：算法不能有二义性，对于相同的输入能得到相同的输出。

3）可行性：算法的步骤可以实现。

4）拥有足够的情报：算法有0个或多个输入；1个或多个输出。

1.3结构化程序设计和模块化结构

1.3.1结构化程序

C语言程序有3种基本结构：

顺序结构

选择结构（分支结构）

循环结构（重复结构）

1.3.2模块化结构

自顶向下、逐步求精、模块化

C语言使用“函数”实现模块化。

C语言是函数的语言。

C程序的基本组成单位是函数。

第2章C程序设计的初步知识

2.1简单C语言程序的构成和格式

#include<stdio.h>

main()

doublea,b,area;

a=1.2;/*将矩形的两条边分别赋给a和b*/

b=3.6;

r计算矩形的面积7

area=a*b;

,H

printf('a=%f,b=%f,area=%f\nJa,b,area);

)

说明：

1、main是主函数名。C语言程序必须使用main作为主函数名，其后需接一对圆括号()表

示其函数身份。main函数是C程序唯一的入口，也是程序唯一的出口，C程序从main函

数的第一条语句开始执行。故，C程序有且仅有一个main函数。

2、C程序的语句以分号结尾。一般一条语句作为一行，但可以在一行上写多条语句，也可

以将一条语句写成多行。语句需写在｛｝表示的函数体内。

3、在程序中可以使用I*……*/符号表示注释，被注释的部分将不会在程序执行过程中

起作用，仅仅作为程序的说明。

inta=3,b=5;

a=10;I*赋值*/

b=20;

a+b的值是30

inta=3,b=5;

a=10;/*赋值b=20;

*1

a+b的值是_15

2.2标识符、常量和变量

2.2.1标识符

标识符包括：变量名、数组名、函数名。

1）由字母、数字、下划线组成；

2）数字不能开头；

3）不能和关键字重名。

int（整型）float（单精度实型）double（双精度实型）char（字符

型）

sizeof（求字节数）short（短整型）long（长整型）

areaPIa_arrayx100_100x（正确）

a$ba++x.y100x（错误）

变量名可以叫做main、printf

标识符对大小写敏感。

int（错误）

Int（正确）

2.2.2常量

常量：在程序执行过程中，值不发生改变的量。

12-10（整型常量）

3.14-2.70.0（实型常量）

A'b'（字符型常量）

"NCRE”“Wuhan"（字符串常量）

2.2.3符号常量

习惯上，常量使用大写字母表示，变量使用小写字母表示，但不是必须的。

#defineN10

main（）

（

N=N*2;/*不能对符号常量赋值*1

printf（"%d\n",N）;

）

main()

intn=10;

n=n*2;/*可以对变量赋值*/

printf("％d\n”,n);

}

#definePI3.14

main()

{

doubler,s;

r=5.0;

s=r*r*PI;

printf("s=%f\nH,s);

)

变量名可以叫做define、include

2.2.4变量

变量：在程序执行过程中，值可以发生改变的量。

变量必须“先定义，后使用”

定义时，需指明变量的数据类型和变量名。

2.3整型数据

2.3.1整型常量

十进制：32767-327680

八进制：由“0”引导的整数。01001102340386(错误)

十六进制：由“Ox”或“0X”引导的整数。0x123Oxaa0x1ff

0~9a-10b-11...f-15

长整型常量：40000L40000I

无符号型常量：100U100u-12U(错误)

2.3.2整型变量

inta;

inta,b,c;

2.3.3整型数据的分类

long(int)4字节

int4字节

short(int)-32768~327672字节

signed有正有负

unsigned正整数

unsignedshort0~65535

2.3.4整型数据在内存中的存储形式

位（bit）:二进制位100110最小单位

字节（byte）:1byte=8bit最基本单位

2.4实型数据

2.4.1实型常量

小数形式：0.123.1233.03.

在实数的整数部分或小数部分为0时，可将为0的部分省略，但小数点不可省。

0.00..0,（错误）

指数形式：3E2->3*102->3003.15e33.15e-1

E（e）的前面必须有数字，后面必须为整数。

E22e3e1.0（错误）

2.4.2实型变量

float（单精度实型）4字节

double（双精度实型）8字节

2.5算术表达式

2.5.1基本的算术运算符

整数和整数运算，结果为整数

参与运算的数字中，有一个实数，结果结果就为实数

+-*

/注意：在什么情况下运算结果才有小数部分。

%求余数。求余数运算两边必须为整数。

绝对值相除得余数，符号取决于被除数。

main()

(

printf("%d\n",4%3);1

printf("%d\n",4%-3);1

printf("%d\n",-4%3);-1

printf("%d\n",-4%-3);-1

)

2.5.2运算符的优先级、结合性和算术表达式

*/%

+-

2.5.3强制类型转换表达式

(目标类型)需转换变量

(int)bint(b)(错误)

2.6赋值表达式

2.6.1赋值运算符和赋值表达式

注意：

1)赋值运算的优先级很低，往往需要在所有运算完成后，再进行赋值。

2)赋值运算理解上，从右向左进行。

3)赋值后，右侧变量值不变，左侧变量值更新。

4)赋值号左侧只能是变量，不能是常量或表达式。

5)赋值表达式整体的值，等于被赋值变量的值。

main()

(

inta,b;

printf(',%d\n,,,(a=3)+(b=5));

}

2.6.2复合赋值表达式

a+=13a=a+1

a*=29a=a*2

a*=1+2今a=a*(1+2)

main()

inta=5;

a+=a-=a+a;

printf(,'%d\n'',a);

)

2.6.3赋值运算中的类型转换

以被赋值变量的类型为准。

inta;

a=3.5;3

floata;

a=3;3.0

2.7自加、自减运算符和逗号运算符

2.7.1自加运算符”++”和自减运算符“一”

独立构成语句时，i++和++i是等价的。

j=i++；-j=j；今先取值，后自增

i=i+1;

j=++i;9i=i+1;“先自增，后取值

j=i；

main()

inti=5;

printf("%d\n',,i++);5

printf("%d\nn,++i);7

)

2.7.2逗号运算符和逗号表达式

逗号运算符的优先级最低；

从左至右运行每个表达式；

整个逗号表达式的值，等于最后一个表达式的值。

main()

(

inti,j,x;

x=(i=3,j=4);

printf("%d\n",x);4

)

main()

(

inti,j,x;

x=i=3,j=4;

printf("%d\n",x);3

)

第3章顺序结构

3.1赋值语句

在赋值表达式后加上“：号，构成赋值语句

a=10赋值表达式

a=10;赋值语句

3.2数据输出

3.2.1printf函数的一般调用形式

printf(l'a=%d\n",a);

1)非格式说明符部分原样输出。如：a=

2)转义符进行转义。\n换行

\t下一制表位

\b退格

\r回到开头

3)格式说明符输出变量值。

3.2.2printf函数中常用的格式说明

%d

%ld

%u

%o

%x

%f

%lf

%e

%g

3.2.3使用printf函数时的注意事项

3.3数据输入

3.3.1scanf函数的一般调用形式

scanf中格式说明符的相关规则，和printf相同。

scanf中变量前需要加&号(取地址卜

scanf("%d",&a);

3.3.2scanf函数中常用的格式说明

3.3.3通过scanf函数从键盘输入数据

scanf中非格式说明符部分，在输入时应原样输入。

scanf("%d,%d",&a,&b);10,20

scanf("a=%d,%d",&a,&b);a=10,20

连续格式说明符，应使用空格、制表符、回车分隔数据。

scanf("%d%d",&a,&b);1020

按指定宽度输入数据。

scanf("%2d%3d%d",&a,&b,&c);123456789

printf("%d,%d,%d\n",a,b,c);12,3,456

跳过某个输入数据。格式说明符中*号，表示跳过此位置的输入。

a=b=c=5;

scanf("%d%*d%d",&a,&b);123

printf("%d,%d,%d\n",a,b,c);1,3,5

3.4复合语句和空语句

3.4.1复合语句

在C语言中，可以使用｛……｝号将多条语句括起来，形成复合语句。

复合语句在逻辑上当做一条语句处理。

3.4.2空语句

;号是构成C语言语句的重要符号，若只有一个；号也能构成语句，它是一个空语句。

空语句本身不做任何操作，故一般不会影响程序结果，而不是完全不会影响程序结果。

第4章选择结构

4.1关系运算和逻辑运算

4.1.1C语言的逻辑值

C语句中没有逻辑类型。

在程序中使用0值表示假，使用非0值表示真。

main()

(

if(O)printf("yes\n");

elseprintf("no\n");

}

no

main()

{

if(-1)printf("yes\n");

elseprintf("no\n");

)

yes

在程序计算结果时，用0值表示假，用1表示真。

main()

printf(',%d\n,,,2<300);1

)

4.1.2关系运算符和关系表达式

><>=<===!=

C语言中不能正确表示连续的关系运算

main()

{

printf(',%d\n,,,4>3>2);0

)

><>=<=优先级较高

==!=优先级较低

main()

(

printf("%d\n",1==3>1);1

4.1.3逻辑运算符和逻辑表达式

&&逻辑与“且”两边同时为真，结果为真。

||逻辑或“或”两边有一边为真，结果为真。

!逻辑非原来真，变为假。原来假，变为真。

main()

printf(',%d\nH,4>3&&3==2);0

printf(',%d\nH,4>3||3==2);1

pnntf("%d\nH,!(4>3));0

逻辑运算的中断：

&&运算前段为假，后段不运行。

main()

{

intx=3,y=5;

(x=0)&&(y=8);

printf(“％d,%d\n“,x,y);0,5

)

II运算的前段为真，后段不运行。

main()

(

intx=O,y=O;

x++||y++;

printf("%d,%d\n",x,y);1,1

)

运算符的优先级：

单目算术运算符关系运算符逻辑运算符赋值运算符逗号

运算符

!*/%+->>=<<===!=&&||=

!4>3&&2+5||7*31

4.2if语句和用if语句构成的选择结构

4.2.1if语句

计算if的括号内表达式的值是否为真，若为真则运行if的子句

)

main()

(

intx;

scanf(n%dn,&x);

if(x%2==0)

printf("偶数\n")；

)

注意：

1)if只能控制最近的一条语句。

main()

intx;

scanf("%d",&x);

if(x%2==0)

x++;

x++；

printf(n%d\nn,x);

)

2)若有多条语句作为if的子句，需用。构成复合语句。

main()

{

inta=3,b=6,t=0;

if(a==b)t=a;a=b;b=t;

,n

printf('%d,%d\nJa,b);6,0

)

3)在if的括号后不用加7号，否则会影响程序的逻辑。

main()

intx=8;

if(x==6);

x++;

printf("%d\nn,x);9

)

4)if的条件通常是一个关系表达式，但要注意其他情况，特别是赋值表达式冒充关系表达

式的情况。

main()

{

intx=8;

if(x=6)

x++；

printf("％d\n”,x);7

}

if-else

计算if的括号内表达式的值是否为真，若为真则运行if的子句，否则运行else的子句。

main()

intx;

scanf("%d",&x);

,,

if(x>0)printf(%d\n"Jx);

elseprintf(,'%d\n",-x);

)

注意：

1)else和最近的if配对

4.2.2嵌套的if语句

main()

{

inta=3,b=4,c=5;

if(a>3)

if(b==4)C++;

elsec-;

printf("%d\nu,c);5

main()

inta=3,b=4,c=5;

if(a>3)

(

if(b==4)C++;

}

elsec-;

printf("%d\nH,c);4

)

4.3条件表达式构成的选择结构

条件表达式是C语言中唯一的三目运算。

exp1?exp2:exp3

先计算exp1是否为真，若为真取exp2,为假取exp3。

main()

printf("%d\n",5>3?4<7?1:10:100);1

)

4.4switch语句以及用switch语句和break语句构成的选择结构

4.4.1switch语句

switch(a)

{

case1:n++;

case2:n++;

case3:n++;

case4:n++;

case5:n++;

)

语法规定：

1)switch后有一对小括号。

2)小括号中必须时整型或字符型表达式。

3)小括号后不能有“;”号。

4)case和数值间的空格不能省略。

5)case后需使用"号。

4.4.2switch语句的执行过程

1)计算switch的括号内表达式的值。

2)判断表达式的值和哪一个case相等，若找到了，则运行对应case后的语句。

3)若没有找到，则运行default后的语句。

4）当某一个部分的语句运行后，会无条件的运行其后所有的语句，直到遇到break为止。

4.4.3在switch语句体中使用break语句

在结构中遇到break语句，立即终止结构。

main()

{

inta=O,n=O;

switch(a)

(

default:n++;

case1:n++;

case2:n++;

case3:n++;break;

case4:n++;

case5:n++;

}

printf("％d\n”,n);4

}

4.5语句标号和goto语句

4.5.1语句标号

4.5.2goto语句

第5章循环结构

5.1while语句和用while语句构成的循环结构

5.1.1while循环的一般形式

循环变量初始化

while（循环条件）

（

循环体

）

5.1.2while循环的执行过程

1）循环变量初始化

2）判断循环条件，若条件为真，则运行循环体。若条件为假，循环终止。

3）循环体运行完，返回到第2步，判断条件。

1+2+3+.......+100

main()

intsum=0,i=1;

while(i<=100)

{sum=sum+i;

i++；

)

printf("%d\nn,sum);

}

1+2+3+......+50

main()

{

intsum=0,i=1;

while(i<=50)

{sum=sum+i;

i++；

)

printf("％d\n”,sum);

}

30+31+32+.......+50

main()

intsum=0,i=30;

while(i<=50)

{sum=sum+i;

i++；

)

pnntf("%d\nu,sum);

)

30+32+34+.......+50

main()

{

intsum=0,i=30;

while(i<=50)

{sum=sum+i;

i+=2;

)

printf("%d\n",sum);

)

1到100内，3和5的公倍数的和

main()

intsum=0,i=1;

while(i<=100)

if(i%3==0&&i%5==0)

sum=sum+i;

i++；

)

printf("%d\nn,sum);

}

12+22+32+......+102

main()

(

intsum=0,i=1;

while(i<=10)

(

sum=sum+i*i;

i++；

}

printf("%d\n",sum);

)

5.2do-while语句和用do-while语句构成的循环结构

5.2.1do-while语句构成的循环结构

循环变量初始化

do

{

循环体

}while(循环条件)；

main()

{

intsum=0,i=1;

do

{

sum=sum+i;

i++；

}while(i<=100);

printf("%d\nH,sum);

)

5.2.2do-while循环的执行过程

1）循环变量初始化

2）运行循环体

3）判断循环条件，若条件为真，则返回第2步继续循环；若条件为假，则循环终止。

while循环和do-while循环的比较

1）语法区别：while的条件在循环体前，do-while的条件在循环体后，前面是do;while的

条件没有"：'号，do-while有。

2）逻辑区别：while先判断条件，后执行循环体；do-while先执行循环体，后判断条件。

当初始条件不满足时，while一次也不运行循环体；而do-while至少运行一次。

5.3for语句和for语句构成的循环结构

5.3.1for语句构成的循环结构

for（循环变量初始化;循环条件;循环变量增量）

（

循环体

）

5.3.2for循环的执行过程

1）循环变量初始化

2）判断循环条件，若条件为真，则运行循环体；若条件为假，循环终止。

3）运行循环体

4）运行循环变量增量后，返回到第2步，判断条件

1+3+5+.......+99

main()

{

intsum=O,i;

f0r(i=1;i<=99;i+=2)

sum+=i;

printf("%d\n",sum);

}

1-2+3-4+5-6+7.......+99-100

main()

(

intsum=0,i,s=1;

for(i=1;i<=100;i++)

{

sum+=s*i;

s=-s;

)

printf("%d\n",sum);

)

1+1/2+1/3+……+1/50

main()

(

doublesum=0;

inti;

for(i=1;i<=50;i++)

(

sum+=1.0/i;

)

printf("%f\n",sum);

)

5.3.3有关for语句的说明

1)for语句中的三个表达式都是可以省略的。

i=1;

for(;i<=100;i++)

{

sum+=i;

}

i=1;

for(;i<=100;)

sum+=i;

i++；

)

死循环-无法退出的循环

i=1；

for(;;)

(

if(!(i<=100))

break;

sum+=i;

i++；

)

5.4循环结构的嵌套

外层循环每循环一次，内层循环循环一轮;

内层循环循环结束，外层循环才循环一次。

main()

(

inti,j,cnt=O;

for(i=1;i<=4;i++)

for(j=1;j<=3;j++)

cnt++;

printf("%d\nH,cnt);

)

5.5break和continue语句在循环体中的作用

5.5.1break语句

立刻终止循环结构

main()

(

inti,sum=0;

for(i=1；i<=10;i++)

{

if(i==5)

break;

sum+=i;

}

printf("%d\n,,,sum);10

)

5.5.2continue语句

结束（跳过）本次循环后面的语句，继续一下次循环。

main()

inti,sum=O;

for(i=1;i<=10;i++)

(

if(i==5||i==7)

continue;

sum+=i;

}

printf(',%d\n,,,sum);43

)

第6章字符型数据

6.1字符型常量

6.1.1字符常量

'A'b'#''\n'

C语言中所有的字符，以ASCII码存放。

'A'-65

'a'"97

'O'-48

注意：

1）有多种字符常量:$,

2）单引号内只能是一个字符'ab'（错误）

6.1.2转义符常量

'\n'换行

'\t'制表符

'\b'退格

'\r'返回

'\\'\

'V，

'\ddd'由1~3位八进制数表示的ASCII码值所对应的字符'\101'-'A'

'\108'（错误）

'\xhh'由1~2位十六进制数表示的ASCII码值所对应的字符‘\x65'-'e'

6.1.3字符串常量

“abc”串长=3

“a\bc”3

“abc123”6

uabc\123"4

空串0

6.1.4可对字符常量进行的运算

C语言中字符就是一个整数，所以可以对其进行运算。

对字符型进行的运算，就是对其ASCII码值进行的运算。

大写字母+32〉所对应的小写字母

小写字母-32f所对应的大写字母

6.2字符变量

charc1;

charc1='A';

6.3字符的输入和输出

6.3.1调用printf和scanf函数输出和输入字符

%c字符型的格式说明符

注意：

main()

(

charc1,c2;

scanf("%c%c",&c1,&c2);

printf("%c,%c\n",c1,c2);

)

在scanf中使用连续的％c%c输入字符型数据时，不能使用任何方式分割字符，必须连续输

入。

否则，用来分割的符号会作为有效输入赋给变量。

main()

{

charc1,c2;

scanf("%2c%2c",&c1,&c2);

printf("%c,%c\n",c1,c2);

)

指定宽度输入时，只会将第一个字符赋给变量。

main()

{

inta,b;

charc;

scanf("%d%c%d,',&a,&c,&b);10A20

printf(“％d,%c,%d\n”,a,c,b);10,A,20

}

6.3.2调用putchar和getchar函数输出和输入字符

main()

{

charc='a';

c=getchar();

putchar(c);

)

第7章函数

7.1库函数

库函数系统已经定义好的函数，直接调用即可。

库函数的使用方法：

1)独立构成语句。printf("％d”,x);

2)作为表达式的一部分。n=pow(2,2)+abs(-5)+sqrt(4);

stdio.hprintf()scanf()putchar()getchar()

math.hpow(2,3)-8

abs(-3)・3fabs(-3.5)-3.5

sqrt(9)-3

7.2函数的定义和返回值

和其他的程序元素一样，函数也必须先定义，后使用。

7.2.1函数定义的语法

intfun(inta,intb)

returna+b;

)

函数定义一般形式:

函数类型函数名（参数类型参数名，参数类型参数名.....）

（

函数体

）

注意：

1）函数类型应和函数返回值的类型一致。当不一致时，按照赋值原则，以函数类型为准。

若函数无返回值，则应将函数定义为void类型（空类型b当定义函数时，未声明函数类型，

则函数的默认类型为into

2）函数名需符合标识符命名规则。

3）定义函数时所列出的参数叫‘形式参数”（形参卜每个形参均需分别声明类型。形参的个

数任意，若形参个数为0时，称函数为无参函数。

4）函数不能嵌套定义，即，不能在一个函数里面定义新的函数。

5）函数需先定义，后使用。即，定义部分需放在调用部分的前面。若函数类型为int时，

定义放在调用后也可（不推荐b

7.2.2函数的返回值

函数通过return语句返回值。

returna+b;或return（a+b）;

函数运行到return时，会将return后表达式的值作为函数值返回，同时立刻终止掉函数的

运行，返回到函数被调用的位置。

若函数中无return,则当最后一条语句运行完时终止。

7.3函数的调用

7.3.1函数的两种调用方式

1)独立构成语句。printf("%d",x);

2)作为表达式的一部分。n=pow(2,2)+abs(-5)+sqrt(4);

7.3.2函数调用时的语法要求

1)函数名必须与定义的函数名一致。

2)调用函数时出现的参数叫“实际参数”(实参卜实参一般一个确定的常量、变量或表达式。

实参不需要声明类型。

3)实参必须与形参完全匹配。个数、类型、顺序。若实参类型与形参类型不一致时，按赋

值原则，以形参类型为准。

4)调用时，实参值单向传递给形参。

7.4函数的声明

7.4.1函数声明的形式

函数首部；

函数声明中需指出以下内容：函数类型、函数名、参数类型。

doublefun(intjnt);正确形参名不是函数声明时的必要内容。

7.4.2函数声明的位置

前面：所有代码的前面；main函数的前面。

函数声明可以出现在某个函数的内部。

7.5调用函数和被调用函数之间的数据传递

函数的参数传递是单向的，只能有实参传递给形参，形参的改变是不能影响实参的。

第8章地址和指针

8.1变量的地址和指针

地址：变量在内存中的编号。

指针：用来存放地址的变量。

地址•今指针

8.2指针变量的定义和指针变量的基类型

inta;

int*p;

注意：*号的作用在C语言中有3种：

乘法；

当*出现在定义语句中时，表示后面的变量是个指针；

*以单目运算符形式出现普通语句中时，表示取值（取出指针所指变量的值卜

p=&a若有针对指针的赋值，理解上应从左向右进行，理解为：令p指向a。

在P指向a的前提下，程序产生两组等价关系。

p3&a

*p<-玲a

*p=&a;错误

int*p=&a;正确

main()

{

inta=5,*p=&a;

a=10;

*p=20;

printf(”％d,%d\n“a*p);2020

}

8.3给指针变量赋值

8.3.1给指针变量赋地址值

1）令指针直接指向变量

inta,*p;

p=&a;

2）通过其他指针确定指向

inta,*p=&a,*q;

q=p；

main()

inta=5,*p=&a,*q;

q=p;

a=10;

*p=20;

*q=30;

printf("%d,%d,%d\n",a,*p,*q);30,30,30

)

8.3.2给指针变量赋“空”值

在stdio.h中定义了符号常量NULL—0EOF--1

NULL0'\0'

int*p;

p=NULL;令指针p指向空

空地址是系统的保留地址，即，不可向空地址中赋值。

int*p=NULL;

*p=10;错误。不能对指向空地址的指针赋值。

int*p;

*p=10;错误。不能对未确定指向的指针赋值

inta,*p=&a;

*p=10;正确

8.4对指针变量的操作

8.4.1通过指针来引用一个存储单元

在指针前加*号即可。

*和&互为逆运算

二级指针(指向指针的指针)

main()

{

inta=5,*p=&a,**q;

q=&P；

printf("%d,%d,%d\n",a,*p,**q);5,5,5

)

8.4.2移动指针

指针移动仅发生在指针指向数组时。此时，令指针自增，表示将指针向后移动；自减，表示

向前移动。

main()

(

inta[5]={10,20,30,40,50},*p=&a[2];

P++；

printf(',%d\n,,,*p);40

)

是否移动，主要看指针是否又被重新赋值。

p++p=p+1

加几，表示后移几个位置；减几，表示前移几个位置。

main()

inta[5]={10,20,30,40,50},*p=&a[2];

printf(',%d\n,',*p++);先取p和*号结合，取值30,后移动p

printf("%d\nH,(*p)++);先取*p,40,后累加*p值为41

printf("%d\n",*++p);先后移p,后取*p值，50

printf("%d\n",++*p);先累加*p值，后取值，51

)

8.4.3指针比较

仅当指针指向同一数组时，才有比较的意义。

main()

{

inta[5]={10J20J30,40,50},*p=&a[1],*q=&a[3];

printf("％d\n”,q・p);2

)

指针相减，减的是所指的数组下标。

8.5函数之间地址值的传递

8.5.1形参为指针变量时实参和形参之间的传递

函数参数传递是单向的，只能由实参传递给形参，形参的改变是无法影响实参的，但指针除

外。

fun(inta,int*b)

(

a=a+*b;

*b=a+*b;

)

main()

(

inta=10,b=20;

fun(a,&b);

printf(n%d,%d\nn,a,b);10,50

)

8.5.2通过传送地址值在被调用函数中直接改变调用函数中的变量的值

8.5.3函数返回地址值

int*fun(int*a,int*b)

if(*a>*b)returna;

elsereturnb;

}

main()

(

inta=10,b=20;

int*c;

c=fun(&a,&b);

printf(n%d\nn,*c);20

)

第9章数组

9.1一维数组的定义和一维数组元素的引用

9.1.1一维数组的定义

inta[10];

说明：

1)这里定义的是一个由10个int型元素组成的一维数组ao

2)定义时方括号中的整型常量表达式表示数组中元素的个数。定义数组时须指明长度，且

长度表达式不能由实型或变量组成。

3)数组元素的下标从0开始，故长度为5的数组，下标最大只能到4。

inta[10];正确

inta[5+5];正确

intn=10,a[n];错误

intn[5.0]错误

#defineN10

inta[N];正确

inta[];错误

9.1.2一维数组元素的引用

求和：

inti,sum=O;

for(i=0;i<=9;i++)

sum+=a[i];

求平均值：

inti,sum=O;doubleave;

for(i=0;i<=9;i++)

sum+=a[i];

ave=sum/10.0;

求最值：

inti,max;

max=a[O];

for(i=0;i<=9;i++)

if(max<a[i])

max=a[i];

转置：

int

for(i=0,j=9;i<j;i++,j-)

(

t=a[i];a[i]=aQ];a[j]=t;

)

排序：

排序使用3个变量完成，外层循环i从第1个开始到倒数第2个为止，内层循环j从i的下

一个开始到最后为止，循环体内比较的关系(重复后一个字，从小到大)，交换a[i]a[j]

inti,j,t；

for(i=0;i<=8;i++)

for(j=i+1;j<=9;j++)

if(a[i]<a[j])

t=a[i];a[i]=aO];a[j]=t;

)

9.1.3一维数组的初始化

intb[5]={10,20,30,40,50};标准方式：初始化个数和数组长度相同

intb[5]={10,20,30,40,50,60};错误

intb[5]={10,20,30);定义数组时若只给部分元素赋初值，则未被赋初值的元素

将自动赋。值。

intb[]={10,20,30);定义数组时若同时对数组进行初始化，则可以省略数组的

长度，

此时，数组长度等于初始化的个数。

9.1.4通过赋初值定义数组的大小

9.2一维数组和指针

数组名代表数组的首地址常量。首地址(首个元素的地址卜

inta[5],*p;

p=a;

p=&a[0];

程序中所有出现a的地址都能被p替换。

printf("%d\n",*p++);

printf("%d\n",*++p);

printf("%d\n",++*p);

printf("%d\n",(*p)++);

printf("%d\n",*p);

数组元素的多种表示方法：

a[i]p[i]*(P+i)*(a+i)

p++;对

a++;错

指针指向数组中段，下标从0开始重新计数。

inta[5]={10,20,30,40,50);

int*p;

P=&a[2];

printf("%d\n",p[-1]);20

9.3函数之间对一维数组和数组元素的引用

9.3.1数组元素作实参

和普遍变量一样

9.3.2数组名作实参

数组名作为实参，则形参有以下表达方式:

1）使用和实参一样的数组定义。inta[N]

2）使用不指明长度的数组定义。inta[]

3）使用指针表示。int*a

9.3.3数组元素地址作为实参

9.3.4函数的指针形参和函数体中数组的区别

9.4一维数组应用举例

9.5二维数组的定义和二维数组元素的引用

9.5.1二维数组的定义

inta[2][3];

9.5.2二维数组元素的引用

9.5.3二维数组的初始化

inta[2][3]={{1,2,3},{4,5,6}）;

inta[2][3]={{1,2},{4}};

inta[2][3]={1,2.4）；

inta口[3]={{1,2,3},{4,5,6}};

inta[2][]={{1,2,3},{4,5,6});错误

主对角线置0:

for(i=0;i<=3;i++)

a[i][i]=O；

左下三角置0:

for(i=0;i<=3;i++)

for(j=0;j<=i;j++)

a[i]D]=O;

右上三角置0:

for(i=0;i<=3;i++)

for(j=i；j<=3;j++)

a[i]0]=O；

反对角线置0:

for(i=0;i<N;i++)

a[i][N-1-i]=0;

左上三角置0:

for(i=0;i<N;i++)

for(j=0;j<=N-1-i;j++)

a[i]0]=O；

右下三角置0:

for(i=0;i<N;i++)

for(j=N-1-i;j<N;j++)

a[i]0]=O；

转置：

for(i=0;i<N;i++)

forG=0;j<=i;j++)

(

t=a[i]O]；a[i]O]=aO][i];a皿i]=t;

}

9.6二维数组和指针

二维数组的一维表示：

inta[N][N]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16));

int*p=a;

printf("%d",p[5]);6

二维数组元素的多种表示方法：

*(a[i]+j)*(*(a+i)+j)(*(a+i))[j]*(&a[0][0]+i*N+j)

指向数组的指针：

inta[2][3]={{1,2,3},{5,6,7});

int(*p)[3];

P=a;

由指针构成的数组：

inta[2][3]={{1,2,3},{5,6.7});

int*p[2];

p[O]=a[O];

p[1]=a[1]；

int*p;

int**p;

int(*p)[M];

int*p[N];

9.7二维数组和指针数组作为实参

inta[N]

inta[]

int*a

二维数组作为形参的多种表示：

inta[N][M]

inta[][M]

int**a;

int(*a)[M]

第10章字符串

10.1用一维字符数组存放字符串

程序会自动在字符串常量的末尾添加(看不见的八0'—字符串的结束符

chars[]={Habcn);

printf("%d\nH,sizeof(s));

'\0'0NULL

10.1.1通过赋初值的方式给一维字符数组赋字符串

chars1[尸{七be”};

chars2[]={'a','b?c?\0'};

10.1.2在C程序执行过程中给一维字符数组赋字符串

charsO^aVb'/c^O'};

chars|]={"abc"};

charsO=,,abc";

chars[4]="abc";

char*p=,'abcn;

char*p;p=Habcn;

错误情况：

charsQ={'a','b','c');

chars[3]="abc";

chars[4];s="abc";

10.2使指针指向一个字符串

10.2.1通过赋初值的方式使指针指向一个字符串

10.2.2通过赋值运算使指针指向一个字符串

10.2.3用字符数组作为字符串和用指针指向的字符串之间的区别

10.3字符串的输入和输出

10.3.1输入和输出字符串时的必要条件

10.3.2用格式说明符％s进行整串输入和输出

%d%o%x%f%c

%s表示从当前所指的位置开始输出，直到遇到结束符为止。

main()

(

chars[]="abcdef;

char*p=s;

printf("%s\n",p+2);cdef

)

使用％5输入字符串时，遇到空格将停止输入。

chars1[20],*p=s1;

scanf("%s",p);

chars1[20],*p;

scanf(n%sn,p);不能对未确定指向的指针赋值

10.3.3调用gets、puts函数在终端输入或输出一行字符串

gets(s)能够接受空格的输入

main()

(

chars[20];

gets(s);

puts(s);

)

10.4字符串数组

10.5用于字符串处理的函数

strlen(s)求字符串长度，从当前所指的位置开始统计，直到遇到结束符为止。

chars[20]="abcde";

printf("%d\n",strlen(s));5

printf("%d\n",sizeof(s));20

chars[]="abcde";

printf("%d\n",strlen(s));5

printf("%d\n",sizeof(s));6

strcpy(s1,s2)将后一个字符串的内容复制到前一个字符串中。

strcat(s1,s2)将后一个字符串连接到前一个字符串的后面

strcmp(s1,s2)比较两个字符串的大小，前面大返回正数

相等返回0

后面大返回负数

第11章对函数的进一步讨论

11.1传给main函数的参数

main(intargc.char*argv[])

其中：

argc表示执行程序时命令行参数的个数。

argv口中存放的是各命令行参数的首地址。

main(intargc.char*argv[])

while(argc>1)

argc-;

printf(H%s",argv[argc]);

)

)

11.2通过实参向函数传递函数名或指向函数的指针变量

int(*f)()；指向函数的指针

intadd(inta,intb)

{

returna+b;

)

main()

(

int(*f)(int,int);//定义指向具有2个整型参数且返回值为整型的指针f

f=add;//令指针f指向函数add

printf("%d\n",(*f)(3,5));〃通过指针f调用函数addf(3,5)

)

int(*f)(int,int);指向函数的指针

int*f(inta,intb);返回值为指针的函数

11.3函数的递归调用

递归：

直接递归-函数自己调用自己

间接递归-函数通过其他函数调用自己。

斐波那契数列

1123581321

intf(intn)

(

if(n>2)returnf(n-1)+f(n-2);

elsereturn1;

)

main()

(

printf("%d\n",f(5));

)

intf(intn)

if(n>1)returnn*f(n-1);

elsereturn1;

)

第12章C语言中用户标识符的作用域和存储类型

12.1局部变量、全局变量和存储分类

12.1.1用户标识符的作用域

局部变量和全局变量重名时，全局变量被屏蔽，局部变量发挥作用。

inta=50;

voidfun()

{

printf("%d\nH,a);

)

main()

{

a++;

{

inta=100;

printf("％d\n”,a);

)

fun();

printf("%d\n",a);

)

12.1.2局部变量、全局变量和存储分类

12.2局部变量及其作用域和生存期

局部变量的生命周期较短，在函数调用完时，局部变量被释放。

register寄存器型register型变量不能进行&运算

auto自动型默认类型不赋初值，初值为随机值不能保留上一次的运行

结果

static静态型不赋初值，初值为0保留上次的运行结果

extern外部型

voidfun()

staticinta=1;

a++;

printf("%d\n",a);

)

main()

fun();2

fun();3

)

inta=100;

voidfun()

(

externinta;

printf("%d\nH,a);

)

main()

(

fun();100

)

12.2.1auto变量

12.2.2register变量

12.2.3静态存储类型的局部变量

12.3全部变量及其作用和生存期

在默认情况下，全局变量的特性类似于static的局部变量

全局的static:此变量不能被外部引用。

extern:引用外部的变量。

Filel.c

staticinta=10;

fun1()

(

printf("%d\nH,a);

}

File2.c

fun2()

(

externinta;

printf("%d\nM,a);

)

12.3.1全局变量的作用域和生存期

12.3.2在同一编译单位内用extern说明符扩展全局变量的作用域

12.3.3在不同编译单位内用extern说明符扩展全局变量的作用域

12.3.4静态全局变量

12.4函数的存储分类

12.4.1用extern说明函数

12.4.2用static说明函数

第13章编译预处理和动态存储分配

13.1编译预处理

13.1.1宏替换

先替换，后计算

#defineN5+5

#defineMN/N

main()

(

printf("%d\n",2*M);16

)

#defineN(x,y)x*y

main()

(

printf("%d\n",N(2+3,2));8

)

13.1.2文件包含

1)预处理命令包括：#define#include。预处理今预先处理，预先是相对于编译，即，

预处理命令在编译前执行。

2)预处理命令后没有"；’号，故不属于C语句。

3)预处理命令#include后可以声明包含任意类型的文件，一般文件扩展名为*.h，但不一

定。

4)当预处理命令中，所包含文件出错时，整个程序需要重新编译。

13.2动态存储分配

13.2.1malloc函数和free函数

int*p;

p=(int*)malloc(sizeof(int));分配int型所占字节数的空间返回空间的地址。

free(p);释放p所指空间的内容。

13.2.2calloc函数

分配n个连续空间。

main()

(

int*p;

p=(int*)calloc(5,sizeof(int));

p[0]=10;

p[1]=p[0]*2;

printf("%d\n",p[1]);20

第14章结构体、共用体和用户定义类型

14.1用typedef说明一种新类型名

用来定义新的类型名

typedef旧类型名新类型名；

typedefint*INT;

14.2结构体类型

多种数据类型的集合。

14.2.1结构体类型的说明

structST定义结构体类型

doublea;

intb;

structSTx;通过结构体类型，定义结构体变量

structST在定义结构体类型的同时，定义结构体变量

double

intb;

)x；

struct定义匿名的结构体类型，同时定义变量。

doublea;

intb;

)X；

typedefstructST结构体类型名

doublea;

intb;

}A;结构体的新类型名

Ax;

14.2.2结构体类型的变量、数组和指针变量的定义

typedefstructST

(

inta,b;

)A；

Ax={1,2};通过新类型名定义结构体变量

A*p;定义结构体指针

p=&x;令指针p指向结构体变量x

当结构体变量为“值”时使用“.”访