C语言知识点总结

C语言知识点总结... 1

一、     常量... 2

二、     标识符... 2

三、     变量... 2

四、     表达式... 3

五、     输入输出函数... 4

六、     C语言的语句... 5

七、     C程序的基本结构... 5

八、     选择结构语句... 5

Ø    if(表达式) 语句1 else 语句2. 5

Ø    条件运算符 表达式1? 表达式2 : 表达式3. 6

Ø    switch语句... 6

九、     循环结构... 6

Ø    for循环语句... 6

Ø    while循环语句 do while循环语句... 6

十、     数组... 7

十一、  字符串函数... 7

十二、  函数... 8

十三、  指针... 9

十四、  宏定义... 10

十五、  结构体，共用体，枚举类型... 10

十六、  Turbo C的使用... 12

一、    常量

Ø  数字常量

              i.              普通数字：1，35，2.7

            ii.              指数形式：2.45e-2等价于2.45*10^-2注意e大小写皆可，e前面的数字不能省，就算是1也不能省，后面的数字一定要是整数

          iii.              长整型，单精度浮点型：3235L，32.5F 分别表示3235是长整型数据，32.5是单精度浮点型左，若不写上L，F则表示3235是整型，32.5是双精度浮点型，L，F大小写皆可

Ø  字符常量

              i.              普通字符常量：用单引号把一个字符括起来，如’A’,’@’

            ii.              转义字符常量：一对单引号括起来并以“\”开头的字符序列，如’\n’(回车)、’\123’(8进制123对应的字符), ’\x23’(16进制23对应的字符)

Ø  字符串常量

用一对双引号把一个字符序列括起来，如“ABCef”， 系统存放字符串常量，每个字符分配一个字节，各字符所占字节紧邻，并且字符串末尾会给再开一个字节里面放一个’\0’做为结束标志。

字符串"\"EOF\n=-\61\""的长度是____。 A) 8  B) 9  C) 14  D) 非法字符串

Ø  符号常量

定义格式 #define 符号常量名 符号常量值，如#define N 20则定义了符号常量N，其值为20，注意符号常量名和符号常量值之间是用空格隔开，而不是写上=号，#define和符号常量名之间也有空格的。

二、    标识符

Ø  命名规则

以数字，字母，下划线这三类字符组成，但只能以字母或下划线开头，而不能也数字开头，另外不能将关键字做为标识符。32个关键字表在P365附录B

Ø  变量名，函数名，符号常量名全都是标识符

三、    变量

Ø  变量的定义格式

类型名 变量名;

如 int  a;定义了一个整型常量a。变量名是由人类随便定义的，符合命名规则的前提下，爱写啥就写啥。所以什么flag，cc，y1或者函数名fun,find等全部是自定的用来做为名字而已，没有更特别的意义。

Ø  类型名

int 整型，long 长整型： 用于存放整数，只是数值范围不同

float 单精度浮点型 double 双精度浮点型：用于存放实数，数值范围，精度不同

char字符型：用于存放字符

Ø  变量赋值，初始化

int  a=3;定义的同时初始化

a=6*9;定义后在程序中进行赋值

Ø  变量的值

只有在赋值操作时才会被改变，即将其放在等号左边时才会改变它的值，或自增自减操作：a=5,a++,a--，像a+3并未改变a的值，只是使用了a的值而已.

Ø  自增自减运算

变量++,++变量，变量--，--变量  使变量的值自增1或自减1

等价于 变量=变量+1  变量=变量-1

++，--放于变量前后效果的区别：

当自增自减运算做为表达式的一部分时，++，--放在变量前面是先自增自减再使用变量的值，放在变量后面则是先使用变量的值，再自增自减。

如x=3; printf(“%d”,++x);则相当于执行了++x; printf(“%d”,x);这样的操作所以打印出4

再如x=3; printf(“%d”,x++);则相当于执行了printf(“%d”,x); x++;这样的操作，则打印出3，当然最后x的值还是4。

     已知 int x=1,y=1,z=1；

    表达式"x+++y+++z++"的值是____。

     A) 3 B) 4 C) 5 D) 表达式错误 first to do

四、    表达式

Ø  运算符和运算对象

一个运算符都有若干个运算对象，如 + 必然要跟两个运算对象才能进行加法运算：3+5。C语言里称需要跟n个运算对象的运算符为n元运算符。

一元运算符有：!，（类型名）

二元运算符有：+,-,*,/,%(求余), =,+=，-=，*=，/=,%=,< , > , <=, >=, = =(等于), !=(不等于)，&&(且) , ||(或)

多元运算符有： ，

Ø  运算符的优先级和结合性

              i.              优先级：同一个运算对象左右两边若同时有两个运算符，则这两个运算符优先级高的先进行运算。

            ii.              结合性：若同一个运算对象左右两边的两个运算符优先级相同，则根据结合性判断先进行哪个运算，自左自右结合性的先算左边的运算符，自右自左的先算右边的运算符。

          iii.              各运算符的优先级和结合性见P365附录C

Ø  强制类型转换

格式： (类型名) 表达式 。将后跟的表达式的值的数据类型转换为与圆括号内的类型名一致的类型。注意类型名一定要用（） 括起来。

Ø  算术表达式

              i.              算术运算符：+,-,*,/,%(求余)

            ii.              由算术运算符加上运算对象构成算术表达式,如3+3*6-9/2

          iii.              值：跟我们小学时学的一样，就是表达式的计算结果

   iv.      整数除以整数结果取整数部分，故1/3得到的值是0

    v.      5%3 结果为2，想想小学除法，求余得到的是余数不是商。

Ø  赋值表达式

              i.              赋值运算符：=，+=，-=，*=，/=,%=

            ii.              赋值表达式：变量=表达式，如x=3+6，x+=6-9，x+=x*=3+4 注意等号左边只能是变量

          iii.              复合赋值运算符的运算：以/=为例：x/=表达式 等价于 x=x/(表达式)

          iv.              值：=号左边的变量最终的值

Ø  关系表达式

              i.              关系运算符：< , > , <=, >=, = =(等于), !=(不等于)

            ii.              由关系运算符加上运算对象构成关系表达式,如3>=4, 2==a

          iii.              值：满足相应运算符所指定的关系的值为1，否则为0

Ø  逻辑表达式

              i.              逻辑运算符：&&(且) , ||(或) , !(非)

            ii.              由逻辑运算符加上运算对象构成逻辑表达式,如3&&4, x||!y

          iii.              值：满足相应运算符所指定的关系的值为1，否则为0

   iv.      进行 ||或 运算时，若||左边的表达式值为1，则不再对右边的表达式进行运算。

    v.      进行 &&且 运算时，若&&左边的表达式值为0，则不再对右边的表达式进行运算。

Ø  逗号表达式

              i.              逗号运算符： ，

            ii.              用逗号将各种表达式连续起来构成逗号表达式，如3+4,a=9,8*a

          iii.              值：组成逗号表达式的各个表达式中的最后一个的值，如上例为8*a

Ø  题目：P7—11~17    P8—18~33

五、    输入输出函数

Ø  scanf(“格式控制串”，变量地址表列);

如scanf(“%d%c%d”,&a,&ch,&b);    scanf(“%4f”,&x);

注意：

              i.              格式控制串可控制截取用户输入的前几个字符给变量，但不能控制输入几位小数给变量，如不能写成scanf(“%4.2f”,&x);

            ii.              第二个参数给的是地址，即要么是&+变量名或数组元素名的形式，要么就是一个数组名或指针变量名，如int *p,a; p=&a; scanf(“%d”,p);

          iii.              考试时注意看题目给你写好的scanf的格式

1.        若其格式控制串内各格式符用“，”隔开如scanf(“%d，%c，%d”,&a,&ch,&b);那输入时也要用逗号隔开，如此例输入时应：3,+,5

2.        若是这种格式scanf(“%d %d”,&a,&b);则输入时应：3 5;

3.        若是这种格式scanf(“%d%c%d”,&a,&ch,&b);则输入时应3+5，若写成3 + 5则a=3,ch=‘ ’(空格)，b=任意值      (自己上机运行看看结果)

Ø  printf(“格式控制串”，输出项表列);

如float x=7.5; printf(“%8.2f”,x);此处的意思是将x打印出来，且占8列，保留两位小数。自己上机运行看看效果。

