文章目录：

第一部分：各章节类 

第1、2章(概述、顺序、选择、循环结构)练习题【58题】

一、选择题【23题】

温馨提示！ 

温馨提示！

温馨提示！

 温馨提示！

  温馨提示！

   温馨提示！

二、 判断下列描述的正确性，对者划√，错者划╳【11题】

三、写出下列程序的运行结果【10题】

  温馨提示！

 温馨提示！ 

 温馨提示！ 

 温馨提示！ 

 温馨提示！  

四、完成程序【7题】

  温馨提示！ 

五、程序设计题【7题】

   温馨提示！ 

答案

第3-4章(数组、指针)练习题【40题】

一：选择题【16题】

温馨提示！ 

温馨提示！

温馨提示！

 温馨提示！

二、读程序【15题】

三：填空题【4题】

四：编程题目【5题】

答案 

第5-7章(函数)练习题【32题】

一：选择题【10题】

二：写出程序运行结果【16题】

三：程序填空【6题】

答案

 第8-12章：预处理、结构体、共用体、位运算及文件操作

一：学习的了解的

二：练题

三：提升

第二部分：C语言概念题解答选编【200题】

 一：单项选择题【100题】

二：填充题【100题】

文本题库下载地址 

单元一：C语言概述与数据结构 单元二：顺序结构程序设计 单元三：选择结构程序设计 单元四：循环结构程序设计 单元五：数组函数指针 单元六：编译预处理 单元七：结构体共用体 单元八：位运算 单元九：文件 单元十：程序设计题

第1-2章：概述、顺序、选择、循环结构 第3-4章：数组、指针 第5-7章：函数                  位运算、预处理、结构体、共用体                   文件

这里没有后面的我自己加上：

第8-12章：预处理、结构体、共用体、位运算及文件操作

1.下列运算符中（C）结合性从左到右。

A. 三目 B. 赋值 C. 比较 D. 单目

2.下列for循环的次数为（B）：for ( i=0，x=0；! x && i=y)&(y>=z)

21. 若c为char类型变量，能正确判断出c为小写字母的表达式是（D）

A) 'a'{1,2},{1,2,3},{1,2,3,4}};

3. 以下对一维数组a正确初始化的是：C

（A）int a[10]=(0,0,0,0,); （B）int a[10]={};

（C）int a[10]={0}; （D）int a[10]=(10*2);

4.以下选项中，不能正确赋值的是： A（A） char s1[10];s1="Ctest"; （B） char s2[]={'C', 't', 'e', 's', 't'};

（C） char s3[20]="Ctest"; （D） char *s4="Ctest\n"

5.若有说明：int i, j=2，*p=&i;，则能完成i=j赋值功能的语句是： B（A） i=*p; （B） *p=*&j; （C） i=&j; （D） i=**p;

6. 下面各语句行中,不能正确进行字符串操作的语句行是：D(A) char st[10]={"abcde"};      (B) char s[5]={'a','b','c','d','e'};(C) char *s; s="abcde";         (D) char *s; scanf("%s",s);

7.设有如下的程序段,执行上面的程序段后，*(ptr+5)的值为:B

(A) 'o' (B) '\0' (C)不确定的值 (D) 'o'的地址

8. 请选出以下语句的输出结果A  

  (A)5         (B)14      (C)8        (D)输出项不合法，无正常输出

9.以下程序段给数组所有的元素输入数据，请选择正确答案填入。A

   ① 3  ② 0  ③ 9  ④ -12

【解】由于赋值运算符的结合性自右至左，语句“a + = a - = a*a；”的执行是先计算a*a，得到值9，再计算a - = a*a，使a 的值为-6，接着计算a += a，使a 的值为-12。所以解答是④。

   ① {0, 1}, {2, 4}, {5, 8}}, (*p)[4] = w;

   ① *w[1]+1  ② p++, *(p+1)  ③ w[2][2]  ④ p[1][1]

