c语言经典笔试题非常全.docx

c语言经典笔试题非常全.docx

《c语言经典笔试题非常全.docx》由会员分享，可在线阅读，更多相关《c语言经典笔试题非常全.docx（68页珍藏版）》请在冰豆网上搜索。

c语言经典笔试题非常全

1.用预处理指令#define声明一个常数，用以表明1年中有多少秒（忽略闰年问题）

#defineSECONDS_PER_YEAR（60*60*24*365）UL

2.写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。

#defineMIN（A,B）（（A）<=（B）（A）:

（B））

4.嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？

这个问题用几个解决方案。

我首选的方案是：

while

（1）

{

}

一些程序员更喜欢如下方案：

for（;;）

{

}

第三个方案是用goto

Loop:

...

gotoLoop;

5.用变量a给出下面的定义

a）一个整型数（Aninteger）

b）一个指向整型数的指针（Apointertoaninteger）

c）一个指向指针的的指针，它指向的指针是指向一个整型数（Apointertoapointertoaninteger）

d）一个有10个整型数的数组（Anarrayof10integers）

e）一个有10个指针的数组，该指针是指向一个整型数的（Anarrayof10pointerstointegers）

f）一个指向有10个整型数数组的指针（Apointertoanarrayof10integers）

g）一个指向函数的指针，该函数有一个整型参数并返回一个整型数（Apointertoafunctionthattakesanintegerasanargumentandreturnsaninteger）

h）一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（Anarrayoftenpointerstofunctionsthattakeanintegerargumentandreturnaninteger）

答案是：

a）inta;//Aninteger

b）int*a;//Apointertoaninteger

c）int**a;//Apointertoapointertoaninteger

d）inta[10];//Anarrayof10integers

e）int*a[10];//Anarrayof10pointerstointegers

f）int（*a）[10];//Apointertoanarrayof10integers

g）int（*a）（int）;//Apointertoafunctionathattakesanintegerargumentandreturnsaninteger

h）int（*a[10]）（int）;//Anarrayof10pointerstofunctionsthattakeanintegerargumentandreturnaninteger

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

这个简单的问题很少有人能回答完全。

在C语言中，关键字static有三个明显的作用：

1）.在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。

2）.在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。

它是一个本地的全局变量。

3）.在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。

那就是，这个函数被限制在声明它的模块的本地范围内使用。

7．关键字const是什么含意？

constinta;

intconsta;

constint*a;

int*consta;

intconst*aconst;

前两个的作用是一样，a是一个常整型数。

第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。

第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。

最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。

如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。

8.关键字volatile有什么含意并给出三个不同的例子。

一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。

精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。

下面是volatile变量的几个例子：

1）.并行设备的硬件寄存器（如：

状态寄存器）

2）.一个中断服务子程序中会访问到的非自动变量（Non-automaticvariables）

3）.多线程应用中被几个任务共享的变量

1）.一个参数既可以是const还可以是volatile吗？

解释为什么。

2）.一个指针可以是volatile吗？

解释为什么。

3）.下面的函数有什么错误：

intsquare（volatileint*ptr）

{

return*ptr**ptr;

}

Ptr内容可能被修改，无法保证两次取得同一个值，应该先取出值放入一个变量中，然后通过这个变量来计算

9.嵌入式系统总是要用户对变量或寄存器进行位操作。

给定一个整型变量a，写两段代码，第一个设置a的bit3，第二个清除a的bit3。

在以上两个操作中，要保持其它位不变。

#defineBIT3（0x1<<3）

staticinta;

voidset_bit3（void）

{

a|=BIT3;

}

voidclear_bit3（void）

{

a&=~BIT3;

}

10.嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。

在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。

编译器是一个纯粹的ANSI编译器。

写代码去完成这一任务。

Int*p;

P=（int*）0x67a9;

*p=0xaa66;

11.中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展—让标准C支持中断。

具代表事实是，产生了一个新的关键字__interrupt。

下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序（ISR），请评论一下这段代码的。

__interruptdoublecompute_area（doubleradius）

{

doublearea=PI*radius*radius;

printf（"Area=%f",area）;

returnarea;

}

12.下面的代码输出是什么，为什么？

voidfoo（void）

{

unsignedinta=6;

intb=-20;

（a+b>6）puts（">6"）:

puts（"<=6"）;

}

>6

13.评价下面的代码片断：

unsignedintzero=0;

unsignedintcompzero=0xFFFF;

/*1'scomplementofzero*/

14.尽管不像非嵌入式计算机那么常见，嵌入式系统还是有从堆（heap）中动态分配内存的过程的。

那么嵌入式系统中，动态分配内存可能发生的问题是什么？

主要有三种类型:

内存泄露、内存碎片和内存崩溃　内存崩溃是内存使用最严重的结果，主要原因有数组访问越界、写已经释放的内存、指针计算错误、访问堆栈地址越界等等。

