C语言题库含答案.docx

C语言题库含答案.docx

《C语言题库含答案.docx》由会员分享，可在线阅读，更多相关《C语言题库含答案.docx（48页珍藏版）》请在冰豆网上搜索。

C语言题库含答案

一、简答题。

（共14题,共0分,每题0分）

1. int i=10, j=10, k=3; k*=i+j; k最后的值是?

答：

k=60

ok

2. 写出程序结果:

void Func（char str[100]）

{                                          

  printf（"%d\n", sizeof（str））;

}

答：

4或者8（如果操作系统为32位则为4,64位则为8）

是地址吗

3. 写出sizeof（structname2）的结果

structname2{

charstr;

intnum;

shortx;

}

不会！

看结构

答：

此题考察结构对齐的知识，结果为12

4. 写出sizeof（structname1） 的结果

structname1{

charstr;

shortx;

intnum;

}

不会！

答：

同样考察的是结构对齐的知识，结果为8

5. A.c 和B.c两个c文件中使用了两个相同名字的static变量,编译的时候会不会有问题?

这两个static变量会保存到哪里（栈还是堆或者其他的）?

答：

没有问题，static变量只在当前文件中有效，也就是说static变量的作用域属于所在的文件域。

static变量保存在全局/静态区

6. （void*）ptr 和 （*（void**））ptr的结果是否相同？

答：

相同。

首先第一个（void*）ptr将ptr转换为空指针类型（一级指针），（*（void**））ptr相当于先将ptr转换为空类型指针（二级指针）。

二级指针是指向指针的指针，在前面加上*（解指针），也就是空类型指针了（一级指针）。

7. #defineDOUBLE（x）x+x ，i=5*DOUBLE（5）； i 是多少？

答:

i=5*5+5=30;看书上的结构理解下意思

8. 下面的声明都是什么意思？

constinta;

intconsta;

constint*a;

int*consta;

intconst*consta;

答：

第一个定义常量a，第二个也是定义常量a，第三个定义常量指针a，第四个定义指针常量a，第五个定义指向常量的指针常量（相当于const引用）。

9. 关键字const是什么含意？

答：

1.const修饰基本类型，比如int类型为常量。

2.const修饰指针分为两种情况：

指针常量或者常量指针。

3.const修饰类的成员函数，则在此函数中无法修改类中数据成员的值。

？

？

？

4.const修饰返回值意味着返回值不可被改变

5.const修饰函数参数，意味着函数参数不能被有意或者无意修改。

10. do……while和while……do有什么区别？

答：

do…while先执行循环再判断条件，while…do先进行判断再执行循环。

11.语句for（；1；）有什么问题？

它是什么意思？

他的意思是循环条件永远为真，不停地进行循环操作，除非循环体中有强制退出循环的语句才能终止循环，其实功能就相当于while

（1）

答：

无限循环

12.如何引用一个已经定义过的全局变量？

答：

题目说的有点不太清楚，如果是引用其它文件中定义的全局变量用extern，如果是在本文件中引用的话用作用域运算符:

:

是在c++中的

13.switch（）结构中条件表达式的类型可以是什么类型？

答：

整型，字符型，常量，枚举类型

14..h头文件中的ifndef/define/endif的作用？

答：

预编译命令，一般是用来防止头文件多重包含结构？

二、问答题。

（共63题,共0分,每题0分）

1.关键字static的作用是什么？

第一：

隐藏。

static全局变量只在本文件中可访问，其它文件无法访问。

第二：

持久保存变量的内容。

static变量一经初始化便到程序运行结束后才

会被释放。

第三：

默认初始化为0.static变量会被编译器默认初始化为0

2.inta[3];

a[0]=0;a[1]=1;a[2]=2;

int*p,*q;

p=a;

q=&a[2];

则a[q-p]=a[2]

这段程序执行完之后数组中元素的值分别是什么？

q-p=2

答：

0，1，2

3.根据a的值，完成b的初始化，并将b的值返回

intfunc（floata）

{

intb;

switch（a）

{

case1:

30;

break;

case2:

20;

case3:

16;

default:

0

}

returnb;

}

