嵌入式软件工程师笔试题

1、 将一个字符串逆序
2、将一个链表逆序
3、计算一个字节里（byte）里面有多少bit被置1
4、搜索给定的字节(byte)
5、在一个字符串中找到可能的最长的子字符串
6、字符串转换为整数
7、整数转换为字符串

1、c51单片机的串口异步通信和同步通信的区别，说说他们的优缺点。

2、C51单片机的数据总线和地址总线是如何复用的，说明原理。

3、C51单片机的绝对寻址范围是多少k？

4、说明下面的寻址方式

     (1)MOV A , #30H                                          (2)MOV A,@R0

     (3)ADD A , R4                                                (4)MOV  A+@DPTR

5、写出下面分别是什么指针？ 

     (1)int *a[10];                                                (2)int  (*a)[10];   

     (3)int  (*P)(int) ;                                            (4)int (*a[10])(int);

6、

void swap（int a，int b）

{

int temp；

temp = a;

a=b;

b=temp；

}

main(void)

{

int x="3"，y=4;

swap(x,y)；

}

问 上面程序执行完后 x= ？，y=?

7、typedef struct  test{

      int i;

      short s；

      char c；

     union{

      int a；

      short b;

}

}example ；

int y ；

y = sizeof(example)；

请问在TC环境下，y=?

8、编程实现数组的逆置，例如，“hello,world!”  逆置后为“!dlrow,olleh”。

9、你认为嵌入式操作系统包括哪些部分？说说实时操作系统有哪些特点。

10、冯诺依曼结构的计算机由哪几部分组成？

11、说说程序，进程，线程的区别。

12、说说你怎样理解

        程序 = 数据 + 结构 + 算法

13、根据函数原型编程实现 一个数组，按从大到小的冒泡排序。

       void tibbule（int a[],int n）;//a[]为数组，n为数组长度

14、OSI有哪几层？tcp/ip包括哪几层？

15、编程实现一个双链表的节点插入和删除。

 

5。写一个数据类型：一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个

整型数。

6。嵌入式系统总是要用户对变量或寄存器进行位操作。给定一个整型变量a，写两段代码，第一个设置a

的bit 3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。

7。嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。在某工程中，要求设置一绝对地址

为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。

8。字符串倒序。

9。float a,b,c    问下列两个的值：
      (a+b)+c == (b+a)+c
      (a+b)+c == (a+c)+b

10。关键字static的作用是什么？
        关键字const有什么含意？

11。关键字volatile有什么含意?并给出三个不同的例子。
         1)一个参数既可以是const还可以是volatile吗？解释为什么。
         2) 一个指针可以是volatile 吗？解释为什么。
         3)下面的函数有什么错误：
 int square(volatile int *ptr)
 {
         return *ptr * *ptr;
 }

12。嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。在某工程中，要求设置一绝对地址

为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。

13。动态内存分配
下面的代码片段的输出是什么，为什么？
 char *ptr;
 if ((ptr = (char *)malloc(0)) == NULL)
     puts("Got a null pointer");
 else
      puts("Got a valid pointer");

14。Typedef 在C语言中频繁用以声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。

例如，思考一下下面的例子：
 #define dPS struct s *
 typedef struct s * tPS;
以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢？（如果有的话）

为什么？

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

代表事实是，产生了一个新的关键字 __interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断

服务子程序(ISR)，请评论一下这段代码的。

 __interrupt double compute_area (double radius)
 {
     double area = PI * radius * radius;
     printf("/nArea = %f", area);
     return area;
 }

16。下面的代码输出是什么，为什么？
 void foo(void)
 {
     unsigned int a = 6;
     int b = -20;
     (a+b > 6) ? puts("> 6") : puts("<= 6");
 }

17。评价下面的代码片断：
 unsigned int zero = 0;
 unsigned int compzero = 0xFFFF;
 /*1's complement of zero */

18。C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什么？
 int a = 5, b = 7, c;
 c = a+++b;

19。编写一个可重入的函数。

20。编写ISR需要注意哪些地方？

21。如何设计一个内存拷贝函数，考虑效率及强健性原则。