Ø  常用格式符汇总：

              i.              %d：输入输出整型数据，%ld：输入输出长整型数据

            ii.              %c：输入输出字符型数据

          iii.              %f：输出单（双）精度浮点型数据，输入单精度型数据。            %lf：输入双精度型数据

          iv.              %s：输入输出一个字符串，用printf输出字符串时，输出项书写时可为字符串常量，或字符数组名。如printf(“%s”,”hello”);或char str[10]=”hello”; printf(“%s”,str);

            v.              %u：输入输出无符号整型，%o：输入输出八进制数，            

%x:输入输出十六进制数

Ø  getchar();

函数调用后返回用户输入的一个字符，故需再定义一个变量来存放这个字符，即使用时应 char c; c=getchar()；意思就是接收用户输入的一个字符，并将其赋值给变量c。

Ø  putchar(字符常量或字符变量名)；

如char c=’A’; putchar(c);或putchar(‘A’)；都会向屏幕输出字符A。

六、    C语言的语句

Ø  表达式语句：由表达式末尾加上分号构成。

Ø  函数调用语句：由函数调用表达式加上分号构成。

Ø  空语句： ；

Ø  选择结构语句：if语句 switch语句

Ø  循环语句：for语句 while语句 do while语句

Ø  复合语句：用花括号｛｝将以上任意语句括起来构成一条复合语句。

七、    C程序的基本结构

void main()

{  声明部分：用来定义变量和声明自定义函数的原型，需以“；”结尾，如int x;

   执行语句部分：第六点里介绍的各种语句，如x=3；printf(“%d”,x);

}

main函数外可写自定义函数。如

int max()

{

   return 0;

}

八、    选择结构语句

Ø  if(表达式) 语句1 else 语句2

如果if语句的圆括号内的表达式值为非0，则执行语句1，值为0则执行语句2。

              i.              表达式可为任意表达式，if语句执行的实质是判断表达式的值是否为0来决定执行语句1还是语句2。另外请在此处表达严重关切，不管是高手还是菜鸟经常会把判断两个数相等的符号“==”写成了一个等号“=”成为了赋值运算，这样的写法不会引发编译错误，但结果会与原意大大不同，所以考试前请再三提醒自己。

            ii.              语句1和语句2都只能是一个语句，若要跟多条语句，切记用一对{}括起来，构成复合语句；也不要随便在圆括号后加“；” ，因“ ；”构成一条空语句，这会使后面跟的语句1不再属于if语句的组成部分。

          iii.              if语句的三种结构

1.        单边： if(表达式) 语句

2.        双边：if(表达式) 语句1 else 语句2

3.        多层(重点掌握)：

if(表达式1) 语句1

else if(表达式2) 语句2

else if(表达式3) 语句3

…

else 语句n

Ø  条件运算符 表达式1? 表达式2 : 表达式3

若表达式1的值非0，则取表达式2的值做为整个表达式的值，否则取表达式3的值为整个表达式的值。如 3>4? 1:2  该表达式的值为2

Ø  switch语句

switch(表达式)

{

       case 表达式1：语句

       case 表达式2：语句

       …

case 表达式n：语句

       default: 语句

}

语句执行过程：先计算表达式的值，然后判断该值与表达式1到表达式n中的哪个相等，若与表达式i的值相等，则执行表达式i后的所有语句，当遇到break；语句时结束整个switch语句的执行。表达式1到表达式n的值都不相等的情况下执行default后跟的语句。每个case后可跟多条语句。

九、    循环结构

Ø  for循环语句

for(表达式1；表达式2；表达式3) 循环体语句

语句执行过程：

1.        计算表达式1

2.        判断表达式2的值是否为0，若为0，语句执行结束，若不为0，进入步骤3

3.        执行循环体语句（需注意的是循环体语句只能有一个语句，若要包含多个语句要用一对{}括起来，构成一条复合语句，此处也不要随便加上 “ ; ”，因一个“；”可构成一条空语句，这会使得后面真正的循环体语句不属于for循环语句的部分）。进入步骤4

4.        计算表达式3，然后重新进入步骤2

Ø  while循环语句 do while循环语句

              i.              while(表达式) 循环体语句

执行过程：

1.        判断表达式的值是否为非0，若是进入步骤2，否则结束语句执行。

2.        执行循环体语句，重新回到步骤1。

            ii.              do  循环体语句  while(表达式)；

执行过程：

1.        执行循环体语句，进入步骤2

2.        判断表达式的值是否为非0，若是重新回到步骤1，否则结束语句执行。

这里要注意的地方跟for语句一样，即循环体语句只能有一个语句，若要包含多个语句要用一对{}括起来，构成一条复合语句，此处也不要随便加上 “ ; ”，因一个“；”可构成一条空语句，这会使得后面真正的循环体语句不属于while循环语句的部分，另外do while循环的while(表达式)后是要加“；”的。

Ø  break语句：放在循环体内实现的功能是结束其所在的那层循环的执行。

十、    数组

Ø  定义格式：数据类型   数组名[整型常量]；如 int a[10]; 定义了一个整型数组，数组名为a，这个数组含有10个元素。

Ø  引用数组元素： 格式：数组名[下标]   切记下标值从0开始。下标可为常量，表达式，变量等，如int i=3； a[0]=5；a[3*2]=9； a[i]=7；

Ø  初始化：数据类型   数组名[整型常量]={数据表列}；将数据表列的各个值依次赋值给数组的各个元素。如int a[5]={0,1,2,3,4}；则数组a各元素a[0]到a[4]的值分别为0，1，2，3，4

Ø  遍历数组元素

数组定义后，我们不能对数组进行整体的操作，如int a[10];不能用a=3这样的操作将数组的各元素都赋值为3；而只能一个一个元素的进行赋值，如a[0]=3;a[1]=3;a[2]=3…a[9]=3； 当然此时我们就可以借助于一个for循环来控制下标的变化从而对数组的各个元素进行赋值

for(i=0;i<10;i++) a[i]=3;

当然这只是用for循环遍历数组各元素的最简单的例子，一般考试考的是找出数组元素的某种特性的极值，比如最大值，最小值，或对数组各元素进行排序，这时我们就可以使用for循环来遍历数组的各元素，然后在当前循环中得到一个元素再对其进行处理。如i=2时访问到的元素是a[2]，你就可以问问它，你是不是最小值啊。

Ø  整型数组

int a[10]; 整型数组里的各个元素存放的是整数。a[3]=3;

Ø  字符型数组

char  str[20]；字符型数组里的各个元素存放的是字符。   str[3]=’A’;

十一、     字符串函数

Ø  gets(字符数组名或字符指针变量)；

如char str[10],* str2; str2=str;则gets(str)；或gets(str2)；都是接收用户输入的字符串如“ABC”存入到字符数组str中

Ø  puts(字符数组名或字符指针变量或字符串常量)；

如char str[10]=”china”;    char *str2;str=str2;  则puts(str); 或puts(str2); 或 puts(“china”);都会在屏幕上打印出 china

Ø  strlen(字符数组名或字符指针变量);字符串测长函数

char str[20]=”hello world!”; 

int len;len=strlen(str);得出的结果是len的值为12

Ø  strcat(字符串1的地址，字符串2的地址)；

将字符串2的内容连接到字符串1的尾部。

char str1[20]=”ABC”,str2[20]=”xyz”;

strcat(str1,str2);

则程序运行的结果是str1内存放的字符串变为ABCxyz，当然str2存放的字符串还是xyz。

Ø  strcmp(字符串1的地址，字符串2的地址)；

比较串1和串2哪个比较大。比较大小的依据是，两个字符串从左往右相应位置上第一个不相等的字符ASCII码值之差。

char str1[20]=”ABCE”,str2[20]=”ABDE”;

int i;

i=strcmp (str1,str2);

第一个不相等的字符为str1的‘C’和str2的‘D’，而二者相差-1，故-1做为strcmp函数执行的结果返回到被调用的位置，该位置位于赋值表达式内，故将其值赋值给i，即此时i的值就是-1.

Ø  strcpy(字符串1的地址，字符串2的地址)；

将字符串2的内容复制到字符串1内。

char str1[20]=”ABC”,str2[20]=”xyz”;

strcpy(str1,str2);此时str1的内容为”xyz”，当然str2的内容没变

strcpy(str1,”uvw”);此时str1的内容又变成了“uvw“。

十二、     函数

Ø  函数定义