【解】两维数组定义有多种赋初值的办法，问题给出的代码是按行给数组的部分元素赋初值。它们分别是w[0][0] = 0、w[0][1]=1、w[1][0]=2、w[1][1] = 4、w[2][0]=5、w[2][1]=8。根据约定，未指定初值的元素自动置全0值。指针变量p是一个指向具有四个int型元素的一维数组的指针，定义时的初值使它指向数组w的第一行。①的代码，*w[1]+1中的w[1]是指向w[1][0]的指针，*w[1]就是w[1][0]，其值是2，*w[1]+1的值是3。②的代码是逗号表达式，“p++，*(p+1)”先使p指向数组w的第二行，*(p+1)中的p+1是指向数组w的第三行，*(p+1)是指针值，指向数组w的第三行的第一个元素，即&w[2][0]。③的代码w[2][2]引用数组w第三行的第三列元素，其值是0。④的代码p[1][1]引用数组w第二行的第二列元素w[1][1]，其值是4。所以解答是④。

int a[12] = {0}, *p[3], **pp, i;

for(i = 0; i < 3; i++) p[i] = &a[i+4];

pp = p;

   ① pp[0][1]  ② a[10]  ③ p[3][1]  ④ *(*(p+2)+2)

【解】上述代码定义变量a是有12个整型元素的数组，它的初值全是0。p是有3个元素的指针数组，每个指针能指向整型变量。pp是指针的指针，它能指向一个指向整型变量的指针，i是一个整型变量。执行代码for(i = 0; i < 3; i++) p[i] = &a[i*4]使指针数组p的元素p[0]指向a[4]，p[1]指向a[5]，p[2]指向a[6]。代码pp = p使指针变量pp指向p[0]。①，代码pp[0][1]用指针表达可等价地写成*(*pp+1)。其中*pp就是p[0]，p[0]的值是&a[4]，*pp+1的值是&a[4]+1 = &a[5]，*(*pp+1)就是a[5]。②，代码a[10]当然是引用数组a的元素。③，代码p[3][1]因数组p只有三个元素，没有p[3]，所以是错误的。④，代码*(*(p+2)+2)中的(p+2)是&p[2]，*(p+2)是p[2]，其值是&a[6]，*(p+2)+2的值是&a[8]，*(*(p+2)+2)引用的是a[8]。所以解答是③。

int **pp, *p, a = 10, b = 20;

pp = &p; p = &a; p = &b; printf(“%d, %d\n”, *p, **pp);

   ① 10, 20  ② 10, 10  ③ 20, 10  ④ 20, 20

【解】上述代码定义变量pp是指针的指针，它能指向一个指向整型变量的指针。定义变量p是指针，它能指向一个整型变量。a是一个整型变量，它有初值10。b也是一个整型变量，它有初值20。代码pp=&p使pp指向p，p = &a使p指向a，p = &b又使p指向b，不再指向a。所以*p是引用b，其值为20。**pp是通过pp间接引用p，再通过p间接引用b，所以也是20。所以解答是④。

int w[2][3], (*pw)[3]; pw = w;

   ① *(w[0]+2)  ② *pw[2]  ③ pw[0][0]  ④ *(pw[1]+2)

【解】上述代码定义2行3列的两维数组w，定义能指向有三个整型元素一维数组的指针pw，并让pw指向数组w的第一行。①，代码*(w[0]+2)中的w[0]是&w[0][0]，w[0]+2是&w[0][2]，所以，*(w[0]+2)就是w[0][2]。②，代码*pw[2]中的pw[2]是&w[2][0]，该数组w只有2行，没有w[2][0]，所以代码*pw[2]是对数组w元素的非法引用。③，代码pw[0][0]就是w[0][0]。④，代码*(pw[1]+2) 中的pw[1]就是*(pw+1)，即&w[1][0]，pw[1]+2就是&w[1][2]，所以，*(pw[1]+2)就是w[1][2]。所以解答是②。

72．函数调用语句“f((e1, e2), (e3, e4, e5))；”中参数的个数是○。

    ①  1   ②  2   ③  4   ④  5  

【解】上述函数调用中，(e1, e2)和(e3, e4, e5)是两个带括号的表达式，所以函数调用只提供两个实参，其中第一个实参先计算e1的值，然后计算e2，并以e2的值为实参。第二个实参顺序计算e3，e4，e5，并以e5的值为实参。所以解答是②。

73．C语言中，函数的隐含存储类型是○。

    ①  auto   ②  static   ③  extern   ④  无存储类别  