此程序段有什么错误，如果有请指出

答：

1.switch只能用整型或者字符型或者枚举类型，float类型不正确。

2.case后面没有加break

4. 写出程序运行结果

intsum（inta）

{

autointc=0;

staticintb=3;

c+=1;

b+=2;

return（a+b+c）;

}

voidmain（）

{

intI;

inta=2;

for（I=0;I<5;I++）

{

printf（"%d,",sum（a））;

}

}

答：

8，10，12，14，16

5. 写出输出结果

voidg（int**）;

intmain（）

{

intline[10],i;

int*p=line;

for（i=0;i<10;i++）

{

*p=i;

g（&p）;

}

for（i=0;i<10;i++）

printf（"%d\n",line[i]）;

return0;

}

voidg（int**p）

{

（**p）++;

（*p）++;

}

答：

12345678910

6. 写出输出结果

intmain（）

{

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

int*ptr=（int*）（&a+1）;//解释解释1

printf（"%d,%d",*（a+1）,*（ptr-1））;

}

答：

2，5

7.写出下面的结果

charstr1[]="abc";

charstr2[]="abc";

constcharstr3[]="abc";

constcharstr4[]="abc";

constchar*str5="abc";

constchar*str6="abc";

char*str7="abc";

char*str8="abc";

printf（“%d”,str1==str2）;//数组名就是

printf（“%d”,str3==str4）;

printf（“%d”,str5==str6）;

printf（“%d”,str7==str8）;

答：

0011

8. 以下3个有什么区别


char*constp;

charconst*p；

constchar*p；

答：

第一个是指针常量，第二个是常量指针，第三个也是常量指针

9.unsignedshortarray[]={1,2,3,4,5,6,7};

inti=3;

*（array+i）=?

答：

4

10. i最后等于多少?

int i = 1;

int j = i++;

if（（i>j++） && （i++ == j）） i+=j;

答：

5

11. 写一个“标准”宏

1>输入两个参数，输出较小的一个

2>表明1年中有多少秒（忽略闰年问题）

答：

此题的考察点是防止数据太大int类型表示不了，现在不用担心（int占4个字节）

1.#defineMin（a,b）（（a）<=（b）?

（a）:

（b））

2.#defineSECONDS_PER_YEAR（60*60*24*365UL

考察内容：

1）.#define语法的基本知识（例如：

不能以分号结束，括号的使用，等等）

2）.意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。

3）.如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。

12. 什么是预编译,何时需要预编译?

答：

预编译又称为预处理，主要做一些文本的替换工作。

比如#include包含文件代码，#define宏定义的替换，条件编译等等。

预编译代码有助于在开发周期中缩短编译时间，特别是在以下的情况中：

1.总是使用不经常改动的大型代码体

2.程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。

在这种情况下可以将所有包含文件编译为一个预编译头。

用于创建预编译头文件的第一次编译所花费的时间比后面的编译稍长一些，通过包含预编译代码可以加快后面的编译速度。

13. 阐述堆和栈的区别

答：

1.申请方式。

栈由编译器自动申请空间，堆需要程序员手动申请空间。

2.申请后的系统响应。

栈的剩余空间大于所申请的空间，系统为程序提供内存，否则退出。

堆申请方式是链表式申请，遍历空闲内存链表，找到大于申请空间的内存，从空闲内存链表中删除，分配给程序。

3.申请大小的限制。

栈在windows下是向低地址扩展的数据结构，是一块连续的内存区域，大小是固定的。

（一般是2m）堆是向高地址扩展的数据结构，是

不连续的内存区域。

4.申请效率，栈分配速度较快，堆分配速度较慢，容易产生内存碎片。

还有其它的一些区别，课下大家自己去学习一下。

14. 简要描述c程序的内存分配

答：

C语言内存分配主要分为5块

1.栈。

存放局部变量，函数参数等。

由编译器自动申请空间，自动释放。

2.堆。

由程序员手动申请、释放空间。

3.常量存储区。

一般是常量字符串

4.静态/全局区。

存储的是静态变量或者全局变量。

初始化后等到程序结束后内存才会被释放

5.程序代码区。

存放函数体的二进制代码。