函数类型  函数名( 形式参数列表 )

 {

        内部变量定义和声明部分

            执行语句

 }

如：

int  max (int  x , int  y )

{  int  z ;

    z= x > y ? x : y ;

    return  ( z ) ;

}

注意点：

1.函数类型是指返回值的类型，即要与return语句后跟的表达式的值的类型一致。若函数类型为void则说明该函数无返回值，即函数体里不能出现return 语句。

2.形式参数列表里定义的变量要记得给它们指定类型，而且如果同时要定义多个，应在每个前面都分别指定类型名，而不能写成int x,y;

3.函数体里能写的语句跟main函数一样，在开头可定义所需要的变量，后面跟上一堆执行语句。

Ø  函数调用流程

以上面的函数为例，在main函数进行调用：

void main()

{ int a,b,c;

  scanf(“%d%d”,&a,&b);

  printf(“%d”,max(a,b));或 c=max(a,b);printf(“%d”,c)以上两种方法都会在屏幕中打印出a，b间的较大值。

调用函数的格式 函数名(实际参数列表)；调用的时候像什么函数类型，形式参数的类型就不要加上去了。max(a,b)中max就是函数名，写上变量名a,b是实际参数列表，执行这个调用语句时，会先把a,b的值给相应位置的形式参数即执行了x=a,y=b这样的操作，然后开始执行max函数的函数体的语句。当max函数体里执行到一个return语句时，则max函数结束执行，将return后的表达式的值返回给main函数调用max函数的那个位置，即若上面a=3,b=5则max(a,b)return后的表达式的值应该是5也就是说执行完max后把5返回到调用max的位置可看成printf(“%d”，5)；或另一种解法的c=5。

}

十三、     指针

Ø  指针变量的声明： 类型名 * 指针变量名；

Ø  通过指针变量访问它所指向的普通变量的值

先将普通变量的地址赋值给指针变量，再通过指针运算符* 得到普通变量的值。

int *p,x,y;

x=3;

p=&x;

则printf(“%d”,*p);会打印出3即x的值

y=*p；则y的值变为3

*p=5；则x的值变为5

Ø  指针变量加上（减去）一个位移的效果

若指针变量存入的是数组元素的地址，则其加一减一得到的是那个数组元素下一个或前一个元素的地址。

int a[10]; p=&a[3];

*p得到的是a[3]的值。

若p++；此时p存放的是a[4]的地址&a[4]; *p得到的就是a[4]的值。

或p--；此时p存放的是a[2]的地址&a[2]，*p得到的就是a[2]的值。

Ø  行指针

              i.              主要是对于二维数组来说的，二维数组每行都有自己的地址，第0行地址用 数组名 表示，第i行地址为 数组名+i；而想要得到二维数组里一个元素的地址，必需先得到其所在行的地址，然后再由那个地址得到元素的地址，比如说 int  a[3][4]；定义了一个二维数组，该二维数组第0行的地址为a，第1行的地址为a+1，第2行的地址为a+2，想从行的地址得到元素的地址，需在行地址前加上指针运算符“*”，即*a就是第0行首个元素的地址即a[0][0]的地址，而a[0][2]的地址就是在a[0][0]的地址基础上加上位移量2，即*a+2，然后想得到a[0][2]这个元素的值呢就再加上一个指针运算符“*”，即*(*a+2)，类似地，想得到a[2][2]这个元素的值呢就是*(*(a+2)+2)

            ii.              定义行指针变量： 类型名  （*变量名）[数组长度]；

如int (*p)[4],a[3][4]; p=a;此时就可把p当成a来用，用法同上所述。

Ø  判断是否合法访问数组元素：若是指针法访问，判断指针后跟的是否地址；若是下标法访问，判断下标有无越界。

Ø  函数指针：函数名即为函数的地址（指针）

              i.              函数指针变量的定义： 类型名 (*变量名) (形参列表);如 int (*p)();

            ii.              赋值：指针变量=函数名；设有个函数其函数名为max,则要将该函数的地址给p的话只要执行如下语句即可 p = max;

Ø  指针数组：指针数组的数组元素都是指针变量，是用来存放变量的地址的，定义格式为 类型名 * 变量名[数组长度]; 如int * p[10];

Ø  指向指针的指针：指针变量也是一种变量，故在内存中也有对应的一个地址，而要存放指针变量的地址，就要求助于用来存放指针变量的地址的指针变量，定义格式  类型名 ** 变量名；如 int *p1; int **p2; int a=3;可进行赋值p1=&a; p2=&p1; 则a 、*p1和 **p2的值都是3.

                     

十四、     宏定义

Ø  无参宏定义 #define  标识符  值   定义后，出现所定义的标识符的地方都将以定义时指定的值来代替。

#define  M  2+3

main()

{  int x;

   x=M*M;  则x的值为2+3*2+3=11若想得到的结果是(2+3)*(2+3)则定义时也写成这样 #define M (2+3)

}

注意#define、标识符、值之间都要用空格隔开，且宏定义结尾不需加分号。

Ø  带参宏定义  #define 标识符(参数表)  值

#define  S(x,y)  x*y

main( )

{  int a=3,b=4,c=5,d=6;

    printf("a*b=%d\n", S(a,b));  此时会打印出 a*b=12

    printf("a+b*c+d=%d\n" , S(a+b,c+d)); 此时会打印出a+b*c+d=29，带参宏定义执行时是将a+b这样一个表达式代替x，c+d这样一个表达式代替y，所以S(a+b,c+d)进行的是a+b*c+d的运算，而不是将a+b的值给x，c+d的值给y然后再做x*y，这点跟函数调用传递参数是不一样的。

}

Ø  自定义类型名typedef：对已存在的类型名取一个外号。

              i.              基本格式：typedef  原类型名  新类型名;

            ii.              typedef  int INTEGER; 则int a,b;等价于INTEGER a,b;

          iii.              typedef  int  NUM[10]; 则 int a[10];等价于 NUM a; a即为一个有10个元素的数组的数组名。

          iv.              typedef int * INTEGER; 则int *a,*b;等价于INTEGER a,b;

十五、     结构体，共用体，枚举类型

Ø  结构体

              i.              结构体类型的定义及变量的定义

struct  结构体名

 {类型 成员1；

  类型 成员2；

  ……

  类型 成员n；

 }变量名;

如

struct student

{  long  num;

char name[10];

int score[4];

}st1;定义类型时同时定义变量

struct student st2;定义类型后，用类型名定义变量

还有一种

struct

{  long num;

char name[10];

int score[4];

}st3;不给类型名，直接定义变量

            ii.              结构体变量所占字节数：各成员各占字节数之和，如以上st1,st2,st3的字节数皆为4+10+2*4=22

          iii.              结构体变量初始化：struct student a={20030001, "张三", 70,75,80,85};

          iv.              结构体数组定义及初始化：

struct student a[3]={{20030001,"zhang",89,90,91,92},

            {20030002,"liu",68,69,70,71},

            {20030003,"li",57,58,59,60} };

            v.              结构体变量成员的访问

1.        结构体变量名. 成员名 如st1.num ①

2.        使用结构体类型的指针：

(*结构体指针名) . 成员   或    结构体指针名–>成员名

struct student *st;  st=&st1;  st->num② 或(*st).num③

Ø  共用体

              i.              共用体类型的定义及变量的定义

union  共用体名

{ 类型  成员名1；

                   …

                   类型  成员名n；

}；

变量的定义与结构体类似，也有三种方法。

union data

{

  int i;

     char ch;

     float f;

}d1; 定义类型时同时定义变量

union data d2; 定义类型后，用类型名定义变量

union

{

  int i;

     char ch;

     float f;

}d3; 不给类型名，直接定义变量

            ii.              共用体变量所占字节数：各成员所占字节数的最大值,如上d1,d2,d3所占字节数皆为4.（单精度浮点型变量所占字节数最多为4）.

          iii.              共用体变量成员的访问

1.        共用体变量名. 成员名 如d1.i

2.        使用共用体类型的指针：

(*共用体指针名) . 成员   或    共用体指针名–>成员名

union data *dd;  dd=&d1;  dd->i 或(*dd).i

          iv.              共用体成员的值：由于共用体各成员共用同一段内存区，故同一时刻只有一个成员的值是正确的。如d1.i=5;d1.ch=’a’;则此时d1.i的值就不是5了，而是其他值了，d1.ch的值是’a’