碎片收集的问题，变量的持行时间等等

下面的代码片段的输出是什么，为什么？

char*ptr;

if（（ptr=（char*）malloc（0））==NULL）

puts（"Gotanullpointer"）;

else

puts（"Gotavalidpointer"）;

该代码的输出是“Gotavalidpointer”。

15.Typedef在C语言中频繁用以声明一个已经存在的数据类型的同义字。

也可以用预处理器做类似的事。

例如，思考一下下面的例子：

#definedPSstructs*

typedefstructs*tPS;

答案是：

typedef更好。

思考下面的例子：

dPSp1,p2;

tPSp3,p4;

第一个扩展为

structs*p1,p2;

上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。

第二个例子正确地定义了p3和p4两个指针。

16.C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什么？

inta=5,b=7,c;

c=a+++b;

上面的代码被处理成：

c=a+++b;

因此,这段代码持行后a=6,b=7,c=12。

17.找错题

　　试题1：

voidtest1（）

{

　charstring[10];

　char*str1="0123456789";

　strcpy（string,str1）;

}

　　试题2：

voidtest2（）

{

　charstring[10],str1[10];

　inti;

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

　{

　　str1[i]='a';

　}

　strcpy（string,str1）;

}

　　试题3：

voidtest3（char*str1）

{

　charstring[10];

　if（strlen（str1）<=10）

　{

　　strcpy（string,str1）;

　}

}

　　解答：

　　试题1字符串str1需要11个字节才能存放下（包括末尾的’\0’），而string只有10个字节的空间，strcpy会导致数组越界；

　　对试题2，如果面试者指出字符数组str1不能在数组内结束可以给3分；如果面试者指出strcpy（string,str1）调用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10分；

　　对试题3，if（strlen（str1）<=10）应改为if（strlen（str1）<10），因为strlen的结果未统计’\0’所占用的1个字节。

18．写出字符串strcpy的函数实现过程式

voidstrcpy（char*strdest,char*strsrc）

{

　while（（*strdest++=*strsrc++）!

=‘\0’）;

}

　　4分

voidstrcpy（char*strdest,constchar*strsrc）

//将源字符串加const，表明其为输入参数，加2分

{

　while（（*strdest++=*strsrc++）!

=‘\0’）;

}

　　7分

voidstrcpy（char*strdest,constchar*strsrc）

{

　//对源地址和目的地址加非0断言，加3分

　assert（（strdest!

=null）&&（strsrc!

=null））;

　while（（*strdest++=*strsrc++）!

=‘\0’）;

}

　　10分

//为了实现链式操作，将目的地址返回，加3分！

char*strcpy（char*strdest,constchar*strsrc）

{

　assert（（strdest!

=null）&&（strsrc!

=null））;

　char*address=strdest;

　while（（*strdest++=*strsrc++）!

=‘\0’）;

　　returnaddress;

}

　20．经典getmemory问题讨论

试题4：

voidgetmemory（char*p）

{

　p=（char*）malloc（100）;

}

voidtest（void）

{

　char*str=null;

　getmemory（str）;

　strcpy（str,"helloworld"）;

　printf（str）;

}

　　试题5：

char*getmemory（void）

{

　charp[]="helloworld";

　returnp;

}

voidtest（void）

{

　char*str=null;

　str=getmemory（）;

　printf（str）;

}

　　试题6：

voidgetmemory（char**p,intnum）

{

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

}

voidtest（void）

{

　char*str=null;

　getmemory（&str,100）;

　strcpy（str,"hello"）;

　printf（str）;

}

　　试题7：

voidtest（void）

{

　char*str=（char*）malloc（100）;

　strcpy（str,"hello"）;

　free（str）;

　...//省略的其它语句

}

　　解答：

　　试题4传入中getmemory（char*p）函数的形参为字符串指针，在函数内部修改形参并不能真正的改变传入形参的值，执行完

char*str=null;

getmemory（str）;

　　后的str仍然为null；

　　试题5中

charp[]="helloworld";

returnp;

　　的p[]数组为函数内的局部自动变量，在函数返回后，内存已经被释放。

这是许多程序员常犯的错误，其根源在于不理解变量的生存期。

　　试题6的getmemory避免了试题4的问题，传入getmemory的参数为字符串指针的指针，但是在getmemory中执行申请内存及赋值语句

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

　　后未判断内存是否申请成功，应加上：

if（*p==null）

{

　...//进行申请内存失败处理

}

　　试题7存在与试题6同样的问题，在执行

char*str=（char*）malloc（100）;

　　后未进行内存是否申请成功的判断；另外，在free（str）后未置str为空，导致可能变成一个“野”指针，应加上：

str=null;

　　试题6的test函数中也未对malloc的内存进行释放。

21下面的一段程序有什么错误：

swap（int*p1,int*p2）