【解】由于C函数内不能再定义函数，C函数的存储类型只能是静态的或外部的之一。若定义函数时不指定存储类型是静态的，则它的存储类型就是外部的（extern），即函数允许被程序的其它函数调用。所以解答是③。

74．以下对C语言函数的有关描述中，正确的是○。

④  C程序中，有调用关系的所有函数必须放在同一个源程序文件中  

【解】C语言规定，调用函数时，只能把实参的值传递给函数的形参。函数调用时，形参从实参表达式得到初值，形参也是函数的一种局部变量，其值可以改变，但形参的值不能传回给对应的实参。当函数设置非指针类型的形参时，实参可以是同类型的一般表达式；当函数设置指针类型的形参时，对应的实参也必须是同类型的指针表达式。所以叙述①是正确的。C函数虽可以递归调用，但同时规定，在函数内不能再定义函数，所以叙述②是错误的。通常C函数会有返回值，但也可以没有返回值，有许多情况，函数的执行是完成某种预定的工作，并没有返回值，所以叙述③是不正确的。在C程序中，如函数未指定是静态的，则就是外部的，能让别的文件中的函数调用，但函数要调用别的文件中的函数，在调用代码之前，需对它作说明，所以叙述④也是不正确的。正确的解答只有①。

75．设函数的功能是交换x和y的值，且通过正确调用返回交换结果。不能正确执行此功能的函数是○。

{ int *p;

  *p = *x; *x = *y; *y = *p;

}

    ②  funb(int x, int y)

{ int t;

  t = x; x = y; y = t;

}

③  func(int *x, int *y)

{ int p;

  p = *x; *x = *y; *y = p;

}

④  fund(int *x, int *y)

{ int *p;

  *x = *x + *y; *y = *x - *y; *x = *x - *y;

}

【解】设计实现交换两个变量值的函数。希望函数调用能改变调用环境中的变量，方法之一是让函数设置指针类型的形参，实参传送给形参的是希望交换值的两个变量的指针。函数的两个形参得到这两个变量的指针后，函数就能通过形参间接引用要交换值的变量，或引用它们的值，或改变它们的值。从而实现从函数传回信息存于调用环境的变量中。以上所述是设计交换变量值函数的一般原则，具体编写函数时还需注意对上述原则的正确应用。

    对于函数funa，该函数的定义满足设置指针形参，并通过指针形参间接引用环境变量的要求。但是在函数体中定义了指针变量p，并在p未明确设定它所指向的变量下，代码*p = *x企图将值存入它所指的变量中，这是初学者经常出现的一种严重的错误。该函数因有错，不能实现交换变量值的功能。

    对于函数funb，该函数不定义指针形参，函数体也没有可用的指针间接引用调用环境中的变量，所以该函数也不能实现交换变量值的功能。

    对于函数func，该函数正确定义了指针形参，函数体也正确通过指针形参间接引用环境中的变量，并正确定义了自已的局部变量。该函数能实现交换变量值的功能。

对于函数fund，该函数也正确定义指针形参和函数体通过形参间接引用环境变量。特别要指出的是，该函数是利用*x和*y的旧值与新值之间的关系实现问题要求的。其中第一个赋值使*x存有原来未交换之前的*x与*y之和；第二个赋值从这个和中减去原来的*y，并将差赋给*y，使*y的值是交换之前的*x的值；第三个赋值再次从和中减去新的*y，即减去交换之前的*x，这个差就是交换之前的*y，并将差赋给*x。经以上三个赋值，实现两变量之间的值交换。所以不能正确执行交换变量值的函数是funa和funb，即正确选择是①和②。

①  funa(int *a, int n, int x)

{ *a = x;

  while(a[n] != x) n--;

  return n;

}

    ②  funb(int *a, int n, int x)