Ø  枚举类型

              i.              枚举类型的定义：                                                  enum 枚举名{枚举元素名1，枚举元素名2，…，枚举元素名n}；

            ii.              枚举元素的值：
默认值分别为0、1、…、n-1。枚举元素的值也可在定义时重指定，对于没有指定值的元素，按顺序加1

如enum weekday{sun=7,mon=1,tue,wend,thur,fri,sat};则sun值为7，mon值为1，tue值为2，wend值为3，thur值为4，fri值为5，sat值为6

十六、     Turbo C的使用

Ø  菜单激活： F10

Ø  菜单切换：左右方向键在不同菜单间切换，上下方向键在同一个菜单不同选项间切换。

Ø  载入文件：两种方法：1.找到源文件所在位置，直接将其拉到Turbo C快捷方式上；2.  F3

Ø  运行程序： ctrl+F9

Ø  看程序运行结果：alt+F5

Ø  进入编辑状态：菜单Edit

Ø  保存： F2

Ø  插入状态切换： Insert键

《C语言程序设计》精品课件试题

一、单项选择题

导读：单项选择题要求从给出的四个备选答案中，选出一个最符合题意的答案。本类习题主要检查对C语言基本概念的掌握情况，读者可根据学习进度选做部分习题。在完成习题的过程中，不但要选出正确的答案，而且要清楚不正确的选项错在何处，以加深对概念的理解。对于掌握不准的问题，应该通过上机实验来检验。

【1.1】以下不正确的C语言标识符是____。

A) int   B) a_1_2   C) ab1exe    D) _x

【1.2】以下是正确的C语言标识符是____。

A) #define B) _123   C) %d    D) \n

【1.3】下列四组字符串中都可以用作Ｃ语言程序标识符的一组是 。

 A) print  B) i\am     C) Pxq        D) str_l

 _3d      one_half      My->book    Cpp

 oodbs    tart$it        line#         pow

 aBc      3pai         His.age       while

【1.4】下面各选项组中，均是C语言关键字的组是 。

A) auto，enum，include B) switch，typedef，continue

C) signed，union，scanf   D) if，struct，type

【1.5】下列不属于C语言关键字的是 。

A) default  B) register  C) enum  D) external

【1.6】C语言程序从main()函数开始执行，所以这个函数要写在____。

A) 程序文件的开始 B) 程序文件的最后

C) 它所调用的函数的前面    D) 程序文件的任何位置

【1.7】下列关于C语言的叙述错误的是____

A) 大写字母和小写字母的意义相同

B) 不同类型的变量可以在一个表达式中

C) 在赋值表达式中等号(=)左边的变量和右边的值可以是不同类型

D) 同一个运算符号在不同的场合可以有不同的含义

【1.8】在C语言中，错误的int类型的常数是 。

A) 32768   B) 0  C)  037  D) 0xAF

【1.9】执行语句 printf("%x",-1)；屏幕显示____。

A) -1  B) 1  C) -ffff   D) ffff

【1.10】已知 long i=32768；执行语句printf("%d",i)；屏幕显示____。

A) -1  B) -32768  C) 1  D) 32768

【1.11】已知 long i=65539；

执行语句printf("%d",i)；屏幕显示____。

A) 65539  B) -3  C) 3  D) 程序不能执行

【1.12】在Ｃ语言中，整数-8在内存中的存储形式是 。

A) 1111 1111 1111 1000  B) 1000 0000 0000 1000

C) 0000 0000 0000 1000  D) 1111 1111 1111 0111

【1.13】Ｃ语言中字符型(char)数据在内存中的存储形式是____。

　 　 A) 原码 B) 补码 C) 反码  D) ASCII码

【1.14】将字符g赋给字符变量c，正确的表达式是 。

A) c=\147  B) c="\147"  C) c='\147'  D) c='0147'

【1.15】下列转义字符中错误的一个是____。

A) '\000'  B) '\0014'  C) '\x111'  D) '\2'

【1.16】将空格符赋给字符变量c，正确的赋值语句是____。

A) c='\0' B) c=NULL C) c=0  D) c=32

【1.17】已知：char a='\70'；则变量a中 。

A) 包含1个字符 B) 包含2个字符 C) 包含3个字符 D) 说明非法

【1.18】字符串"\"EOF\n=-\61\""的长度是____。

A) 8  B) 9  C) 14  D) 非法字符串

【1.19】字符串""的长度是____。

A) 0  B) 1  C) 2  D) 非法字符串

【1.20】已知：char a；int b；float c；double d；

执行语句"c=a+b+c+d；"后，变量c的数据类型是 。

A) int  B) char  C) float  D) double

【1.21】温度华氏和摄氏的关系是: C=-(F-32)。已知：float C,F；由华氏求摄氏的正确的赋值表达式是____。

A) C=5/9(F-32)  B) C=5*(F-32)/9

C) C=5/9*(F-32)  D) 三个表达式都正确

【1.22】逗号表达式"(a=3*5, a*4), a+15"的值是____。

A) 15  B) 60  C) 30  D) 不确定

【1.23】如果int a=1,b=2,c=3,d=4；则条件表达式"a<b?a:c<d?c:d"的值是____。

A) 1 B) 2 C) 3 D) 4

【1.24】为求出s=10!的值，则变量s的类型应当为 。

A) int  B) unsiged  C) long  D) 以上三种类型均可

【1.25】已知int i=10；表达式"20-0<=i<=9"的值是____。

A) 0 B) 1 C) 19 D) 20

【1.26】已知int x=1,y；执行下述语句后变量x的值是____。

y=++x>5&&++x<10；A) 1 B) 2 C) 3 D) 4

【1.28】已知 int a[3][2]={3,2,1}；

则表达式"a[0][0]/a[0][1]/a[0][2]"的值是____。

A) 0.166667 B) 1 C) 0 D) 错误的表达式

【1.29】已知 int x=1,y=1,z=1；

表达式"x+++y+++z++"的值是____。

A) 3 B) 4 C) 5 D) 表达式错误 first to do

【1.36】已知int x=5,y=5,z=5；执行语句x%=y+z；

后，x的值是____。

A) 0 B) 1 C) 5  D) 6

【1.37】使用语句scanf("x=%f,y=%f",&x,&y)；

输入变量x、y的值（□代表空格），正确的输入是____。

A) 1.25,2.4 B) 1.25□2.4 C) x=1.25,y=2.4 D) x=1.25□y=2.4

【1.38】下列循环语句中有语法错误的是____。

A) while(x=y) 5； B) while(0) ；

C) do 2；while(x==b)； D) do x++ while(x==10)；

【1.39】已知int x=(1,2,3,4)；变量x的值是____。

A) 1 B) 2 C) 3 D) 4

【1.40】表达式sizeof(double)是 。

A) 函数调用 B) double型表达式 C) int型表达式 D) 非法表达式

【1.42】已知：int x，y；double z；

则以下语句中错误的函数调用是 。

A) scanf ("%d,%lx,%le",&x,&y,&z)；

 B) scanf ("%2d*%d%lf",&x,&y,&z)；

C) scanf ("%x%*d%o",&x,&y)；

D) scanf ("%x%o%6.2f",&x,&y,&z)；

【1.43】与条件表达式"(n)?(c++):(c--)"中的表达式（n）等价的表达式是____。

A) (n==0) B) (n==1) C) (n!=0) D) (n!=1)

【1.44】已知int i=1,j=0；执行下面语句后j的值是____。

while(i)

switch(i)

{ case 1: i+=1；j++；break；

case 2: i+=2；j++；break；

case j3: i+=3；++；break；

default: i--；j++；break；

}

A) 1 B) 2 C) 3 D) 死循环

【1.45】求取满足式 1²+2²+3²+ …… +n² ≤1000的n，

正确的语句是____。

A) for(i=1,s=0；(s=s+i*i)<=1000；n=i++) ；

B) for(i=1,s=0；(s=s+i*i)<=1000；n=++i) ；

C) for(i=1,s=0；(s=s+i*++i)<=1000；n=i) ；

D) for(i=1,s=0；(s=s+i*i++)<=1000；n=i) ；

【1.46】下面的for语句 。

for(x=0,y=10；(y>0)&&(x<4)；x++,y-- ) ；

A) 是无限循环 B) 循环次数不定

C) 循环执行4次 D) 循环执行3次

【1.47】已知int i=1； 执行语句while (i++<4) ；

