嵌入式软件工程师笔试题面试宝典.docx
《嵌入式软件工程师笔试题面试宝典.docx》由会员分享，可在线阅读，更多相关《嵌入式软件工程师笔试题面试宝典.docx（27页珍藏版）》请在冰豆网上搜索。
嵌入式软件工程师笔试题面试宝典
1、将一个字符串逆序
2、将一个链表逆序
3、计算一个字节里（byte）里面有多少bit被置1
4、搜索给定的字节（byte）
5、在一个字符串中找到可能的最长的子字符串
6、字符串转换为整数
7、整数转换为字符串
/*
*题目：
将一个字符串逆序
*完成时间：
2006.9.30深圳极讯网吧
*版权归刘志强所有
*描述：
写本程序的目的是希望练一下手，希望下午去面试能成功，不希望国庆节之后再去找工作拉！
*/
#include
usingnamespacestd;
//#defineNULL（（void*）0）
char*mystrrev（char*constdest,constchar*constsrc）
{
if（dest==NULL&&src==NULL）
returnNULL;
char*addr=dest;
intval_len=strlen（src）;
dest[val_len]='\0';
inti;
for（i=0;i{
*（dest+i）=*（src+val_len-i-1）;
}
returnaddr;
}
main（）
{
char*str="asdfa";
char*str1=NULL;
str1=（char*）malloc（20）;
if（str1==NULL）
cout<<"mallocfailed";
cout<free（str1）;
str1=NULL;//杜绝野指针
}
p=head;
q=p->next;
while（q!
=NULL）
{
temp=q->next;
q->next=p;
p=q;
q=temp;
}
这样增加个辅助的指针就行乐。
ok通过编译的代码：
#include
#include
#include
typedefstructList{
intdata;
structList*next;
}List;
List*list_create（void）
{
structList*head,*tail,*p;
inte;
head=（List*）malloc（sizeof（List））;
tail=head;
printf（"\nListCreate,inputnumbers（endof0）:
"）;
scanf（"%d",&e）;
while（e）{
p=（List*）malloc（sizeof（List））;
p->data=e;
tail->next=p;
tail=p;
scanf（"%d",&e）;}
tail->next=NULL;
returnhead;
}
List*list_reverse（List*head）
{
List*p,*q,*r;
p=head;
q=p->next;
while（q!
=NULL）
{
r=q->next;
q->next=p;
p=q;
q=r;
}
head->next=NULL;
head=p;
returnhead;
}
voidmain（void）
{
structList*head,*p;
intd;
head=list_create（）;
printf（"\n"）;
for（p=head->next;p;p=p->next）
printf（"--%d--",p->data）;
head=list_reverse（head）;
printf（"\n"）;
for（p=head;p->next;p=p->next）
printf（"--%d--",p->data）;
}
编写函数数N个BYTE的数据中有多少位是1。
解：
此题按步骤解：
先定位到某一个BYTE数据；再计算其中有多少个1。
叠加得解。
#incluede
#defineN10
//定义BYTE类型别名
#ifndefBYTE
typedefunsignedcharBYTE;
#endif
intcomb（BYTEb[],intn）
{
intcount=0;
intbi,bj;
BYTEcc=1,tt;
//历遍到第bi个BYTE数据
for（bi=0;bi{
//计算该BYTE的8个bit中有多少个1
tt=b[bi];
for（bj=0;bj<8;bj++）
{
//与1相与或模2结果是否是1？
测试当前bit是否为1
//if（tt%2==1）
if（（tt&cc）==1）
{
count++;
}
//右移一位或除以2，效果相同
//tt=tt>>1;
tt=tt/2;
}
}
returncount;
}
//测试
intmain（）
{
BYTEb[10]={3,3,3,11,1,1,1,1,1,1};
cout<return0;
}
1。
编写一个C函数，该函数在一个字符串中找到可能的最长的子字符串，且该字符串是由同一字符组成的。
char*search（char*cpSource,charch）
{
char*cpTemp=NULL,*cpDest=NULL;
intiTemp,iCount=0;
while（*cpSource）
{
if（*cpSource==ch）
{
iTemp=0;
cpTemp=cpSource;
while（*cpSource==ch）
++iTemp,++cpSource;
if（iTemp>iCount）
iCount=iTemp,cpDest=cpTemp;
if（!
*cpSource）
break;
}
++cpSource;
}
returncpDest;
}
#include
#include
//
//自定义函数MyAtoI
//实现整数字符串转换为证书输出
//程序不检查字符串的正确性,请用户在调用前检查
//
intMyAtoI（charstr[]）
{
inti;
intweight=1;//权重
intrtn=0;//用作返回
for（i=strlen（str）-1;i>=0;i--）
{
rtn+=（str[i]-'0'）*weight;//
weight*=10;//增重
}
returnrtn;
}
voidmain（）
{
charstr[32];
printf（"Inputastring:
"）;
gets（str）;
printf（"%d\n",MyAtoI（str））;
}
#include
#include
voidreverse（chars[]）
{ //字符串反转
intc,i=0,j;
for（j=strlen（s）-1;i { c=s[i];
s[i]=s[j];
s[j]=c;
i++;
}
}
voidIntegerToString（chars[],intn）
{ inti=0,sign;
if（（sign=n）<0）//如果是负数，先转成正数
n=-n;
do//从个位开始变成字符,直到最高位,最后应该反转
{ s[i++]=n%10+'0';
}while（（n=n/10）>0）;
//如果是负数，补上负号
if（sign<0）
s[i++]='-';
s[i]='\0';//字符串结束
reverse（s）;
}
voidmain（）
{ intm;
charc[100];
printf（"请输入整数m:
"）;
scanf（"%d",&m）;
IntegerToString（c,m）;
printf（"integer=%dstring=%s\n",m,c）;
}
考查嵌入式C开发人员的最好的0x10道题
考查一个初级嵌入式系统开发人员的C基本功，附有答案题目由资深嵌入式系统专家拟定,目的是考查入门级的嵌入式软件开发人员GavinShaw提供详细解答
编者按:
非常基本关于C语言的问题,一个信息类（计算机,资讯工程,电子工程,通信工程）专业的本科毕业生应该达到的水平。
题目不难,全部都能快速地答完，当然也需要一定的知识储备。
对于大多数人，我们预期你可能答错3） 4） 15）题，所以答错3道以内的，我们认为你很棒
答错5道题以内，我们认为你还不错（你还可能答错第9题）
如果你有6道以上的题目不能答对,基本上我们都不好说什么了....
约定:
1）下面的测试题中，认为所有必须的头文件都已经正确的包含了
2）数据类型
char一个字节1byte
int两个字节2byte（16位系统，认为整型是2个字节）
longint四个字节4byte
float 四个字节4byet
double八个字节8byte
longdouble十个字节10byte
pointer两个字节2byte（注意，16位系统,地址总线只有16位）
第1题:
考查对volatile关键字的认识
#include
staticjmp_bufbuf;
main（）
{
volatileintb;
b=3;
if（setjmp（buf）!
=0）
{
printf（"%d",b）;
exit（0）;
}
b=5;
longjmp（buf,1）;
}
请问，这段程序的输出是
（a）3
（b）5
（c）0
（d）以上均不是
第2题:
考查类型转换
main（）
{
structnode
{
inta;
intb;
intc;
};
structnodes={3,5,6};
structnode*pt=&s;
printf（"%d",*（int*）pt）;
}
这段程序的输出是:
（a）3
（b）5
（c）6
（d）7
第3题:
考查递归调用
intfoo（intx,intn）
{
intval;
val=1;
if（n>0）
{
if（n%2==1）val=val*x;
val=val*foo（x*x,n/2）;
}
returnval;
}
这段代码对x和n完成什么样的功能（操作）?
（a）x^n（x的n次幂）
（b）x*n（x与n的乘积）
（c）n^x（n的x次幂）
（d）以上均不是
第4题:
考查指针,这道题只适合于那些特别细心且对指针和数组有深入理解的人
main（）
{
inta[5]={1,2,3,4,5};
int*ptr=（int*）（&a+1）;
printf（"%d%d",*（a+1）,*（ptr-1））;
}
这段程序的输出是:
（a）22
（b）21
（c）25
（d）以上均不是
第5题:
考查多维数组与指针
voidfoo（int[][3]）;
main（）
{
inta[3][3]={{1,2,3},{4,5,6},{7,8,9}};
foo（a）;
printf（"%d",a[2][1]）;
}
voidfoo（intb[][3]）
{
++b;
b[1][1]=9;
}
这段程序的输出是:
（a）8
（b）9
（c）7
（d）以上均不对
第6题目:
考查逗号表达式
main（）
{
inta,b,c,d;
a=3;
b=5;
c=a,b;
d=（a,b）;
printf（"c=%d",c）;
printf（"d=%d",d）;
}
这段程序的输出是:
（a）c=3d=3
（b）c=5d=3
（c）c=3d=5
（d）c=5d=5
第7题:
考查指针数组
main（）
{
inta[][3]={1,2,3,4,5,6};
int（*ptr）[3]=a;
printf（"%d%d",（*ptr）[1],（*ptr）[2]）;
++ptr;
printf（"%d%d",（*ptr）[1],（*ptr）[2]）;
}
这段程序的输出是:
（a）2356
（b）2345
（c）4500
（d）以上均不对
第8题:
考查函数指针
int*f1（void）
{
intx=10;
return（&x）;
}
int*f2（void）
{
int*ptr;
*ptr=10;
returnptr;
}
int*f3（void）
{
int*ptr;
ptr=（int*）malloc（sizeof（int））;
returnptr;
}
上面这3个函数哪一个最可能引起指针方面的问题
（a）只有f3
（b）只有f1andf3
（c）只有f1andf2
（d）f1,f2,f3
第9题:
考查自加操作（++）
main（）
{
inti=3;
intj;
j=sizeof（++i+++i）;
printf（"i=%dj=%d",i,j）;
}
这段程序的输出是:
（a）i=4j=2
（b）i=3j=2
（c）i=3j=4
（d）i=3j=6
第10题:
考查形式参数，实际参数，指针和数组
voidf1（int*,int）;
voidf2（int*,int）;
void（*p[2]）（int*,int）;
main（）
{
inta;
intb;
p[0]=f1;
p[1]=f2;
a=3;
b=5;
p[0]（&a,b）;
printf（"%d\t%d\t",a,b）;
p[1]（&a,b）;
printf（"%d\t%d\t",a,b）;
}
voidf1（int*p,intq）
{
inttmp;
tmp=*p;
*p=q;
q=tmp;
}
voidf2（int*p,intq）
{
inttmp;
tmp=*p;
*p=q;
q=tmp;
}
这段程序的输出是:
（a）5555
（b）3535
（c）5353
（d）3333
第11题:
考查自减操作（--）
voide（int）;
main（）
{
inta;
a=3;
e（a）;
}
voide（intn）
{
if（n>0）
{
e（--n）;
printf（"%d",n）;
e（--n）;
}
}
这段程序的输出是:
（a）0120
（b）0121
（c）1201
（d）0211
第12题:
考查typedef类型定义,函数指针
typedefint（*test）（float*,float*）
testtmp;
tmp的类型是
（a）函数的指针，该函数以两个指向浮点数（float）的指针（pointer）作为参数（arguments）
Pointertofunctionofhavingtwoargumentsthatispointertofloat
（b）整型
（c）函数的指针，该函数以两个指向浮点数（float）的指针（pointer）作为参数（arguments）,并且函数的返回值类型是整型
Pointertofunctionhavingtwoargumentthatispointertofloatandreturnint
（d）以上都不是
第13题:
数组与指针的区别与联系
main（）
{
charp;
charbuf[10]={1,2,3,4,5,6,9,8};
p=（buf+1）[5];
printf（"%d",p）;
}
这段程序的输出是:
（a）5
（b）6
（c）9
（d）以上都不对
第14题:
考查指针数组的指针
Voidf（char**）;
main（）
{
char*argv[]={"ab","cd","ef","gh","ij","kl"};
f（argv）;
}
voidf（char**p）
{
char*t;
t=（p+=sizeof（int））[-1];
printf（"%s",t）;
}
这段程序的输出是:
（a）ab
（b）cd
（c）ef
（d）gh
第15题:
此题考查的是C的变长参数,就像标准函数库里printf（）那样,这个话题一般国内大学课堂是不会讲到的,不会也情有可原呵呵,
#include
intripple（int,...）;
main（）
{
intnum;
num=ripple（3,5,7）;
printf（"%d",num）;
}
intripple（intn,...）
{
inti,j;
intk;
va_listp;
k=0;
j=1;
va_start（p,n）;
for（;j{
i=va_arg（p,int）;
for（;i;i&=i-1）
++k;
}
returnk;
}
这段程序的输出是:
（a）7
（b）6
（c）5
（d）3
第16题:
考查静态变量的知识
intcounter（inti）
{
staticintcount=0;
count=count+i;
return（count）;
}
main（）
{
inti,j;
for（i=0;i<=5;i++）
j=counter（i）;
}
本程序执行到最后,j的值是:
（a）10
（b）15
（c）6
（d）7
详细参考答案
第1题:
（b）
volatile字面意思是易于挥发的。
这个关键字来描述一个变量时，意味着给该变量赋值（写入）之后，马上再读取，写入的值与读取的值可能不一样,所以说它"容易挥发"的。
这是因为这个变量可能一个寄存器，直接与外部设备相连，你写入之后，该寄存器也有可能被外部设备的写操作所改变;或者，该变量被一个中断程序，或另一个进程改变了.
volatile不会被编译器优化影响，在longjump后,它的值是后面假定的变量值,b最后的值是5,所以5被打印出来.
setjmp:
设置非局部跳转/*setjmp.h*/
Storescontextinformationsuchasregistervaluessothatthelomgjmpfunctioncanreturncontroltothestatementfollowingtheonecallingsetjmp.Returns0whenitisinitiallycalled.
Lonjjmp:
执行一个非局部跳转/*setjmp.h*/
Transferscontroltothestatementwherethecalltosetjmp（whichinitializedbuf）wasmade.Executioncontinuesatthispointasiflongjmpcannotreturnthevalue0.Anonvolatileautomaticvariablemightbechangedbyacalltolongjmp.Whenyouusesetjmpandlongjmp,theonlyautomaticvariablesguaranteedtoremainvalidarethosedeclaredvolatile.
Note:
Testprogramwithoutvolatilequalifier（resultmayvery）
更详细介绍，请参阅C语言的setjmp和longjmp
第2题:
（a）
结构题的成员在内存中的地址是按照他们定义的位置顺序依次增长的。
如果一个结构体的指针被看成它的第一个成员的指针,那么该指针的确指向第一个成员
第3题:
（a）
此题目较难.
这个程序的非递归版本
intwhat（intx,intn）
{
intval;
intproduct;
pro
升级会员 