15. static全局变量与普通的全局变量有什么区别？

static局部变量和普通局部变量有什么区别？

static函数与普通函数有什么区别？

答：

1.static全局变量只能在本文件中访问，而全局变量可以通过extern在其它文件中访问

2.static局部变量存储在全局/静态区中，一经初始化直到程序结束后才会被释放。

普通的局部变量存储在栈中。

3.static函数只能在本文件中访问，普通函数可以在其它文件中访问。

16. 局部变量能否和全局变量重名，如果可以，请说明原因？

答：

可以。

局部变量会屏蔽全局变量

17. 使用枚举的好处？

答：

代码的可读性就好一些

18. 全局变量和局部变量在内存中的存储是否有区别？

如果有，是什么区别？

答：

全局变量存储在全局数据区，初始化后直到程序运行结束后才会释放内存。

局部变量存储在栈上，作用域在其被定义的函数或者块中，出了这个作用域就会被释放。

19. #include 与 #include"file.h"的区别？

答：

<>一般用来引用系统定义的头文件，“”一般用来引用自定义头文件。

20. “引用”与指针的区别是什么？

答：

引用是变量的别名，指针保存的是变量的地址。

也就是说引用是直接操作变量本身，而指针是间接操作变量。

21. 已知strcpy函数的原型是：

char*strcpy（char*strDest,constchar*strSrc）;

1.不调用库函数，实现strcpy函数。

2.解释为什么要返回char*。

答：

1.char*strcpy（char*strDest,constchar*strSrc）

{

char*strDestCopy=strDest;

if（strDest==NULL||strSrc==NULL）

{

throw（"invalidarguments"）;

}

while（（*strDestCopy++=*strSrc++）!

='\0'）;

returnstrDest;

}

2.支持链式表达式

22. 判断一个字符串是不是回文，当字符串是回文时,函数返回字符串:

yes!

否则函数返回字符串:

no。

所谓回文即正向与反向的拼写都一样，例如:

adgda。

答：

#include

#include

#defineN100

char*judgeStrings（char*str）;

intmain（）

{

chara[N];

printf（"请输入要判断的回文字符串：

"）;

scanf（"%s",a）;

printf（"%s\n",judgeStrings（a））;

return0;

}

char*judgeStrings（char*str）

{

if（str==NULL）

throw"error:

strisNULL";

intlen=strlen（str）;

for（inti=0;i

{

if（str[i]!

=str[len-i-1]）

return"no";

}

return"yes!

";

}

23. 递规反向输出字符串的例子,可谓是反序的经典例程,那么任意输入一字符串，利用递归将其反向输出.

#include

#defineN20

voidgetReverseChar（char*str）;

intmain（）

{

chara[N];

printf（"请输入要反序的字符串：

"）;

scanf（"%s",a）;

getReverseChar（a）;

printf（"\n"）;

return0;

}

voidgetReverseChar（char*str）

{

if（*str=='\0'）

return;

else

{

getReverseChar（str+1）;

printf（"%c",*str）;

}

}

24. 用指针的方法，将字符串“ABCD1234efgh”前后对调显示

#include

#include

intmain（）

{

chara[]="ABCD1234efgh";

char*p=a;

intlen=strlen（a）;

for（inti=0;i

{

chartemp=a[i];

a[i]=a[len-i-1];

a[len-i-1]=temp;

}

printf（"%s\n",a）;

return0;

}

25. 两个字符串，s,t;把t字符串插入到s字符串中，s字符串有足够的空间存放t字符串

答：

#include

#include

#defineN100

intmain（）

{

chars[N]="HelloWorld";

char*t="welcometoBeijing";

intsLen=strlen（s）;

inttLen=strlen（t）;

intpos;

printf（"请输入要插入的位置：

"）;

scanf（"%d",&pos）;

if（pos>sLen||pos<0）

return0;

//先将s字符数组后面的字符放到后面（采用前插法，从0开始）

for（inti=0;i

{

s[pos+tLen+i]=s[pos+i];

}

//再放心的插入t字符数组

for（inti=0;i

{

s[pos+i]=t[i];

}

s[sLen+tLen]='\0';

printf（"%s\n",s）;

return0;

}