后，变量i的值为____。

A) 3 B) 4 C) 5 D) 6

【1.48】已知int x=12,y=3；执行下述程序后，

变量x的值是____。

do

{ x/=y--；

}while(x>y)；

A) 1 B) 2 C) 3 D) 程序运行有错误

【1.50】若用数组名作为函数调用时的实参，则实际上传递给形参的是 。

A) 数组首地址 B) 数组的第一个元素值

C) 数组中全部元素的值 D) 数组元素的个数

【1.51】对二维数组的正确说明是____。

A) int a[][]={1,2,3,4,5,6}； B) int a[2][]={1,2,3,4,5,6}；

C) int a[][3]={1,2,3,4,5,6}； D) int a[2,3]={1,2,3,4,5,6}；

【1.52】对字符数组s赋值,不合法的一个是____。

A) char s[]="Beijing"；

B) char s[20]={"beijing"}；

C) char s[20]；s="Beijing"；

D) char s[20]={'B','e','i','j','i','n','g'}；

【1.53】对字符数组str赋初值，

str不能作为字符串使用的一个是____。

A) char str[]="shanghai"；

B) char str[]={"shanghai"}；

C) char str[9]={'s','h','a','n','g','h','a','i'}；

D) char str[8]={ 's','h','a','n','g','h','a','i'}；

【1.54】对函数形参的说明有错误的是____。

A) int a(float x[],int n) B) int a(float *x,int n)

C) int a(float x[10],int n) D) int a(float x,int n)

【1.55】如果一个变量在整个程序运行期间都存在，但是仅在说明它的函数内是可见的，这个变量的存储类型应该被说明为____。

A) 静态变量 B) 动态变量 C) 外部变量 D) 内部变量

【1.56】在一个C源程序文件中,若要定义一个只允许在该源文件中所有函数使用的变量，则该变量需要使用的存储类别是 。

A) extern B) register C) auto D) static

【1.57】在C语言中，函数的数据类型是指____。

A) 函数返回值的数据类型 B) 函数形参的数据类型

C) 调用该函数时的实参的数据类型 D) 任意指定的数据类型

【1.58】已知如下定义的函数：

fun1(a)

{ printf("\n%d",a)；

}

则该函数的数据类型是____。

A) 与参数a的类型相同 B) void型

C) 没有返回值 D) 无法确定

【1.59】定义一个函数实现交换x和y的值，并将结果正确返回。能够实现此功能的是____。

A) swapa(int x,int y)  B) swapb(int *x,int *y)

{ int temp； { int temp；

temp=x；x=y；y=temp； temp=x；x=y；y=temp；

} }

C) swapc(int *x,int *y)  D) swapd(int *x,int *y)

{ int temp； { int *temp；

temp=*x；*x=*y；*y=temp； temp=x；x=y；y=temp；

} }

【1.61】一个函数内有数据类型说明语句如下：

double x,y,z(10)；

关于此语句的解释，下面说法正确的是____。

A) z是一个数组，它有10个元素。

B) z是一个函数，小括号内的10是它的实参的值。

C) z是一个变量，小括号内的10是它的初值。

D) 语句中有错误。

【1.62】已知函数定义如下：

float fun1(int x,int y)

{ float z；

z=(float)x/y；

return(z)；

}

主调函数中有int a=1,b=0；可以正确调用此函数的语句是____。

A) printf("%f",fun1(a,b))； B) printf("%f",fun1(&a,&b))；

C) printf("%f",fun1(*a,*b))； D) 调用时发生错误

【1.65】已知：int a, *y=&a；则下列函数调用中错误的是 。

A) scanf("%d", &a)； B) scanf("%d", y)；

C) printf("%d", a)； D) printf("%d", y)；

【1.66】说明语句"int (*p)( )；"的含义是 。

A)  p是一个指向一维数组的指针变量

B)  p是指针变量，指向一个整型数据

C)   p是一个指向函数的指针，该函数的返回值是一个整型

D)  以上都不对

【1.67】设有说明int (*p)[4]；其中的标识符p是 。

A) 4个指向整型变量的指针变量

B) 指向4个整型变量的函数指针

C)   一个指向具有4个整型元素的一维数组的指针

D) 具有4个指向整型变量的指针元素的一维指针数组

【1.68】已知：char s[10], *p=s，则在下列语句中，错误的语句是 。

A) p=s+5； B) s=p+s； C) s[2]=p[4]； D) *p=s[0]；

【1.69】已知：char s[100]；int i；则引用数组元素的错误的形式是 。

A) s[i+10] B) *(s+i) C) *(i+s)  D) *((s++)+i)

【1.70】已知：char s[6], *ps=s；则正确的赋值语句是 。

　 A) s="12345"； B) *s="12345"；  C) ps="12345"； D) *ps="12345"；

【1.73】已知：int a[ ]={1,2,3,4,5,6,7,8,9,10,11,12}，*p=a；则值为3的表达式是 。

A)  p+=2,*(p++) B) p+=2,*++p C) p+=2,*p++ D) p+=2,++*p

【1.74】已知：int a[]={1,2,3,4}, y, *p=a；则执行语句y = (*++p)--；之后, 数组a各元素的值变为______。

A) 0,1,3,4  B)  1,1,3,4  C) 1,2,2,4 D) 1,2,3,3

变量y的值是____。

A) 1  B)  2  C) 3 D) 4

【1.76】已知：int x[ ]={ 1,3,5,7,9,11 }，*ptr=x；则能够正确引用数组元素的语句是 。

A) x  B) *(ptr--) C) x[6]  D) *(--ptr)

【1.78】有定义如下：

struct sk

{ int a；

float b；

}data ,*p；

如果 p=&data；则对于结构变量data的成员a的正确引用是____。

A)（*）.data.a  B) (*p).a  C) p->data.a  D) p.data.a

【1.81】已知：

struct

{ int i；

char c；

float a；

}test；

则sizeof(test)的值是 。

A) 4  B) 5  C) 6  D) 7

【1.82】已知：

union

{ int i；

char c；

float a；

}test；

则sizeof(test)的值是 。

A) 4 B) 5 C) 6 D) 7

【1.85】若有以下说明语句，则对结构变量pup中sex域的正确引用是 。

struct pupil

{ char name[20]；

int sex；

}pup,*p；

p=&pup；

A) p.pup.sex B) p->pup.sex C) (*p).pup.sex D) (*p).sex

【1.86】以下对结构变量stul中成员age的非法引用是 。

struct student

{ int age；

int num；

}stu1,*p；

p=&stu1；

A) stu1.age  B) student.age C) p->age D) (*p).age

【1.87】若有以下定义和语句：

union data

{ int i；

char c；

float f；

}a；

int n；

则以下语句正确的是         。A) a=5;B) a={2,'a',1.2}; C) printf("%d\n",a);D) n=a；

【1.93】Ｃ语言中标准输入文件stdin是指 。

　　　 A) 键盘 B) 显示器 C) 鼠标 D) 硬盘

【1.94】要打开一个已存在的非空文件"file"用于修改，选择正确的语句＿＿＿＿。

A) fp=fopen("file", "r")； B) fp=fopen("file", "a+")；

C) fp=fopen("file", "w");  D) fp=fopen('file", "r+")；

【1.95】当顺利执行了文件关闭操作时，fclose函数的返回值是 。

A) -1  B)  TRUE  C) 0  D) 1

【1.96】fscanf函数的正确调用形式是 。

A) fscanf (文件指针, 格式字符串, 输出列表)；

B) fscanf (格式字符串, 输出列表, 文件指针)；

C) fscanf (格式字符串, 文件指针, 输出列表)；

D) fscanf (文件指针, 格式字符串, 输入列表)；

【1.97】使用fgetc函数，则打开文件的方式必须是 。

A) 只写 B) 追加 C) 读或读/写  D) 参考答案B和C都正确

【1.98】已知宏定义

#define N 3

#define Y(n) ((N+1)*n)

执行语句z=2*(N+Y(5+1))；后，变量z的值是____。

A) 42  B) 48  C) 52  D) 出错

========================================================

【单项选择题参考答案】

【1.1】答案: A

注释：int是C语言的关键字

【1.2】答案: B

【1.3】答案：A

【1.4】答案：B

注释：include是预处理命令；scanf是函数名；type不是C语言的关键字。

【1.5】答案：D