{

　int*p;

　*p=*p1;

　*p1=*p2;

　*p2=*p;

}

　　在swap函数中，p是一个“野”指针，有可能指向系统区，导致程序运行的崩溃。

在vc++中debug运行时提示错误“accessviolation”。

该程序应该改为：

swap（int*p1,int*p2）

{

　intp;

　p=*p1;

　*p1=*p2;

　*p2=p;

}

22：

分别给出bool，int，float，指针变量与“零值”比较的if语句（假设变量名为var）

　　解答：

　　　bool型变量：

if（!

var）

　　　int型变量：

if（var==0）

　　　float型变量：

　　　constfloatepsinon=0.00001;

　　　if（（x>=-epsinon）&&（x<=epsinon）

　　　指针变量：

　　if（var==null）

　　剖析：

　　考查对0值判断的“内功”，bool型变量的0判断完全可以写成if（var==0），而int型变量也可以写成if（!

var），指针变量的判断也可以写成if（!

var），上述写法虽然程序都能正确运行，但是未能清晰地表达程序的意思。

　　一般的，如果想让if判断一个变量的“真”、“假”，应直接使用if（var）、if（!

var），表明其为“逻辑”判断；如果用if判断一个数值型变量（short、int、long等），应该用if（var==0），表明是与0进行“数值”上的比较；而判断指针则适宜用if（var==null），这是一种很好的编程习惯。

　　浮点型变量并不精确，所以不可将float变量用“==”或“！

=”与数字比较，应该设法转化成“>=”或“<=”形式。

如果写成if（x==0.0），则判为错，得0分。

23：

以下为windowsnt下的32位c++程序，请计算sizeof的值

voidfunc（charstr[100]）

{

　sizeof（str）=?

}

void*p=malloc（100）;

sizeof（p）=?

　　解答：

……

sizeof（str）=4

sizeof（p）=4

charstr[10];

cout<

24：

写一个“标准”宏min，这个宏输入两个参数并返回较小的一个。

另外，当你写下面的代码时会发生什么事？

least=min（*p++,b）;

　　解答：

#definemin（a,b）（（a）<=（b）?

（a）:

（b））

　　min（*p++,b）会产生宏的副作用

25　为什么标准头文件都有类似以下的结构？

#ifndef__incvxworksh

#define__incvxworksh

#ifdef__cplusplus

extern"c"{

#endif

/*...*/

#ifdef__cplusplus

}

#endif

#endif/*__incvxworksh*/

　　解答：

　　头文件中的编译宏

#ifndef　__incvxworksh

#define　__incvxworksh

#endif

　　的作用是防止被重复引用。

为了实现c和c++的混合编程，c++提供了c连接交换指定符号extern"c"来解决名字匹配问题，函数声明前加上extern"c"后，则编译器就会按照c语言的方式将该函数编译为_foo，这样c语言中就可以调用c++的函数了。

26编写一个函数，作用是把一个char组成的字符串循环右移n个。

比如原来是“abcdefghi”如果n=2，移位后应该是“hiabcdefgh”

　　函数头是这样的：

//pstr是指向以'\0'结尾的字符串的指针

//steps是要求移动的n

voidloopmove（char*pstr,intsteps）

{

　//请填充...

}

　　解答：

　　正确解答1：

voidloopmove（char*pstr,intsteps）

{

　intn=strlen（pstr）-steps;

　chartmp[max_len];

　strcpy（tmp,pstr+n）;

　strcpy（tmp+steps,pstr）;

　*（tmp+strlen（pstr））='\0';

　strcpy（pstr,tmp）;

}

　　正确解答2：

voidloopmove（char*pstr,intsteps）

{

　intn=strlen（pstr）-steps;

　chartmp[max_len];

　memcpy（tmp,pstr+n,steps）;

　memcpy（pstr+steps,pstr,n）;

　memcpy（pstr,tmp,steps）;

}

27static关键字至少有下列n个作用：

（1）函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；

（2）在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；

　　（3）在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；

28　const关键字至少有下列n个作用：

（1）欲阻止一个变量被改变，可以使用const关键字。

在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；

（2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；

　　（3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；

　　（4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；

29：

请写一个c函数，若处理器是big_endian的，则返回0；若是little_endian的，则返回1

　　解答：

intcheckcpu（）

{

　{

　　unionw

　　{

　　　inta;

　　　charb;

　　}c;

　　c.a=1;

　　return（c.b==1）;

　}

}

30.堆和栈的区别？

栈区（stack）-由编译器自动分配释放，存放函数的参数值，局部变量的值等。

其操作方式类似于数据结构中的栈。

堆区（heap）-一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。

1）从静态存储区域分配。

内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。

例如全局变量，static变量。

2）在栈上创建。

在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。

栈内存分配运算内置于处理器的指令集。

3）从堆上分配，亦称动态内存分配。

程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。

动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。

31.struct和class的区别

答案：

st