22。怎样理解"地址对齐","内存分配","处理器字节序"的意义，应用上有什么需要注意的地方吗？举例。
         如何测试一个处理器的字节序？

23。至少举两个例子从硬件和微码执行的角度说明CPU响应中断的过程。

24。如何实现任务调度？

25。如何避免优先级反转？

26。任务锁和终端锁之间的区别，应用上应该怎么去选择？

27。进程间通讯与同步的手段有哪些？举例说明。

4   嵌入式系统相关问题
    a)   对于整形变量A=0x12345678,请画出在little   endian及big   endian的方式下在内存中是如何存储的。
    b)   在ARM系统中，函数调用的时候，参数是通过哪种方式传递的?
    c)   中断(interrupt,如键盘中断)与异常(exception,如除零异常)有何区别? 

定:
1) 下面的测试题中, 认为所有必须的头文件都已经正确的包含了
2) 数据类型
char 一个字节 1 byte
int 两个字节 2 byte (16位系统, 认为整型是2个字节)
long int 四个字节 4 byte
float 四个字节4 byet
double 八个字节 8 byte
long double 十个字节 10 byte
pointer 两个字节 2 byte(注意, 16位系统, 地址总线只有16位)

第1题: 考查对volatile关键字的认识
#include
static jmp_buf buf;
main()
{
volatile int b;
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()
{
struct node
{
int a;
int b;
int c;
};
struct node s= { 3, 5,6 };
struct node *pt = &s;
printf("%d" , *(int*)pt);
}

这段程序的输出是:
(a) 3
(b) 5
(c) 6
(d) 7

第3题:考查递归调用
int foo ( int x , int n)　
{
int val;
val =1;

if (n>0)
{
if (n%2 == 1) val = val *x;
val = val * foo(x*x , n/2);
}
return val;
}

这段代码对x和n完成什么样的功能(操作)?
(a) x^n (x的n次幂)
(b) x*n(x与n的乘积)
(c) n^x(n的x次幂)
(d) 以上均不是

第4题:考查指针,这道题只适合于那些特别细心且对指针和数组有深入理解的人
main()
{
int a[5] = {1,2,3,4,5};
int *ptr = (int*)(&a+1);

printf("%d %d" , *(a+1), *(ptr-1));
}

这段程序的输出是:
(a) 2 2
(b) 2 1
(c) 2 5
(d) 以上均不是

第5题:考查多维数组与指针
void foo(int [][3]);
main()
{
int a [3][3]= { { 1,2,3} , { 4,5,6},{7,8,9}};
foo(a);
printf("%d" , a[2][1]);
}
void foo(int b[][3])
{
++ b;
b[1][1] =9;
}

这段程序的输出是:
(a) 8
(b) 9
(c) 7
(d)以上均不对

第6题:考查逗号表达式
main()
{
int a, b,c, d;
a=3;
b=5;
c=a,b;
d=(a,b);

printf("c=%d" ,c);
printf("d=%d" ,d);
}

这段程序的输出是:
(a) c=3 d=3
(b) c=5 d=3
(c) c=3 d=5
(d) c=5 d=5

第7题:考查指针数组
main()
{
int a[][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) 2 3 5 6
(b) 2 3 4 5
(c) 4 5 0 0
(d) 以上均不对

第8题:考查函数指针
int *f1(void)
{
int x =10;
return(&x);
}
int *f2(void)
{
int*ptr;
*ptr =10;
return ptr;
}
int *f3(void)
{
int *ptr;
ptr=(int*) malloc(sizeof(int));
return ptr;
}

上面这3个函数哪一个最可能引起指针方面的问题
(a) 只有 f3
(b) 只有f1 and f3
(c) 只有f1 and f2
(d) f1 , f2 ,f3

第9题:考查自加操作(++)
main()
{
int i=3;
int j;

j = sizeof(++i+ ++i);

printf("i=%d j=%d", i ,j);
}

这段程序的输出是:
(a) i=4 j=2
(b) i=3 j=2
(c) i=3 j=4
(d) i=3 j=6

第10题:考查形式参数, 实际参数, 指针和数组
void f1(int *, int);
void f2(int *, int);
void(*p[2]) (int *, int);
main()
{
int a;
int b;

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);
}
void f1(int* p , int q)
{
int tmp;
tmp =*p;
*p = q;
q= tmp;
}
void f2(int* p , int q)
{
int tmp;
tmp =*p;
*p = q;
q= tmp;
}

这段程序的输出是:
(a) 5 5 5 5
(b) 3 5 3 5
(c) 5 3 5 3
(d) 3 3 3 3

第11题:考查自减操作(--)
void e(int );
main()
{
int a;
a=3;
e(a);
}
void e(int n)
{
if(n>0)
{
e(--n);
printf("%d", n);
e(--n);
}
}

这段程序的输出是:
(a) 0 1 2 0
(b) 0 1 2 1
(c) 1 2 0 1
(d) 0 2 1 1

第12题:考查typedef类型定义,函数指针
typedef int (*test) ( float * , float*)
test tmp;
tmp 的类型是
(a) 函数的指针, 该函数以两个指向浮点数(float)的指针(pointer)作为参数(arguments)
Pointer to function of having two arguments that is pointer to float
(b) 整型
(c) 函数的指针, 该函数以两个指向浮点数(float)的指针(pointer)作为参数(arguments),并且函数的返回值类型是整型
Pointer to function having two argument that is pointer to float and return int
(d) 以上都不是

第13题:数组与指针的区别与联系
main()
{
char p;
char buf[10] ={ 1,2,3,4,5,6,9,8};
p = (buf+1)[5];
printf("%d" , p);
}

这段程序的输出是:
(a) 5
(b) 6
(c) 9
(d) 以上都不对

第14题: 考查指针数组的指针
void f(char**);
main()
{
char * argv[] = { "ab" ,"cd" , "ef" ,"gh", "ij" ,"kl" };
f( argv );
}
void f( char **p )
{
char* t;

t= (p+= sizeof(int))[-1];

printf( "%s" , t);
}

这段程序的输出是:
(a) ab
(b) cd
(c) ef
(d) gh

第15题:此题考查的是C的变长参数,就像标准函数库里printf()那样,这个话题一般国内大学课堂是不会讲到的,不会情有可原
#include
int ripple ( int , );
main()
{
int num;
num = ripple ( 3, 5,7);
printf( " %d" , num);
}
int ripple (int n, )
{
int i , j;
int k;
va_list p;

k= 0;
j = 1;
va_start(p, n);

for (; j{
i = va_arg(p , int);
for (; i; i &=i-1 )
++k;
}
return k;
}

这段程序的输出是:
(a) 7
(b) 6
(c) 5
(d) 3

第16题:考查静态变量的知识
int counter (int i)
{
static int count =0;
count = count +i;
return (count );
}
main()
{
int i , 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*/
Stores context information such as register values so that the lomgjmp function can return control to the statement following the one calling setjmp.Returns 0 when it is initially called.
Lonjjmp: 执行一个非局部跳转 /* setjmp.h*/
Transfers control to the statement where the call to setjmp (which initialized buf) was made. Execution continues at this point as if longjmp cannot return the value 0.A nonvolatile automatic variable might be changed by a call to longjmp.When you use setjmp and longjmp, the only automatic variables guaranteed to remain valid are those declared volatile.
Note: Test program without volatile qualifier (result may very)
更详细介绍, 请参阅 C语言的setjmp和longjmp

第2题: (a)
结构题的成员在内存中的地址是按照他们定义的位置顺序依次增长的。如果一个结构体的指针被看成 它的第一个成员的指针,那么该指针的确指向第一个成员

第3题: (a)
此题目较难.
这个程序的非递归版本
int what ( int x , int n)
{
int val;
int product;
product =1;
val =x;

while(n>0)
{
if (n%2 == 1)
product = product*val; /*如果是奇数次幂, x(val)要先乘上一次,;
偶数次幂, 最后返回时才会到这里乘以1*/
val = val* val;
n = n/2;
}
return product;
}

/* 用二元复乘策略 */
算法描述
(while n>0)
{
if next most significant binary digit of n( power) is one
then multiply accumulated product by current val,
reduce n(power) sequence by a factor of two using integer division.
get next val by multiply current value of itself
}

第4题: (c)
a的类型是一个整型数组,它有5个成员。&a的类型是一个整型数组的指针, 所以&a + 1指向的地方等同于a[6], 所以*(a+1) 等同于a[1]
ptr等同a[6], ptr-1就等同与a[5]

第5题: (b)
题目自身就给了足够的提示
b[0][0] = 4
b[1][0] = 7

第6题: (c)
考查逗号表达式,逗号表达式的优先级是很低的, 比 赋值(=)的优先级 低. 逗号表达式的值就是最后一个元素的值
逗号表达式的还有一个作用就是分割函数的参数列表..
E1, E2, ..., En
上面这个表示式的左右是,E1, E2,... En的值被分别计算出来, En计算出来的结构赋给整个逗号表达式
c=a,b; / *yields c=a* /
d=(a,b); /* d =b */

第7题: (a)
ptr是一个数组的指针, 该数组有3个int成员

第8题: (c)
f1显然有问题, 它返回一个局部变量的指针, 局部变量是保存在stack中的,退出函数后, 局部变量就销毁了, 保留其指针没有意义, 因为其指向的stack空间可能被其他变量覆盖了
f2也有问题, ptr是局部变量, 未初始化, 它的值是未知的, *ptr不知道指向哪里了, 直接给*ptr赋值可能会覆盖重要的系统变量, 这就是通常说的野指针的一种

第9题: (b)
sizeof 操作符给出其操作数需要占用的空间大小, 它是在编译时就可确定的, 所以其操作数即使是一个表达式, 也不需要在运行时进行计算.( ++i + ++ i )是不会执行的, 所以i的值还是3

第10题: (a)
很显然选a.
f1交换*p 和 q的值, f1执行完后, *p 和 q的值的确交换了, 但q的改变不会影响到b的改变, *p 实际上就是a
所以执行f1后, a=b=5
这道题考查的知识范围很广,包括typedef自定义类型,函数指针,指针数组void(*p[ 2 ]) ( int *, int);
定义了一个函数指针的数组p,p有两个指针元素. 元素是函数的指针, 函数指针指向的函数是一个带2个参数,返回void的函数, 所带的两个参数是指向整型的指针, 和整型
p[ 0 ] = f1; p[ 1 ] = f2 contain address of function .function name without parenthesis represent address of function Value and address of variable is passed to function only argument that is effected is a (address is passed). Because of call by value f1, f2 can not effect b

第11题: (a)

考查--操作和递归调用,仔细分析一下就可以了

第12题: (c)
建议不会的看看C专家编程
从左往有, 遇到括号停下来, 将第一个括号里的东西看成一个整体

第13题: (c)
考查什么时候数组就是指针.对某些类型T而言, 如果一个表达式是 T[] (T的数组), 这个表达式的值实际上就是指向该数组的第一个元素的指针.所以(buf+1)[5]实际上就是*(buf +6)或者buf[6]

第14题: (b)

sizeof(int)的值是2,所以p+=sizeof(int) 指向 argv[2],这点估计大家都没有什么疑问
(p+=sizeof(int))[-1] 指向 argv[1],能理解吗, 因为(p+=sizeof(int))[-1] 就相当于 (p+=2)[-1] ,也就是(p+2-1)

第15题: (c)
在C编译器通常提供了一系列处理可变参数的宏, 以屏蔽不同的硬件平台造成的差异, 增加程序的可移植性。这些宏包括va_start、va_arg和va_end等。
采用ANSI标准形式时, 参数个数可变的函数的原型声明是：type funcname(type para1, type para2, ...)
这种形式至少需要一个普通的形式参数, 后面的省略号不表示省略, 而是函数原型的一部分。type是函数返回值和形式参数的类型。
不同的编译器, 对这个可变长参数的实现不一样 , gcc4.x中是内置函数.
关于可变长参数,可参阅
http://www.upsdn.net/html/2004-11/26.html
http://www.upsdn.net/html/2004-11/24.html
程序分析
va_list p; /*定义一个变量 ,保存 函数参数列表 的指针*/
va_start( p , n); /*用va_start宏 初始化变量p, va_start宏的第2个参数n, 是一个固定的参数, 必须是我们自己定义的
变长函数的最后一个入栈的参数也就是调用的时候参数列表里的第1个参数*/
for (; j{
i = va_arg( p , int); /*va_arg取出当前的参数,并认为取出的参数是一个整数(int) */
for (; i; i &=i-1 ) /*判断取出的i是否为0*/
++k; /* 如果i不为0, k自加, i与i-1进行与逻辑运算, 直到i 为0
这是一个技巧, 下面会谈到它的功能*/
}

当我们调用ripple函数时, 传递给ripple函数的 参数列表的第一个参数n的值是3. va_start 初始化p士气指向第一个未命名的参数(n是有名字的参数) ,也就是 is 5 (第一个). 每次对 va_arg的调用, 都将返回一个参数, 并且把 p 指向下一个参数. va_arg 用一个类型名来决定返回的参数是何种类型,以及在 var_arg的内部实现中决定移动多大的距离才到达下一个参数
(; i; i&=i-1) k++ /* 计算i有多少bit被置1 */
5用二进制表示是 (101) 2
7用二进制表示 (111) 3
所以 k 返回 5(2+3),也即本题应该选c
举个例子, 就很好理解了
令 i= 9 = 1001
i-1 = 1000
(i-1) +1 = i
1000
+1
1001
因为i与i-1的最右边的那位(最低位) 肯定是不同, 如果i1,i-1肯定是0, 反之亦然. i & i-1 这个运算, 在二相补的数字系统中, 将会消除最右边的1位

第16题: (b)
答案是 (b)
相传高斯小学一年级的时候就会做这类等比数列的题目了.这道题考查的是静态变量的知识,当每次调用完函数之后,静态变量的值不会丢失,这与栈中的临时局部变量明显不同的地方.
所以,第一次调用counter(0)之后,count =0
第二次调用 counter(1)后 count = 0+1;
第三次调用 counter(2) count = 1+2; /* count = count +i */
第四次调用 counter(3) count = 3+3;
第五次调用 counter(4) count = 6+4;
第六次调用 counter(5) count = 10+5;

 

1. 用宏定义写出swap（x，y）
2.数组a[N]，存放了1至N-1个数，其中某个数重复一次。写一个函数，找出被重复的数字.时间复杂度必须为o（N）函数原型：
int do_dup(int a[],int N)
3 一语句实现x是否为2的若干次幂的判断
4.unsigned int intvert(unsigned int x,int p,int n)实现对x的进行转换,p为起始转化位,n为需要转换的长度,假设起始点在右边.如x=0b0001 0001,p=4,n=3转换后x=0b0110 0001.

Ros:
1, 确实可以有两种方法

#define SWAP(x,y) x+=y; y=x-y; x=x-y

#define SWAP(x,y) x^=y; y^=x; x^=y

第一中较通用，同类型都可以。第二种，以为采用位操作符，而float, double型的位操作是不能通过编译器的。但我始终觉得，不管是用什么数据类型，在内存中最终是二进制，这样第二种中逻辑上应该是能行的通的，只是不能通过编译。

2,
int do_dup(int a[], int N){
char *p_count,i;
p_count = (*char)malloc(N);//时间复杂度是o(N)但占用的空间多了点
for(i=0;i<N;i++){
    *(p_count+a[i])++;
    if(*(p_count+a[i]) == 2){
    return a[i];
    }
}

free(p_count);
}
当然，有人用hash表做的，可惜我没hash过。不过思路也没什么差异

3,Key: 2的n次幂在二进制上有共性，都是只有一个bit为1，其余全为0；
  (x&(x-1))?0:1 //1 for true, 0 for false

4,转换，其实就是每位都与1做异或的结果

unsigned int intvert(unsigned int x,int p,int n){

return x^=(((1<

}