【1.6】答案：D

【1.7】答案：A

【1.8】答案：A

注释：int型表示整数的范围是-32768～32767。

【1.9】答案：D

注释：整型常量-1在计算机中表示为补码1111 1111 1111 1111，用十六进制显示这个数时，最左边的1不会被解释为符号位，而是与右边其它位共同转换为十六进制数。

【1.10】答案：B

注释：长整型数32768在计算机内的表示是1000 0000 0000 0000，以一般整型进行输出时，此数恰是-32768的补码。

【1.11】答案：C

注释：长整型数65539在计算机内的表示是0001 0000 0000 0000 0011，以一般整型进行输出时，仅将右侧16位二进制数转换为十进制数。

【1.12】答案：A

注释：C语言中，int型的负数是采用补码表示的。

【1.13】答案：D

【1.14】答案：C

注释：变量c是字符型，可用字符常量为它赋值。字符常量必须用单引号括起来，所以B是错误的；在单引号或双引号内的反斜线'\'用于表示转义字符，A选项在无引号时使用反斜线是错误的；C选项单引号内出现反斜线表示它与后面的数字组成一个转义字符；单引号只允许括起一个字符，D选项在单引号内出现4个字符，是错误的。

【1.15】答案：C

【1.16】答案：D

注释：空字符和空格符是不同的两个字符，空格符的ASCII码值是32，空字符的ASCII值是0。

【1.17】答案：A

【1.18】答案：B

【1.19】答案：A

【1.20】答案：C

【1.21】答案：B

注释：单纯从C语言语法来说，选项B、C都是正确的，但是选项C中第一个运算的两个对象都是整型常数，其结果也是整型数0,最后的运算结果也就是0了。

【1.22】答案：C

【1.23】答案：A

注释：将条件表达式增加一个括号，此式变为a<b?a:(c<d?c:d)，它的运算顺序就清楚了。由于条件运算符的结合性是从右向左，所以括号可以省略。它的运算顺序是先算出右边的条件表达式"c<d?c:d"的值，然后求条件表达式a<b?a:3的值。

【1.24】答案：C

【1.25】答案：B

【1.26】答案：B

注释：当通过一个运算对象即可决定逻辑运算&&的结果时，则对另一个运算对象不做处理。

【1.27】答案：D

【1.28】答案：B

注释：数组元素在内存中按行排列，此数组的前3个元素的值分别是3、2、1，表达式中虽然数组下标的写法似乎每行有3个元素，和定义时的3行2列不一致，但是C语言引用数组元素时是根据数组的首地址和给出的下标进行运算决定元素的地址。题中表达式引用了数组前3个元素。

【1.29】答案: A

【1.30】答案：D

【1.31】答案：B

【1.32】答案：B

【1.33】答案：B

【1.34】答案：A

【1.35】答案：C

【1.36】答案：C

【1.37】答案：C

【1.38】答案：D

【1.39】答案：D

【1.40】答案：C

1.41】答案：D

注释：scanf函数返回值是输入数据的个数，printf函数的返回值是输出的字符个数。

【1.42】答案：D

【1.43】答案：C

注释：在C语言中， 经常用一个变量来作为逻辑表达式，其含义就是：当变量的值不为0时关系成立。

【1.44】答案：D

注释：break语句仅可跳出switch语句，不会跳出while循环，这是一个死循环。

【1.45】答案：A

【1.46】答案：C

【1.47】答案：C

【1.48】答案：D

注释：当除数y为0时，程序发生溢出错误。

【1.49】答案：C

【1.50】答案：A

【1.51】答案：C

【1.52】答案：C

注释：答案C的赋值号左侧是数组s的首地址，是一个常量，赋值号右侧是一个字符串常量，不可能将一个字符串常量赋给一个地址常量。

【1.53】答案：D

注释：D选项缺少字符串结束标志。

【1.54】答案：C

注释：此处函数形参是一个指针变量，接受实参的地址，而不是一个数组。

【1.55】答案：A

【1.56】答案：D

注释：这里首先要明确一些基本概念。在C语言中，程序与文件是不同的概念，一个程序可以由一个文件组成，也可以由多个文件组成；一个文件中又可以包含多个函数；函数是构成C程序的基本单位。

变量的作用域因变量的存储类型不同而不同。auto和register类型的变量的作用域是说明变量的当前函数；外部变量的作用域是整个程序，即外部变量的作用域可以跨越多个文件；内部静态变量（定义在一个函数内部的static型的变量）的作用域是当前函数，外部静态变量（定义在函数外面的static型的变量）的作用域是当前文件，即可以跨越同一文件中的不同函数。

【1.57】答案：A

【1.58】答案：A

注释：它和参数a一样，数据类型说明被省略，按照C语言的规定，在这种情况下，表示它们是int型。

【1.59】答案：C

注释：函数swapa是值传递，函数的执行结果不能返回；函数swapb中变量temp不是指针变量，所以它不能接受地址量，用指针变量x为它赋值是不对的；函数swap中虽然指针变量交换了地址，即它们的指向的目标变量进行了交换，但是目标变量并没有行值的交换。

【1.60】答案：B

【1.61】答案：D

【1.62】答案：D

注释：主调函数中b=0，在执行fun1函数里的除法时发生溢出错误。

【1.63】答案：B

【1.64】答案：C

【1.65】答案：D

注释：在答案D中，正确的函数调用应当是：printf("%d", *y)。

【1.66】答案：C

注释：要注意与说明语句"int (*p)[ ]；"的区别。说明语句"int (*p)[ ]；"说明的是一个指向数组的指针。

【1.67】答案：C

注释：题干中由于*和p被小括号括起，所以p应被解释为一个指针，而后的下标运算符[]说明所指向的对象是一个有4个int型元素的一维数组；如果是int (*p)(),则是指向函数的指针。对于int *p[4],则根据运算符的优先级，先考虑p和[]运算符的关系，所以它就是一个指针数组了。

【1.68】答案：B

注释：选项B有两处错误，一是数组名是常量，不能出现的赋值好的左侧，二是指针变量只能和整数做加，不能和作为地址常量的数组名相加。

【1.69】答案：D

注释：s作为数组名是地址常量，而s++是s=s+1，C语言不允许对常量进行赋值。

【1.70】答案：C

【1.71】答案：C

注释：a是二维数组名，a+1中的1不是1个字节，而是数组的"一行"，即10个字节，所以a+1是第二个字符串的首地址，A选项正确。在C编译系统中对二维数组名可这样理解(注意，这里仅是理解)：a指向一个一维数组，故(a+1)是指向a[1]的，*(a+1)就是取a[1]的值，它保存第二个字符串"ShangHai"的首地址，所以选项B也正确。*a是第一个字符串的首地址，加1是第一个字符串中第二个字符的地址，选项C的输出是"beiJing"。选项D中的&a[1][0]是对第二个字符串的第一个字符做取地址运算，得到该地址就是字符串"ShangHai"的首地址。注意，对于二维数组来说，做一次*或[]运算的结果仍是地址量，做两次才是取数值。

【1.72】答案：A

注释：p是一个一级指针，选项B中对它进行了两次*运算是错误的。ptr是一个指向一维数组的指针，它所指向的数组有三个元素，对于这样一个指针，对它进行两次**运算才能取出地址单元中所存的数据，C选项中*ptr表示数组第一行的首地址，该地址是一维数组的地址，+3表示加上三个它所指向的数据类型的长度，所以(*ptr+1)+2是数组中数值4的地址。根据以上分析，选项D对ptr进行了两次地址操作（*和[]），所以结果应是数据，但是它加1后指向数组第二行，根据后面[]中2它的地址增加两个一维数组的长度，就指向数组的最后一行，再做*运算就是数10，即a[3][0]。

【1.73】答案：A

【1.74】答案：B B

【1.75】答案：D

【1.76】答案：B

【1.77】答案：D

注释：答案D是另一种交换两个变量值的算法。

【1.78】答案：B

【1.79】答案：C

注释：使用C对p进行赋值，则p->next是a[0]的地址，引用其成员n再做前增1运算，结果就是2。

【1.80】答案：B

【1.81】答案：D

【1.82】答案：A

【1.83】答案：C

注释：联合变量temp的成员是占用同一存储单元，它的长度是4个字节。266的二进制表示是100001010，存放在存储单元的低端两个字节，如下图：

高字节

0 0 0 0 0 0 0 1