{ int k;

  for(k = 1; k 0。在a[0]处放入x后，这个条件就不必要了，循环至少在访问了a[0]后终止，并返回0值。所以该函数能完成指定的功能。函数funb采用常规的办法编写，循环在a[1]与a[n]之间顺序寻找，一旦找到立即返回找到处的下标，直至查找循环结束，查不到指定的值时，返回0值。函数func采用与函数funa相同的方法，不过是另引入一个指针变量。但是该函数return语句后的表达式有严重的错误，应返回k-a，两指针的差是一个整数，在这里是找到元素的下标。表达式k-n是指针k向前移n个位置的指针值。函数fund预置k为0，循环让k增1，并在k在界内和a[k]不等于x的情况下继续循环。循环结束有两种情况，或k已不在界内，或k在界内，并且a[k]等于x。若是后者，函数返回k，而若前者，函数返回0。该函数也能正确完成查找工作。这样，不能正确完成查找工作的函数是函数func。所以正确的选择是③。

#include  

sub1(char a, char b){  char c; c = a; a = b; b = c;}

sub2(char *a, char b){  char c; c = *a; *a = b; b = c;}

sub3(char *a, char *b){  char c; c = *a; *a = *b; *b = c;}

main()

{  char a, b;

   a = ‘A’; b = ‘B’; sub3(&a, &b); putchar(a); putchar(b);

   a = ‘A’; b = ‘B’; sub2(&a, b);  putchar(a); putchar(b);

   a = ‘A’; b = ‘B’; sub1(a, b);   putchar(a); putchar(b);

}

    ①  BABBAB   ②  ABBBBA   ③  BABABA   ④  BAABBA  

【解】在上述程序中，函数sub1完成两形参值的交换，与实参提供的变量无关，这是一个没有意义的函数。函数sub2将第二个形参的值置入由第一个指针形参所指的变量中，指针形参所指的变量由调用时的实参提供。函数sub3完成将两个形参所指的变量的值交换的工作。程序调用sub3，使变量a和b的值交换输出BA；调用sub2，使变量b的值传送到a，输出BB；调用sub1，变量a和b的值不改变，输出AB。所以程序输出BABBAB。正确解答是①。

   ③ 一个指向具有10个元素的一维数组的指针

   ④ 具有10个指针元素的一维数组

【解】代码“int (*ptr)[10];”的分析过程是，因圆括号，括号内的ptr先与字符*结合，字符*修饰标识符ptr，使它是一种指针；接着与后面的一对方括号结合，表示是这样一种指针，是指向一维数组的；再有方括号中的10，说明这种数组有10个元素。至此，ptr是指向含10个元素的一维数组的指针。最后，是最前面的int，表示数组元素是int类型的。所以，ptr是一个指向具有10个int型元素的一维数组的指针。所以解答是③。另外，要是①，10个指向整型变量的指针，就是一个指针数组，上述代码应写成“int *ptr[10];”，即ptr是一个有10个指向整型变量的数组。 要是②，返回值是指向10个整型变量的函数的指针，上述代码应写成“int  (*(*ptr)())[10];”，即ptr是指针，指向一种函数，函数的返回值又是一种指针，指向10个元素的数组，数组的元素是整型的。下面的代码是这样的函数指针和函数的例子：

#include

int a[][10] = {{1,2,3,4,5,6,7,8,9,0},{0,1,2,3,4,5,6,7,8,9}};

int  (*(*ptr)(int))[10];

int (*f(int n))[10]

{ return a+n;

}

void main()

{  int (*p)[10], *q;

   ptr = f;  /* 让ptr指向函数f */

   p = ptr(0);   q = *p;   printf("%d\n", *q);

   p = ptr(1);   q = *p;   printf("%d\n", *q);

}

在上述代码中，函数有一个int型的形参。要是④，其意义与①相同，上述代码应写成“int *ptr[10];” ，即ptr是一个有10个元素的数组，数组元素是指向整型变量的指针。

79．计算平方数时，不可能引起二义性的宏定义是

① #define SQR(x) x*x         ② #define SQR(x) (x)*(x)

③ #define SQR(x) (x*x)       ④ #define SQR(x) ((x)*(x))

【解】宏调用是字符列的替换，一个宏调用被替换后，替换后的字符序列就与它前后的字符列一起构成新的源程序。常有这样的情况，因宏定义对宏参数的独立性注意不够，替换后的字符列会与其前后字符列结合，产生意想不多的结果；另外，因宏调用本身独立性注意不够，宏展开的内容会被分裂，部分内容会与其前或后的其它部分先结合。如一个宏定义有可能发生上述情况，它就是一个有可能引起二义性的宏定义。对于①，若希望描述计算u+v的平方，用宏调用SQR(u+v)，产生的代码将是u+v*u+v。这是因宏定义对参数的独立性注意不够，产生不是希望的展开代码。对于②，若希望描述计算1.0/x2，用宏调用1.0/SQR(x)，产生的代码将是1.0/(x)*(x)，这是因宏调用本身独立性注意不够而引起的。对于③，与①的情况一样，宏调用SQR(u+v)，不能正确描述u+v的平方。对于④，在宏定义中，给参数x加上括号能保证参数的独立性，定义给全部内容也加上括号，这也保证了整个宏调用的独立性。所以，④是计算平方数时，不可能引起二义性的宏定义。所以解答为④。

80．执行下列程序

#define  M(a, b)  (a) > (b)?(a):(b)

main()

{  int i = 10, j = 15; printf(“%d\n”, 10*M(i, j)); }

后输出的结果是 

  ① 10    ② 15     ③ 100     ④ 150

【解】上述程序输出表达式10*M(i, j)的值，该表达式中有宏调用，宏展开后的表达式为

     10 *（i）> (j) ? (i) : (j)

该表达式是一个条件表达式，它的求值顺序如下：先求10 *（i）>(j)，因变量i和j的值分别为10和15，10*10大于15，结果为1。因条件表达式中的条件子表达式为1，以表达式(i)的结果为条件表达式的值。(i)的值是10，条件表达式的结果亦为10。最后，程序输出10。所以解答为①。

81．设有定义语句“struct { int x; int y; } d[2] = {{1, 3}, {2, 7}};”，则

printf(“%d\n”, d[0].y/d[0].x*d[1].x);

的输出是○。

    ①  0   ②  1   ③  3   ④  6  

【解】结构数组d有两个结构元素，每个结构又由两个整型成分组成，初始化后，d[0].x = 1,d[0].y = 3, d[1].x = 2。所以表达式d[0].y /d[0].x*d[1].x的值是6。所以正确解答是④。

82．设有定义语句“enum term { my, your = 4, his, her = his+10};”，则

printf(“%d, %d, %d, %d\n”, my, your, his, her);

的输出是○。

① 0, 1, 2, 3   ② 0, 4, 0, 10   ③ 0, 4, 5, 15   ④ 1, 4, 5, 15  

【解】按枚举类型定义的规定，枚举类型team的枚举常量对应的整数分别是my=0、your=4、his=5、her=15。所以语句输出0，4，5，15。解答是③。

83．若有如下定义，则printf(“%d\n”, sizeof(them));的输出是○。

typedef union {long x[2]; int y[4]; char z[8]; } MYTYPE;

MYTYPE them;

    ①  32   ②  16   ③  8  ④  24  

【解】共用型变量的成分是覆盖存储，为共用型变量分配存储时，以其中需要最多存储字节的成分进行分配。设long型数据占4个字节、int型数据占2个字节。共用型MYTYPE有三个成分，第一个成分是有两个long型元素的数组，它需要8个字节；第二个成分是有4个int型元素的数组，它也需要8个字节；第三个成分是有8个字符元素的数组，也是8个字节。所以MYTYPE类型的共用型变量只需要8个字节。正确解答是③。

struct person {char name[9]; int age; };  

struct person c[10]={{“John”, 17},

                     {“Paul”,19},{“Mary”,18},{“Adam”,16}};

【解】结构类型struct person有两个成分：九个元素的字符数组name和一个基本整型age。元素类型为struct person的数组c有10个元素，其中前四个元素被设定了初值。在已设定初值的元素中，只有c[2].mane[0]的值是字符M。其余元素及元素的成分都不是字符M。解答是④。

struct sk {int a; float b; } data, *p = &data;

    ① (*p).data.a   ②  (*p).a   ③  p->data.a   ④  p.data.a  

【解】结构变量data有两个成分a和b。结构指针变量p指向结构变量data。引用结构变量data的成分a有两种方法：一是直接由变量data引用其自己的成分a，写成data.a。二是通过指针变量p引用它所指的结构的成分a。这又有两种写法，分别是p->a和（*p）.a。解答是②。

struct s {char *name; int no; } pp;

     scanf(“%s”, buf);

     pp.name = (char *)malloc(strlen(buf)+1);

     strcpy(pp.name, buf);

   }  

【解】字符串最终存于某个字符数组中，而不是存于字符指针中。字符指针只是指向存放这个字符串的字符数组的首字符位置。通常对于结构变量中包含字符指针的情况，要为它输入字符串，得先输入到一个较大的字符数组中暂存，然后按输入字符串的长度向系统申请存储字符串的空间，并让结构的字符指针指向这个动态空间，最后将暂存于字符数组中的字符串拷贝到这个动态空间。所以解答是④。

89．设typedef union { long x[2]; short y[4][5]; char z[10];} TYPE1;

TYPE1 u1;

则printf(“%d\n”, sizeof(u1)); 的输出是

① 8    ② 10    ③ 40     ④ 58

【解】上述代码定义共用型TYPE1，并定义TYPE1类型的变量u1。共用型如同结构型一样，可以有多个不同类型的成员，但共用型变量成员的内存分配方法与结构变量成员的内存分配方法不同。结构变量的成员顺序分配内存，各成员独立占用内存。一般来说，结构变量所占用的内存字节总数是它的各成员所占内存字节数之和；共用型变量的成员重叠占用内存，共用型变量占用的字节数由其中需要最多字节数的那个成员确定。计算具体变量实际将占用多少字节，依赖于各种基本数据类型所需字节数。以一个long型数据占用4个字节、short型数据占用2个字节、char型数据占用1个字节为标准计算。对于共用型TYPE1来说，成员x需8个字节，成员y需40个字节，成员z需10个字节。这样共用型变量u1就需40个字节。输出共用型变量u1占用的字节数应是40。所以解答为③。

92．以只写方式打开一个二进制文件，应选择的使用方式是

①”a+”    ②”w+”     ③”rb”     ④”wb”

【解】程序使用文件可以有多种不同方式。在C系统中，使用方式的不同由文件打开方式指定。首先是文件信息的存储形式，有以内存表示形式存储的二进制文件、和以字符形式存储的文本文件。要特别指定为二进制形式存储，在打开方式中要有字符b。其次是文件的读写方式。其中只读一个已存在的文件，在打开方式中用字符r；若只写建立一个新文件，或只写重建一个文件，在打开方式中用字符w。向已存在的文件只写追加信息，在打开方式中用字符a。若有读有写方式使用文件，在打开方式中有字符+。特别地，对已存在文件的有读有写，用双字符r+；在文件尾部追加信息的有读有写，用双字符a+；新建，或重建文件的有读有写，用双字符w+。由以上说明知，以只写方式打开一个二进制文件，在打开方式中有字符b和有字符w。所以解答为④。

93．若文件型指针fp已指向某文件的末尾,则函数feof(fp)的返回值是

    ①  0   ②  -1   ③  非零值   ④  NULL  

【解】当调用fopen函数时，系统将为实参文件设定一个存放文件读写控制信息的控制块。该控制块记录有关文件持征、使用方式，当前读写位置等文件状态，并将该控制块的指针返回，作为文件指针变量的值。以后程序通过该指针调用函数时，系统能访问到这个控制块，利用该文件控制块中的控制信息，正确完成文件的读或写。所以文件指针并不真正指向文件当前读写位置，但通过文件指针，系统能在文件控制块中访问文件的当前读写位置。若某文件与文件指针fp相关联着，该文件的当前读写位置在文件的末尾时，函数调用feof(fp)的返回值是一个非零值。所以正确解答是③。

    ①  FILE c;  ②  FILE *c;   ③  file c;   ④  file *c;  

【解】如上题所述，文件控制块的类型已由系统命名为FILE。所以定义文件指针变量是c，就得用代码：“FILE *c；”。所以正确解答是②。

④ 从p2指向的内存中的一个字符串输出到p1指向的文件  

【解】标准函数调用fputs(p1, p2)完成的功能是将由字符指针p1所指的字符串内容输出到与文件指针p2相关联的文件中，即将从p1所指的内存中的字符串内容复制存入到p2所指向的文件中。所以正确解答是③。

99．以下程序中的for循环执行的次数是

   #include  

   #define  N  2

   #define  M  N+1

   #define  NUM  (M+1)*M/2

   main()

   {  int i, n = 0;

      for(i = 1; i x = 1; printf(“####x = %d\n”, x); }

else { y = 2; printf(“****y = %d\n”, y);}

24．设i，j，k均为int型变量，则执行完下面的for语句后，k的值为▁▁▁▁。

   for(i = 0, j = 10; i