C面试题库一.docx
《C面试题库一.docx》由会员分享，可在线阅读，更多相关《C面试题库一.docx（41页珍藏版）》请在冰豆网上搜索。
C面试题库一
C语言面试题库一
1.用预处理指令#define声明一个常数，用以表明1年中有多少秒（忽略闰年问题）
#defineSECONDS_PER_YEAR（60*60*24*365）
/*宏定义后面不加“；”,最好每个在宏里面的成员多加“（）”..*/
2.写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。
#defineMIN（A,B）（（A）<=（B）?
（A）:
（B））
/*外面也加括号，防止宏再进行运算*/
3.嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？
这个问题用几个解决方案。
我首选的方案是：
while
（1）
{
}
一些程序员更喜欢如下方案：
for（;;）
{
}
第三个方案是用goto
Loop:
...
gotoLoop;
/*只能够在本函数里面跳*/
4.用变量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
5.关键字static的作用是什么？
（1）函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；
/*函数调用结束后，变量的值不丢失,在函数中初始化的时候后面就不再次给这个变量初始化，如果另外复制的话，就要每次被执行，，staticinta=10;（初始化）；staticinta;a=10;（赋值）；*/
（2）在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；
（3）在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；
6．关键字const是什么含意？
分别解释下列语句中const的作用？
constinta;
intconsta;
constint*a;、
、
int*consta;
intconst*consta;
/*const是在编译的时候起作用，编译（出错）通不过*/
（1）欲阻止一个变量被改变，可以使用const关键字。
在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；
（2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
（3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
（4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；
前两个的作用是一样，a是一个常整型数。
第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。
第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。
最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。
如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。
7.关键字volatile有什么含意并给出三个不同的例子。
/*加上volatile之后，CPU不去优化程序；在多任务执行中，每次变量的值发生改变之后，都去内存里面回写这个值*/
一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。
精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。
下面是volatile变量的几个例子：
1）.并行设备的硬件寄存器（如：
状态寄存器）
/*（有时硬件引起的变化，程度没有去回写寄存器，而是按照先前的值处理）没有加volate之前*/
2）.一个中断服务子程序中会访问到的非自动变量（Non-automaticvariables）（中断嵌套）
3）.多线程应用中被几个任务共享的变量
8.一个参数既可以是const还可以是volatile吗？
解释为什么。
可以，（硬件状态寄存器）但没有必要，因为const修饰的参数不能被修改，没有必要再用volatile修饰
9.一个指针可以是volatile吗？
解释为什么。
是的。
尽管这并不很常见。
一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
10.下面的函数有什么错误：
intsquare（volatileint*ptr）
{
return*ptr**ptr;
}
这段代码有点变态。
这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：
intsquare（volatileint*ptr）
{
inta,b;
a=*ptr;
b=*ptr;
returna*b;
}
由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。
结果，这段代码可能返不是你所期望的平方值！
正确的代码如下：
longsquare（volatileint*ptr）
{
inta;
a=*ptr;
returna*a;
}
11.嵌入式系统总是要用户对变量或寄存器进行位操作。
给定一个整型变量a，写两段代码，第一个设置a的bit3，第二个清除a的bit3。
在以上两个操作中，要保持其它位不变。
#defineBIT3（0x1<<3）
staticinta;
voidset_bit3（void）
{
a|=BIT3;
}
voidclear_bit3（void）
{
a&=~BIT3;
}
12.嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。
在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。
编译器是一个纯粹的ANSI编译器。
写代码去完成这一任务。
这一问题测试你是否知道为了访问一绝对地址把一个整型数强制转换（typecast）为一指针是合法的。
这一问题的实现方式随着个人风格不同而不同。
典型的类似代码如下：
int*ptr;
ptr=（int*）0x67a9;
*ptr=0xaa55;
14.下面的代码输出是什么，为什么？
voidfoo（void）
{
unsignedinta=6;
intb=-20;
（a+b>6）puts（">6"）:
puts（"<=6"）;
}
答案是输出是”>6”。
原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。
因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。
这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。
/*有符号数的扩展，只是在符号位前面补充和符号位一样的数*/
/*为了使0经过转变之后，还是0，所以：
补码=~源码+ １*/
15.评价下面的代码片断：
unsignedintzero=0;
unsignedintcompzero=0xFFFF;
/*1'scomplementofzero*/
对于一个int型不是16位的处理器为说，上面的代码是不正确的。
应编写如下：
unsignedintcompzero=~0;
这一问题真正能揭露出应试者是否懂得处理器字长的重要性。
好的嵌入式程序员非常准确地明白硬件的细节和它的局限。
16.尽管不像非嵌入式计算机那么常见，嵌入式系统还是有从堆（heap）中动态分配内存的过程的。
那么嵌入式系统中，动态分配内存可能发生的问题是什么？
主要有三种类型:
内存泄露、内存碎片和内存崩溃，内存崩溃是内存使用最严重的结果，主要原因有数组访问越界、写已经释放的内存、指针计算错误、访问堆栈地址越界等等。
碎片收集的问题，变量的持行时间等等
17.下面的代码片段的输出是什么，为什么？
char*ptr;
if（（ptr=（char*）malloc（0））==NULL）
puts（"Gotanullpointer"）;
else
puts（"Gotavalidpointer"）;
该代码的输出是“Gotavalidpointer”。
/*在堆的每个区间的前面，有个头部用以管理这个分配的空间，所以malloc（0）!
=NULL*/
18.Typedef在C语言中频繁用以声明一个已经存在的数据类型的同义字。
也可以用预处理器做类似的事。
例如，思考一下下面的例子,那个更好，为什么？
#definedPSstructs*
typedefstructs*tPS;
答案是：
typedef更好。
思考下面的例子：
dPSp1,p2;
tPSp3,p4;
第一个扩展为
structs*p1,p2;
上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。
第二个例子正确地定义了p3和p4两个指针。
19.C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什么？
inta=5,b=7,c;
c=a+++b;
上面的代码被处理成：
c=a+++b;
因此,这段代码持行后a=6,b=7,c=12。
20.找错题
试题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）;
/*没有\0,strcpy停止不了*/
}
试题3：
voidtest3（char*str1）
{
charstring[10];
if（strlen（str1）<=10）//strlen不计算\0
{
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个字节。
21．写出字符串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分
if（（strdest==null）||（strsrc==null））;
return;
while（（*strdest++=*strsrc++）!
=‘\0’）;
}
10分
//为了实现链式操作，将目的地址返回，加3分！
char*strcpy（char*strdest,constchar*strsrc）
{
if（（strdest==null）&&（strsrc==null））;
returnNULL;
char*address=strdest;
while（（*strdest++=*strsrc++）!
=‘\0’）;
returnaddress;
}
22．经典getmemory问题讨论
试题1：
voidgetmemory（char*p）
{
p=（char*）malloc（100）;
}
voidtest（void）
{
char*str=null;
getmemory（str）;
strcpy（str,"helloworld"）;
printf（str）;
}
试题2：
char*getmemory（void）
{
charp[]="helloworld";
returnp;
}
voidtest（void）
{
char*str=null;
str=getmemory（）;
printf（str）;
}
试题3：
voidgetmemory（char**p,intnum）
{
*p=（char*）malloc（num）;
/*必需判断是否分配成功*/
}
voidtest（void）
{
char*str=null;
getmemory（&str,100）;
strcpy（str,"hello"）;
printf（str）;
}
试题4：
voidtest（void）
{
char*str=（char*）malloc（100）;
strcpy（str,"hello"）;
free（str）;
...//省略的其它语句
}
解答：
试题1传入中getmemory（char*p）函数的形参为字符串指针，在函数内部修改形参并不能真正的改变传入形参的值，执行完
char*str=null;
getmemory（str）;
后的str仍然为null；
试题2中
charp[]="helloworld";
returnp;
的p[]数组为函数内的局部自动变量，在函数返回后，内存已经被释放。
这是许多程序员常犯的错误，其根源在于不理解变量的生存期。
试题3的getmemory避免了试题4的问题，传入getmemory的参数为字符串指针的指针，但是在getmemory中执行申请内存及赋值语句
*p=（char*）malloc（num）;
后未判断内存是否申请成功，应加上：
if（*p==null）
{
...//进行申请内存失败处理
}
试题4存在与试题3同样的问题，在执行
char*str=（char*）malloc（100）;
后未进行内存是否申请成功的判断；另外，在free（str）后未置str为空，导致可能变成一个“野”指针，应加上：
str=null;
试题3的test函数中也未对malloc的内存进行释放。
23．下面的一段程序有什么错误：
swap（int*p1,int*p2）
{
int*p;
/*p=NULL,NULL就是一个宏定义的0，但是不能够往*p里面写东西，因为这个是个常量，不能够给常量赋值*/
*p=*p1;
*p1=*p2;
*p2=*p;
}
在swap函数中，p是一个“野”指针，有可能指向系统区，导致程序运行的崩溃。
在vc++中debug运行时提示错误“accessviolation”。
该程序应该改为：
swap（int*p1,int*p2）
{
intp;
p=*p1;
*p1=*p2;
*p2=p;
}
24．分别给出bool，int，float，指针变量与“零值”比较的if语句（假设变量名为var）
解答：
bool型变量：
if（!
var）
int型变量：
if（0==var）
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分。
25.请计算sizeof的值
voidfunc（charstr[100]）
{
sizeof（str）=?
}
void*p=malloc（100）;
sizeof（p）=?
charstr[10];
cout< 解答：
……
sizeof（str）=4
sizeof（p）=4
sizeof（str）=10
26.写一个“标准”宏min，这个宏输入两个参数并返回较小的一个。
另外，当你写下面的代码时会发生什么事？
least=min（*p++,b）;
解答：
#definemin（a,b）（（a）<=（b）?
（a）:
（b））
min（*p++,b）会产生宏的副作用
27.为什么标准头文件都有类似以下的结构？
#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++的函数了。
28.编写一个函数，作用是把一个char组成的字符串循环右移n个。
比如原来是“abcdefghi”如果n=2，移位后应该是“hiabcdefg”
函数头是这样的：
//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];
memncpy（tmp,pstr+n,steps）;
memncpy（pstr+steps,pstr,n）;
memncpy（pstr,tmp,strlen（pstr））;
}
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的区别
答案：
struct的成员默认是公有的，而类的成员默认是私有的。
struct和class在其他方面是功能相当的。
从感情上讲，大多数的开发者感到类和结构有很大的差别。
感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位，而类就象活的并且可靠的社会成员，它有智能服务，有牢固的封装屏障和一个良好定义的接口。
既然大多数人都这么认为，那么只有在你的类有很少的方法并且有公有数据（这种事情在良好设计的系统中是存在的!
升级会员 