低字节 0 0 0 0 1 0 1 0

引用temp.ch进行输出，只取最低的第一个字节。

【1.84】答案：D

注释：由于结构指针指向了结构数组的0号元素，所以表达式(p++)->m的含义是先取出m（变量a的地址），然后指针p加1。表达式*(p++)->m的含义是先取出m的内容（变量a的值），然后指针p再加1。表达式(*p).m的含义是取出m（变量a的地址）。表达式*(++p)->m的含义是先将指针p加1，然后再取m的内容（变量b的值）。

【1.85】答案：D

【1.86】答案：B

【1.87】答案：C

【1.88】答案：A

【1.89】答案：D

【1.90】答案：D

【1.91】答案：A

【1.92】答案：B

【1.93】答案：A

【1.94】答案：D

注释：函数fopen中的第二参数是打开模式，"r"模式是只读方式，不能写文件；"a+"模式是读/追加方式，允许从文件中读出数据，但所有写入的数据均自动加在文件的末尾；"w"模式是写方式，允许按照用户的要求将数据写入文件的指定位置，但打开文件后，首先要将文件的内容清空。"r+"模式是读/写方式，不但允许读文件，而且允许按照用户的要求将数据写入文件的指定位置，且在打开文件后，不会将文件的内容清空。本题的要求是"修改"文件的内容，因此只能选择答案D。

【1.95】答案：C

【1.96】答案：D

【1.97】答案：C

【1.98】答案：B

注释：语句z=2*(N+Y(5+1)引用了两个宏定义。C语言是区分字母大小的，第二个宏定义中的N直接用3替换，用5+1替换n，则有z=2*(3+(3+1)*5+1)；结果是48。注意对于带参数的宏亦是直接的文本替换，此例中n用5+1去替换，结果是（N+1）*5+1，而不是(N+1)*(5+1)。

【1.99】答案：C

注释：宏替换后的结果是printf("%d",10/3*3)。

【1.100】答案：C

二、 阅读程序题

导读：学会阅读程序对于初学者来说很重要，一方面可以巩固所学的语法知识，另一方面通过阅读别人写好的程序来打开自己的思路，就所谓见多识广。读者通过阅读理解程序，从给出的四个备选参考答案中，选择程序的正确输出。如果选择有误，就要认真分析原因，是概念方面的错误还是对程序逻辑理解不对，从而加深对语法规则的理解，提高程序设计能力。程序设计语言是开发程序的一个工具，学习语言的目的是为了编写程序来解决实际问题，所以特别提倡通过实际上机来检验备选答案，增强动手能力。习题基本上是按照教材的章节来安排的，读者可以根据学习的进度选择部分习题。

【2.1】以下程序的输出结果是 。 main( )

{ float a；

a=1/100000000；

printf("%g"，a)；

}

A) 0.00000e+00 B) 0.0  C) 1.00000e-07  D) 0

【2.2】下面程序的输出结果是____。

#include <stdio.h>

　　main( )

{ int x=10；

     {

        int x=20；

        printf ("%d，", x)；

      }

     printf("%d\n", x)；

}

A) 10，20  B) 20，10  C) 10，10 D) 20，20

【2.4】以下程序的输出结果是 。 main( )

{ int x=10, y=10； printf("%d %d\n", x――, ――y)；

}

A) 10 10  B) 9 9  C) 9 10  D) 10 9

【2.5】以下程序的输出结果是____。

main()

{ int n=1；

printf("%d %d %d\n",n, n++, n--)；

}

A) 1 1 1  B) 1 0 1;  C) 1 1 0  D) 1 2 1

【2.7】以下程序的输出结果是____。

main()

{ int a=1；

char c='a'；

float f=2.0；

printf("%d\n",(!(a==0),f!=0&&c=='A'))；/*last , function volue*/

}

A) 0 B) 1

【2.10】下面程序的输出结果是____。

main()

{ char s[12]= "a book"；

printf("%.4s",s)；   /*%m.ns 法： m输出长度，n输出个数*/

}

A) a book! B) a book!<四个空格》

C) a bo D) 格式描述错误，输出不确定

【2.11】下面程序的输出结果是____。

main()

{ int a,b；

scanf("%2d%3d",&a,&b)；

printf("a=%d b=%d\n",a,b)；

}

A) a=12 b=34 B) a=123 b=45  C) a=12 b=345  D) 语句右错误

【2.12】以下程序段的输出结果是 。 int a=10,b=50,c=30；

if(a>b)

a=b；

b=c；

c=a；

printf("a=%d b=%d c=%d\n",a,b,c)；

A) a=10 b=50 c=10 B) a=10 b=30 c=10

C) a=50 b=30 c=10 D) a=50 b=30 c=50

【2.13】以下程序的输出结果是 。

 main()

{ int a=0,b=1,c=0,d=20；

if(a) d=d-10；

else if(!b)

if(!c) d=15；

else d=25；

printf("d=%d\n",d)；

}

A)  d=10 B) d=15 C) d=20 D) d=25

【2.14】下面程序的输出结果为 。

main()

{ int a=1,b=0；

 switch(a)

  { case 1: switch (b)

     { case 0: printf("**0**")； break；

      case 1: printf("**1**")； break；

      }

    case 2: printf("**2**")； break；

  }

}

A) **0** B) **0****2** C) **0****1****2** D) 有语法错误

【2.28】下面程序的输出结果是____。

int m[3][3]={ {1}, {2}, {3} }；

int n[3][3]={ 1, 2, 3 }；

main( )

{ printf("%d\n", m[1][0]+n[0][0] )； /* ① */

printf("%d\n", m[0][1]+n[1][0] )； /* ② */

}

① A) 0 B) 1 C) 2 D) 3

② A) 0 B) 1 C) 2 D) 3

【2.29】下面程序的输出结果是____。

#include <stdio.h>

main( )

{ char s1[50]={"some string *"},s2[]={"test"}；

printf("%s\n", strcat(s1,s2))；

}

A) some string * B) test

C) some stritest D) some string *test

【2.30】下面程序的输出结果是____。

#include <stdio.h>

f(char *s)

{ char *p=s；

while(*p!='\0')

p++；

return(p-s)；

}

main()

{ printf("%d\n",f("ABCDEF"))；

}

A) 3  B) 6 C) 8 D) 0

【2.31】下面程序的输出结果是____。

#include <stdio.h>

#include <string.h>

main( )

{ char str[100] ="How do you do"；

strcpy( str + strlen(str)/2, "es she")；

printf("%s\n", str)；

}

A) How do you do B) es she C) How are you  D) How does she

【2.32】下面程序的输出结果是____。

#include <stdio.h>

func(int a,int b)

{ int c；

c=a+b；

return(c)；

}

main()

{ int x=6,y=7,z=8,r；

r=func((x--,y++,x+y),z--)；

printf("%d\n",r)；

}

A) 11 B) 20  C) 21 D) 31

【2.39】下面程序的输出结果是____。

main()

{ int a=2,i；

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

printf("%4d",f(a))；

}

f(int a)

{ int b=0；

static int c=3；

b++；

c++；

return(a+b+c)；

}

A) 7 7 7 B) 7 10 13 C) 7 9 11  D) 7 8 9

【2.42】下面程序的输出结果是____。

#include <stdio.h>

#define SUB(X,Y) (X)*Y

main()

{ int a=3,b=4；

printf("%d\n",SUB(a++,b++))；

}

A)  12 B) 15 C) 16 D) 20

【2.46】下面程序的输出结果是____。

#include <stdio.h>

main ( )

{ int a[]={1, 2, 3, 4, 5} ；

int x, y, *p；

p=&a[0]；

x=*(p+2)；

y=*(p+4)；

printf("%d,%d,%d\n", *p, x, y)；

}

A)  1,3,5 B) 1,2,3 C) 1,2,4 D) 1,4,5

【2.51】下面程序的输出结果是____。

#include <stdio.h>

main( )

{ int a=1,*p,**pp；

pp=&p；

p=&a；

a++；

printf ("%d,%d,%d\n", a,*p, **pp)；

}

A) 2,1,1 B) 2,1,2  C) 2,2,2 D) 程序有错误

【2.57】下面程序的输出结果是____。

#include <stdio.h>

main()

{ union

 {

   int i[2]；

   long k；

   char c[4]；

}r,*s=&r；

s->i[0]=0x39；

s->i[1]=0x38；

printf("%c\n",s->c[0])；

}

