c语言经典笔试题非常全.docx
《c语言经典笔试题非常全.docx》由会员分享，可在线阅读，更多相关《c语言经典笔试题非常全.docx（57页珍藏版）》请在冰豆网上搜索。
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;关键字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="09";
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）
...*/
#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”
函数头是这样的：
.
}
解答：
正确解答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;
=1;
return==1）;
}
}
30.堆和栈的区别
栈区（stack）-由编译器自动分配释放，存放函数的参数值，局部变量的值等。
其操作方式类似于数据结构中的栈。
堆区（heap）-一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。
1）从静态存储区域分配。
内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。
例如全局变量，static变量。
2）在栈上创建。
在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。
栈内存分配运算内置于处理器的指令集。
3）从堆上分配，亦称动态内存分配。
程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。
动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。
和class的区别
答案：
struct的成员默认是公有的，而类的成员默认是私有的。
struct和class在其他方面是功能相当的。
从感情上讲，大多数的开发者感到类和结构有很大的差别。
感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位，而类就象活的并且可靠的社会成员，它有智能服务，有牢固的封装屏障和一个良好定义的接口。
既然大多数人都这么认为，那么只有在你的类有很少的方法并且有公有数据（这种事情在良好设计的系统中是存在的!
）时，你也许应该使用struct关键字，否则，你应该使用class关键字。
32.#include""#defineSQR（X）X*X
intmain（intargc,char*argv[]）{ inta=10; intk=2; intm=1;
a/=SQR（k+m）/SQR（k+m）; printf（"%d\n",a）;
return0;}这道题目的结果是什么啊2+1*2+1/2+1*2+1=2+2++2+1=
--------------------------------------------------------------------------33.const符号常量；
（1）constchar*p
（2）charconst*p（3）char*constp说明上面三种描述的区别；
如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。
（1）constchar*p
一个指向char类型的const对象指针，p不是常量,我们可以修改p的值，使其指向不同的char，但是不能改变它指向非char对象，如：
constchar*p;charc1='a';charc2='b';p=&c1;面是C语言中两种if语句判断方式。
请问哪种写法更好为什么？
intn; if（n==10）出运行结果:
{C++写个程序，如何判断一个操作系统是16位还是32位的不能用sizeof（）函数
A1:
16位的系统下，inti=65536;cout<
voidmain（）{ inti=60; intj=50; i=i+j; j=i-j; i=i-j; printf（"i=%d\n",i）; printf（"j=%d\n",j）;}
方法二：
i^=j;j^=i;i^=j;
方法三：
程间通信的方式有
进程间通信的方式有共享内存，管道，Socket，消息队列,等
39structA{chart:
4;chark:
4;unsignedshorti:
8;unsignedlongm;}sizeof（A）=（不考虑边界对齐）
7
40给定结构structA
{
chart:
4;
chark:
4;
unsignedshorti:
8;
unsignedlongm;
};问sizeof（A）=
给定结构structA
{
chart:
4;4位
chark:
4;4位
unsignedshorti:
8;8位
unsignedlongm;度快B.不能用于不同进程C.不能进行资源统计（每次只可以有一个线程对共享资源进行存取）
A.速度慢B.可用于不同进程C.不能进行资源统计
A.速度慢B.可用于不同进程C.可进行资源统计（可以让一个或超过一个线程对共享资源进行存取）
A.速度慢B.可用于不同进程C.可进行资源统计
47请指出下列程序中的错误并且修改voidGetMemory（char*p）{ p=（char*）malloc（100）;}voidTest（void）{ char*str=NULL; GetMemory=（str）; strcpy（str,"helloworld"）; printf（str）;}
A:
错误--参数的值改变后，不会传回GetMemory并不能传递动态内存，Test函数中的str一直都是NULL。
strcpy（str,"helloworld"）;将使程序崩溃。
修改如下:
char*GetMemory（）{ char*p=（char*）malloc（100）; returnp;}voidTest（void）{ char*str=NULL; str=GetMemory（）{ strcpy（str,"helloworld"）; printf（str）;}
方法二:
voidGetMemory2（char**p）变为二级指针.voidGetMemory2（char**p,intnum）{ *p=（char*）malloc（sizeof（char）*num）;}
48用C写一个输入的整数,倒着输出整数的函数,要求用递归方法;
答:
voidfun（inta）{ printf（"%d",a%10）; a/=10; if（a<=0）return;
fun（a）;}
49.头文件中的ifndef/define/endif干什么用预处理
答：
防止头文件被重复引用
50.＃include和＃include“”有什么区别
答：
前者用来包含开发环境提供的库头文件，后者用来包含自己编写的头文件。
51.在C++程序中调用被C编译器编译后的函数，为什么要加extern“C”声明
答：
函数和变量被C++编译后在符号库中的名字与C语言的不同，被extern"C"修饰的变
量和函数是按照C语言方式编译和连接的。
由于编译后的名字不同，C++程序不能直接调
用C函数。
C++提供了一个C连接交换指定符号extern“C”来解决这个问题。
52.回答下面的问题（6分）
（1）.VoidGetMemory（char**p,intnum）{
*p=（char*）malloc（num）;
}
voidTest（void）{
char*str=NULL;
GetMemory（&str,100）;
strcpy（str,"hello"）;
printf（str）;
}
请问运行Test函数会有什么样的结果
答：
输出“hello”
（2）.voidTest（void）{
char*str=（char*）malloc（100）;
strcpy（str,“hello”）;
free（str）;
if（str!
=NULL）{
strcpy（str,“world”）;
printf（str）;
}
}
请问运行Test函数会有什么样的结果
答：
输出“world”
（3）.char*GetMemory（void）{
charp[]="helloworld";
returnp;
}
voidTest（void）{
char*str=NULL;
str=GetMemory（）;
printf（str）;
}
请问运行Test函数会有什么样的结果
答：
无效的指针，输出不确定
53.编写strcat函数（6分）
已知strcat函数的原型是char*strcat（char*strDest,constchar*strSrc）;
其中strDest是目的字符串，strSrc是源字符串。
（1）不调用C++/C的字符串库函数，请编写函数strcat
答：
char*strcat（char*dst,constchar*src）
{
char*cp=dst;
while（*cp）
cp++;/*findendofdst*/
while（*cp++=*src++）;/*Copysrctoendofdst*/
return（dst）;/*returndst*/
}
（2）strcat能把strSrc的内容连接到strDest，为什么还要char*类型的返回值
答：
方便赋值给其他变量
54.程序什么时候应该使用线程，什么时候单线程效率高。
答：
1．耗时的操作使用线程，提高应用程序响应
2．并行操作时使用线程，如C/S架构的服务器端并发线程响应用户的请求。
3．多CPU系统中，使用线程提高CPU利用率
4．改善程序结构。
一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独
立的运行部分，这样的程序会利于理解和修改
升级会员 