26. 已知strcmp的原型是

intstrcmp（constchar*str1,constchar*str2），不调用库函数，实现strcmp函数

答：

#include

#include

#defineN100

intstrcmp（constchar*str1,constchar*str2）;

intmain（）

{

chars[N];

chart[N];

printf（"请输入要比较的一个字符串：

"）;

scanf（"%s",s）;

printf（"请输入要比较的另一个字符串：

"）;

scanf（"%s",t）;

printf（"%d\n",strcmp1（s,t））;

return0;

}

intstrcmp（constchar*str1,constchar*str2）

{

intlen1=strlen（str1）;

intlen2=strlen（str2）;

intmaxLen=len1>len2?

len1:

len2;

for（inti=0;i

{

if（str1[i]>str2[i]）

return1;

elseif（str1[i]

return-1;

}

return0;

}

27. 找出错误

#include “string.h”

voidmain（void）

{char*src="hello,world";

char*dest=NULL;

dest=（char*）malloc（strlen（src））;

intlen=strlen（str）;

char*d=dest;

char*s=src[len];

while（len--!

=0）

d++=s--;

printf（"%s",dest）;

}

答：

1.string.h用<>括起来。

2.dest=（char*）malloc（strlen（src））;申请的空间不够，需要改为dest=（char*）malloc（strlen（src）+1）;

3.intlen=strlen（str）;改为intlen=strlen（src）;

4.char*s=src[len];改为char*s=src[len-1];

5.d++=s--;改为*d++=*s--;

6.需要在printf（“%s”,dest）;上面加上一行代码：

*d=‘\0’;

28. 写出输出结果

#include

voidfoo（intm,intn）

{

printf（"m=%d,n=%d\n",m,n）;

}

intmain（）

{

intb=3;

foo（b+=3,++b）;

printf（"b=%d\n",b）;

return0;

}

答：

此题考察的有一些难度，深入到了编译器级别。

编译器实现的不一样，那么结果也是不一样的。

在vc6.0下面，结果为：

747在vs2012结果为77

7。

在xcode下面是677.

29. 分析：

intarr[]={6,7,8,9,10};

int*ptr=arr;

*（ptr++）+=123;

printf（“ %d%d ”,*ptr,*（++ptr））;

答：

此题和上一题目类似，考察的是printf（）函数的参数入栈顺序，从右往左的运算。

所以结果为：

88

30. 对下面程序进行分析，若有错误，请写出一个正确的程序段

voidtest2（）

{

charstring[10],str1[10];

inti;

for（i=0;i<10;i++）

{

str1[i]='a';

}

strcpy（string,str1）;

}

答：

错误，主要是str1[10]字符数组没哟\0。

所以应该如下修改:

for（i=0;i<9;i++）

{

str[i]=‘a’;

}

str[i]=‘\0’;

31. 请问一下程序将输出什么结果？

char*RetMemory（void）

{

charp[]= “hellowworld”;

returnp;

}

voidTest（void）

{

char*str=NULL;

str=RetMemory（）;

printf（str）;

}

答：

此程序存在的问题是RetMemory（void）函数返回的是局部变量的地址，然后str指向这个地址，但是实际上这块地址已经让编译器给释放，编译器有可能把这块内存分配给其它的变量。

所以如果内存没有被修改的话输出结果为helloworld,如果被修改则输出结果未知。

32. 分析下面的程序：

voidGetMemory（char**p,intnum）

{

*p=（char*）malloc（num）;

}

intmain（）

{

char*str=NULL;

GetMemory（&str,100）;

strcpy（str,"hello"）;

free（str）;

if（str!

=NULL）

{

strcpy（str,"world"）;

}

printf（"\nstris%s",str）;

getchar（）;

}

答：

程序存在的问题是：

GetMemory函数成功的为str分配了一块堆上的内存，但是后来被释放掉了。

由于释放后没有将指针置为空，故str肯定不会为NULL。

接着调用strcpy（）函数为str指向的空间赋值。

这是非法的，str指向的是已经被释放的内存，故拷贝会失败。

33. 下面的语句会出