嵌入式面试题（转）

1. 1. 输出什么？  
2. int a = (1,2);  
3. printf("a=%d\n",a);  
4. 答：a=2,逗号表达式的赋值  
5. 2. struct value {  
6.     char a[3];  
7.     short b;  
8. };  
9. struct value temp;  
10. printf("sizeof(temp) is %d\n", sizeof(temp));  
11. 答：sizeof(temp) is 6  
12. 3.编写程序交换a,b的值（使用二种方法）  
13. void swap(int *a, int *b)  
14. {  
15.     int temp;  
16.     temp = *a;  
17.     *a = *b;  
18.     *b = temp;  
19. }  
20.   
21. void swap(int *a, int *b)  
22. {  
23.     *a = *a + *b;  
24.     *b = *a - *b;  
25.     *a = *a - *b;  
26. }  
27.   
28. 4. 说明int *p[5]和int(*p)[5]的区别  
29. 答：int *p[5]是指针数组，数组里存储的是指针  
30. (*p)[5]是数组指针，指向一个含有5个数的数组  
31. 5. 编写函数实现链表的创建，节点的插入和删除  
32. typedef struct node  
33. {  
34.     int num;  
35.     struct node *next;  
36. }Node;  
37.   
38. Node *create()  
39. {  
40.     Node *p, *head;  
41.     int n;  
42.     head = (Node *)malloc(sizeof(Node));  
43.     head->next = NULL;  
44.     scanf("%d", &n);  
45.       
46.     while(n > 0) {  
47.         p = (Node *)malloc(sizeof(Node));  
48.         p->num = n;  
49.         p->next = head->next;  
50.         head->next = p;  
51.         scanf("%d", &n);  
52.     }  
53.       
54.     return head;  
55. }  
56.   
57. Node *insert(Node *head, int pos, int num)  
58. {  
59.     Node *p, *pre;  
60.     int i=1;  
61.     pre = head;  
62.     while(pre->next && i < pos)  
63.     {  
64.         pre = pre->next;  
65.         i++;  
66.     }  
67.       
68.     p = (Node *)malloc(sizeof(Node));  
69.     p->num = num;  
70.     p->next = pre->next;  
71.     pre->next = p;  
72.       
73.     return head;  
74. }  
75.   
76. Node *delete(Node *head, int num)  
77. {  
78.     Node *p, *pre;  
79.     p = head->next;  
80.       
81.     while(p->num != num) {  
82.         pre = p;  
83.         p = p->next;  
84.     }  
85.       
86.     if (p->num == num) {  
87.         pre->next = p->next;  
88.         free(p);  
89.     }  
90.       
91.     return head;  
92. }  
93.   
94. 6. 说明如下两片代码的区别  
95. char *p = "love linux";  
96. char p[] = "love linux";  
97. 答：*p中的p是一个指针，指向一片只读的字符串  
98. p[] 是一个数组，该数组被初始化  
99.   
100. 7.用C语言实现一相n!函数（要求用递归实现）  
101. long fact(int n)  
102. {  
103.     if (n==0 || n==1) {  
104.         return 1;  
105.     }  
106.     if(n > 1) {  
107.         return n*fact(n-1);  
108.     }  
109. }  
110.   
111. 8. char c;  
112.     char b[20] = "I love Linux";  
113.     c = 'I'与C=“I” 有什么区别，字符串b在内存占几个字节  
114. 答：c = 'I'是一个字符，c = "I" 是一个字符串，从对数组b的定义  
115. 可知，b在内存中占有20个字节（与它进行初始化的字符串长度无关）  
116. 9. 实现自己的mystrcat()函数  
117. char *mystrcat(char *dst, const char *src)  
118. {  
119.     char *cp;  
120.     cp = dst;  
121.     while (*cp)  
122.         cp ++;//指针指向字符串尾  
123.     while(*cp++ = *src++);//每次循环最后一次拷贝了"\0"  
124.     return dst;  
125. }  
126.   
127. 10. char str[20];  
128.     scanf("%s", str);  
129.     printf("%s", str);  
130. 如果输入I love linux回车，结果输出什么？为什么？  
131. 答：输出I，因为scanf输入字符串不能有空格  
132. 11. 已知两个整型数组均为升序排列，将两个数组合并，且合并后仍按升序排序  
133.   
134. //m为数组a的长度，n为数组b的长度，c是指向新开辟的数组  
135. void combin(int *a, int *b, int *c, int m, int n)  
136. {  
137.     int *p1, *p2, *p3;  
138.     for(p1 = a, p2 = b, p3 = c; p1 < a+m && p2 < b+n;)  
139.     {  
140.         if (*p1 < *p2)  
141.             *p3++ = *p1++;  
142.         else  
143.             *p3++ = *p2++;  
144.     }     
145.       
146.     while(p1 < a+m) *p3++ = *p1++;  
147.     while(p2 < b+n) *p3++ = *p2++;  
148.       
149. }  
150. [csharp]  view plain copy

     1. 1.用指令#define 声明一个常数，用于表明1年中用多少秒（忽略闰年问题）  
     2. 答：#define SECOND_PER_YEAR  (60*60*24*365)UL  
     3. 2.写一个标准的宏MIN,这个宏输入两个参数，并返回较小的一个  
     4. 答：#define MIN(a,b) ((a) > (b) ? (a) : (b))  
     5. 3.嵌入式系统中经常用到的无限循环，用C写死循环  
     6. while(1)  
     7. {  
     8.   
     9. }  
     10.   
     11. 4.数据声明，用变量a给出下面的定义  
     12. 1)一个整型数  
     13. int a;  
     14. 2)一个指向整型数的指针  
     15. int *a;  
     16. 3)一个指向指针的指针，它指向的指针是指向一个整形数  
     17. int **a;  
     18. 4)一个有10个整形数的数组  
     19. int a[10];  
     20. 5)一个有10个指针的数组，该指针是指向一个整形数的  
     21. int *a[10];  
     22. 6)一个指向有10个整形数组的指针  
     23. int (*a)[10];  
     24. 7)一个指向函数的指针，该函数有一个整形参数并返回一个整形数  
     25. int (*a)(int);  
     26. 8)一个有10个指针的数组，该指针指向一个函数，该函数有一个整形参数并返回一个整形数  
     27. int (*a[10])(int);  
     28.   
     29. 5.关键字static的作用  
     30. 答：1)在函数体，一个被声明为静态的变量在这一函数被调用的过程中维持其值不变  
     31. int fun()  
     32. {  
     33.     static int a = 5;//在5的基础上累加  
     34.     a ++;  
     35.     return a;  
     36. }  
     37. 2)在模块内（但在函数体外）一个被声明为静态的变量可以被模块内所有函数访问但不能被模块外的  
     38. 其它函数访问。  
     39. 3)在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用  
     40.   
     41. 6.关键字const有什么含意   
     42. 答：const可以保护不希望被改变的变量参数  
     43. const int a;  
     44. a是一个常整形（把类型去掉，保护最近的那个）  
     45. const int *a;（*a不可修改，a可以修改）a是一个指向常整形的指针  
     46. int *const a; (a不可修改，*a可以修改) a是一个指向整形的常指针  
     47. int const *a const;(*a和a都不可以修改)a是一个指向常整形的常指针  
     48.   
     49. 7.关键字volatile有什么含意，并给出三个不同的例子  
     50. 答:防止变量被优化，优化器在处理被volatile修饰的变量时，会重新  
     51. 读取这个变量的值，而不是使用保存在寄存器里的备份（可能被意想不到的改变）  
     52. 1)并行设备的硬件寄存器（状态寄存器）  
     53. 2)一个中断服务子程序中会访问到的非自动变量  
     54. 3)多线程应用中被几个任务共享的变量  
     55.   
     56. 8.一个参数可以是const还可以是volatile吗  
     57. 答：可以，只读状态寄存器，它是volatile因为它可能被意想不到地改变，  
     58. 它是const因为程序不应该试图去修改它  
     59.   
     60. 9. int square(volatile int *ptr)  
     61. {  
     62.     return *ptr * *ptr;  
     63. }函数有什么错误  
     64. 答：*ptr的值可能被意想不到的改变，返回值不是期望的平方值  
     65. 改：  
     66. long square(volatile int *ptr)  
     67. {  
     68.     int a;  
     69.     a = *ptr;  
     70.     return a * a;  
     71. }  
     72.   
     73. 10. 位操作  
     74. 给定一个整形变量a,写两片代码，第一个设置a的bit 3,第二个清除a的 bit 3  
     75. 在以上两个操作中，要保持其它位不变  
     76. 答：#define BIT3 (0x1 << 3)  
     77.     static int a;  
     78.     void set_bit3(void)  
     79.     {  
     80.          a | = BIT3;  
     81.     }  
     82.       
     83.     void clear_bit3(void)  
     84.     {  
     85.         a &= ~BIT3;  
     86.     }  
     87.       
     88. 11.访问固定的内存位置  
     89. 嵌入式系统经常要求程序员去访问特定的内存位置的点，要求设置一绝对地址为0x6780的整型  
     90. 变量的值为0x5566  
     91. 答: int *p;  
     92.     p = (int *)0x6780;  
     93.     *p = 0x5566;  
     94.     (访问绝对地址把一个整型，强制转换成一个指针是合法的)  
     95.   
     96. 12.中断服务程序ISR(请评论)  
     97.   
     98. __interrupt double compute_area(doble radius)  
     99. {  
     100.     double area = PI*radius*radius;  
     101.     printf("\n AREA = %f", area);  
     102.     return area;  
     103. }  
     104. 答：1)ISR不能返回值  
     105.     2)ISR不能传递参数  
     106.     3)有些编译器不允许在ISR中做浮点运算  
     107.     4)printf有重入性问题  
     108. 13. 下面代码输出什么？为什么？  
     109. void foo(void)  
     110. {  
     111.     unsigned int a = 6;  
     112.     int b = -20;  
     113.     (a+b > 6) ? puts("> 6") : puts("<=6");  
     114. }  
     115. 答：输出>6,因为表达式中有符号和无符号类型时，所有操作  
     116. 数都自动转换为无符号型  
     117.   
     118. 14.评价下面的代码  
     119. unsigned int zero = 0;  
     120. unsigned int compzero = 0xFFFF;  
     121. 答：对一个int 型不是16位的处理器不正确  
     122. unsigned int compzero = ~0;  
     [csharp]  view plain copy

     1. 1.局部变量能否和全局变量重名？  
     2. 答：能，局部会屏蔽全局  
     3. 2.如何引用一个已经定义过的全局变量  
     4. 答：extern  
     5. 3.全局变量可不可以定义在可被多个.c文件包含的头文件中？  
     6. 答：可以，在不同的c文件中以static形式来声明同名全局变量  
     7. 4.语句for(; 1; )有什么问题？它是什么意思  
     8. 答：死循环  
     9. 5.程序中，全局变量、静态变量存在于(全局数据区)  
     10. 局部变量存在于（堆栈中），动态申请数据存在于（堆）中  
     11. 6.队列和栈有什么区别？  
     12. 答：队列先进先出，栈后进先出  
     13. 7.对于一个频繁使用的短小函数，在C语言中用什么实现，C++中呢？  
     14. 答：C用宏定义，C++用inline  
     15. 8.确定模块的功能和模块的接口是在软件设计的那个时期完成的  
     16. 答：概要设计  
     17. 9.引用和指针有什么区别？  
     18. 答：1)引用必须被初始化，指针不必  
     19.     2)引用初始化以后不能被改变，指针可以改变所指的对象   
     20.     3)不存在指向空值的引用，存在指向空值的指针  
     21. 10.RTOS的基本特性  
     22. 答：实时性与可靠性  
     23. 11.什么是平衡二叉树？  
     24. 答：左右子树都是平衡二叉树，且左右子树的深度差的绝对值小于1  
     25. 12.堆栈溢出一般是由什么原因导致的？  
     26. 答：没有回收垃圾资源  
     27. 13.构造函数不能声明为虚函数  
     28. 14.Internet采用哪种网络协议？该协议主要层次结构？  
     29. 答：TCP/IP,应用层、传输层、网络层、物理层（数据链路层）  
     30. 15.Internet物理地址和IP地址转换采用什么协议？  
     31. 答：ARP(地址解析协议)  
     32. 16.请定义一个宏，比较两个数a,b的大小，不能使用大于，小于,if语句  
     33. 答：#define MAX(a,b)  (a/b) ? a:b  
     34. 17.写一个病毒  
     35. while(1)  
     36. {  
     37.     int *p = new int[100000000];  
     38. }  
     39.   
     40. 18.求一个字符串的长度，两种方法  
     41.   
     42. int mystrlen(char *s)  
     43. {  
     44.     int len = 0;  
     45.     while(*s++)  
     46.         len++;  
     47.     return len;  
     48. }  
     49.   
     50. int mystrlen(char *s)  
     51. {  
     52.     char *str = s;  
     53.     while(*str)  
     54.         str++;  
     55.     return (str - s);  
     56. }  
     57.   
     58. 19.字符串复制  
     59. char *mystrcpy(char *dst, const char *src)  
     60. {  
     61.     char *ret = dst;  
     62.     while(*ret++ = *src++);  
     63.     return dst;  
     64. }  
     65.   
     66. 20.内存复制  
     67. void *mymemcpy(void *_dst, const void *_src, unsigned len)  
     68. {  
     69.     unsigned char *dst= _dst;  
     70.     const unsigned char  *src = _src;  
     71.     while(len-- > 0)  
     72.     {  
     73.         *dst++ = *src++;  
     74.     }  
     75.     return _dst;  
     76. }