A) 39 B) 9 C) 38 D) 8

【2.58】下面程序的输出是 。

main ( )

{ printf("%d\n", EOF)；

}

A)  -1 B) 0 C) 1  D) 程序是错误的

　　　　　　　　　　　　　　　　　　　　　【阅读程序题参考答案】

【2.1】参考答案：D

注释：程序中除法运算的两个操作数均是整型，运算结果也是整型。

【2.2】参考答案：B

注释：C语言允许在程序块(分程序)中说明变量。

【2.3】参考答案：C

注释：变量i中的负号传送给变量n后，因n是无符号数，已不作为负号处理。

【2.4】参考答案：D

注释：对变量x的――操作是后缀形式，变量x的减1操作要在执行完 printf函数之后才进行，所以变量x的值在输出的时候仍然保持原值10。

【2.5】参考答案：B

注释：C语言在执行printf()时，对函数中的表达式表列的处理顺序是从后向前，即先处理n- -，再处理n++，最后处理n，而且每一个表达式作为一个处理单元，也就是说在不同的表达式中自增自减运算是单独考虑的。

【2.6】参考答案：A

注释：变量x和变量y做按位与，结果为0x0200，右移4位为0x0020，再与0x005f做按位或，最后结果为0x007f。

【2.7】参考答案：A

注释：逗号表达式的结果是用逗号分开的最后一个表达式的值，此题由于 c=='A'的值是0,所以逗号表达式的值为0。

【2.8】参考答案: B

【2.9】参考答案: A

【2.10】参考答案: C

注释：在输出格式描述"%m.ns"中，m是输出总长度，n是实际字符的个数，这里m没有给出，则输出总长度就是实际输出字符的个数。

【2.11】参考答案: C

【2.12】参考答案：B

【2.13】参考答案：C

【2.14】参考答案：B

【2.15】参考答案：D

【2.16】参考答案：A

【2.17】参考答案: C

【2.18】参考答案：A

【2.19】参考答案: C

注释：在switch语句中，case本身仅起到语句标号的作用，不会改变语句的流程，执行break语句才能退出当前的switch语句。

【2.20】参考答案: D

注释：siwtch语句的表达式中，变量c是后缀的增一运算，第一次执行do-while循环时，执行case 'A'后面的语句。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

【2.21】参考答案: D

【2.22】参考答案: B

【2.23】参考答案: B

注释：fabs()是浮点数绝对值函数。

【2.24】参考答案: A

【2.25】参考答案: C

注释：C语言允许在程序块（分程序）内说明变量，如果在程序块内说明的变量和程序块外的变量同名，在块外说明的变量在块内是不可见的。可将此题和【2.11】进行比较，加深理解。

【2.26】参考答案: C

【2.27】参考答案: B

【2.28】参考答案： ① D ② A

【2.29】参考答案：D

【2.30】参考答案: B

注释：输出结果为字符串长度。

【2.31】参考答案: D

注释：字符串拷贝函数strcpy()要求的两个参数都是字符串首地址。本题中第二个参数是字符串常量，接受这个字符串的第一个参量不是直接给出字符数组名，而是进行了地址运算后的结果。由于str字符串的长度是13，除2取整后是6，第一个参数给出的地址是字符数组str的首地址加6，也就是原来字符串中第二个空格的位置，把"es she"从该处放入，字符串str变为"How does she"。

【2.32】参考答案: C

注释：main函数调用func函数时，第一个实参使用的是逗号表达式的值，也就是x+y的结果。由于对变量x、y、z进行的是后缀运算，所以函数func的参数值是13和8。

【2.33】参考答案: C

【2.34】参考答案: ① C ② A ③ C

【2.35】参考答案: C

【2.36】参考答案: B

注释：函数fun进行了递归调用，实际进行的运算是5×4×3×2×1×3×10。主函数内说明的局部变量w屏蔽了外部变量w，所以在主函数中外部变量w是不可见的，在调用printf函数时表达式"fun(5)*w"中w的值是10。

【2.37】参考答案: D

注释：main函数三次调用了函数funa，在funa函数中的静态变量c仅在第一次调用时进行了初始化，再次调用时不再对静态变量赋初值。

【2.38】参考答案: B

注释：main函数和num函数中都说明了变量a和b，由于它们是内部变量，所以它们分别在说明它们的函数内有效。外部变量x和y在函数num之后被说明，而在num函数中又要引用它们，所以在num函数中用关键字"extern"说明变量x和y是一个外部变量，也就是通知计算机这两个变量在fun函数以外被说明，此处不是定义两个int型变量。

【2.39】参考答案: D

注释：函数f中的变量c是静态变量，仅在第一次调用函数f时它被初始化为3,第二次调用函数f时c的值是4，第三次调用函数f时c的值是5。

【2.40】参考答案: D

　　　　　　　　　　　　　　　【2.41】参考答案: D

注释：程序中有三个"x"分别在三个不同的函数中，这三个"x"都是自动变量，所以三个"x"分别局部于三不同的函数，在三个函数中对"x"的操作互不影响。

【2.42】参考答案: A

【2.43】参考答案: A

注释：*(++p)和*++p都是指针变量值前加1，第一次指向a[1]，第二次指向a[2]；a+3是a[3]的地址。

【2.44】参考答案: C

注释：②句没有语法错误，但是a+6指向数组之外，因为a是a[0]的地址，a+1是a[1]的地址，a+2是a[2]的地址，显然数组a没有a[6]分量。③句错误，因为a[1]是地址常量，它是a[1][0]的地址，对于地址常量是不可以进行赋值运算的。

【2.45】参考答案: ① D ② A

注释：如果FMT定义为"%x\n"，则输出的16进制数据用小写字母表示。

【2.46】参考答案: A

注释：语句"p=&a[0]"表示将数组a中元素a[0]的地址赋给指针变量p，则p就是指向数组首元素a[0]的指针变量，"&a[0]"是取数组首元素的地址。对于指向数组首址的指针，p+i（或a+i）是数组元素a[i]的地址，*(p+i)(或*(a+i))就是a[i]的值。

【2.47】参考答案: B

【2.48】参考答案: D

【2.49】参考答案: D

【2.50】参考答案: A

注释：变量g是指向函数的指针，(*g)(a,b)是调用指针g所指向的函数。

【2.51】参考答案: C

注释：p是指针，pp是指向指针的指针。

【2.52】参考答案: A

注释：对于指向数组的指针变量可以做下标运算，p[i]和alpha[i]都是指向字符串的首地址，*p[i]取出字符串的第一个字符。

【2.53】参考答案: ① D ② A ③ D ④ D ⑤ B

注释：pp是一个二维指针数组，pp+1指向数组的第二维，*(pp+1)是第二维的起始地址，**(pp+1)是第二维第一个元素的地址，***(pp+1)是第二维第一个元素的内容，所以，①的参考答案应选D。*(pp+1)+1是第二维第二个元素的地址，*(*(pp+1)+1)是第二维第二个元素，(*(*(pp+1)+1))[4]则是第二维第二个元素所指字符串下标为4的元素，即是字符w，故③应当选D。

【2.54】参考答案: ① B ② C

【2.55】参考答案:D

【2.56】参考答案:C

注释：联合体成员的取值是最后一次给成员赋的值。

【2.57】参考答案: B

注释：整型数组i和字符数组c共用存储空间，给i赋值也等于给c赋值，所以s->c[0]=0x39，所以输出9。

【2.58】参考答案：A

注释：基本概念。EOF是由C语言在头文件stdio.h中定义的，用户可以直接使用。

【3.1】下面程序的功能是将从终端上读入的10个整数以二进制方式写入名为"bi.dat"的新文件中。

#include <stdio.h>

FILE *fp；

main()

{ int i, j；

if(( fp=fopen( ① , "wb" )) == NULL )

exit (0)；

for( i=0；i<10；i++ )

{ scanf("%d", &j )；

fwrite( ② , sizeof(int), 1, ③ )；

}

fclose( fp)；

}

【3.2】输入3个学生3门课的成绩，分别函数实现下列功能：

1）计算每个学生平均分；

2）计算每门课的平均分；

3）找出所有9个分数中做高的分数所对应的学生和课程；

4）计算平均分方差

           

其中为某个学生的平均分。

【3.3】将n个数按输入时顺序的逆顺序排列，用函数实现。