嵌入式软件开发--口试总结

（1）公司简介：做打印机设备、项目涉及到操纵系统
（2）口试内容：笔试题+技术口试

1. //32位单片机c语言程序
3. typedef struct{
5.         int a;
6.         char b;
7.         char c;
9. }str1;
14. typedef struct{
16.         char a;
17.         int b;
18.         char c;
20. }str2;
23. void function(char src_buf[100])
24. {
26.         char str[]="hello world";
27.         char buf[100];
28.         char *p=str;
29.         int n=10;
30.         char k=10;
35.         printf("1:sizeof(str)=%d\r\n",sizeof(str));
36.         printf("2:strlen(str)=%d\r\n",strlen(str));
37.         strcpy(buf,str);
38.         printf("3:sizeof(buf)=%d\r\n",sizeof(buf));
39.         printf("4:strlen(buf)=%d\r\n",strlen(buf));
40.         printf("5:sizeof(p)=%d\r\n",sizeof(p));
41.         printf("6:sizeof(n)=%d\r\n",sizeof(n));
42.         printf("7:sizeof(k)=%d\r\n",sizeof(k));
43.         printf("8:sizeof(src_buf)=%d\r\n",sizeof(src_buf));
44.         printf("9:sizeof(str1)=%d\r\n",sizeof(str1));
45.         printf("10:sizeof(str2)=%d\r\n",sizeof(str2));
48. }
52. void main()
53. {
54.         char ram_buf[100];
56.        
57.         function(ram_buf[100]);
60. }

复制代码

1.sizeof(str):盘算字符串巨细，要包罗停止符“\0”；好比“空格”、“-”、“~”也算字符
2.strlen(str):盘算字符串长度，不包罗停止符“\0”
3.sizeof(buf):buf是长度为100的数组
4.strlen(buf):str内容复制给了buf，以是buf内容是“hello world\0”。只盘算长度还是11
5.p是字符指针char *,在32为系统中占用4字节
6.n 为char类型，占用1字节
7.k 为int类型，占用4字节
8.src_buf是char类型的数组指针，在32为系统中占用4字节
9.结构体对齐原则
第一个成员在于结构体变量偏移量为0的地点处

结构体总巨细为最大数的整数倍
好比str1
第1个成员是int，占用4字节
第2个成员char，占用1字节
第3个成员char，占用1字节
对齐后：4+4=8

好比str2
第1个成员是char，占用4字节,由于下一个是int
第2个成员int，占用4字节，
第3个成员char，占用4字节，补全字节，要整数倍
对齐后：4+4+4=12

2.下面两个tor 循环，功能完全相同，即在运行过程中，条件condition 不会发生变化,请判断这两个for循环的优缺点。(10分)
// 第一个
for (i=0; i<N; i++){
if(condition){
DoSomething();
} else {
DoOtherthing();
}
/ /第二个
if(condition){
for (i=0; i<N; i++){DoSomething();
} else {
for (i=0; i<N; i++){DoOtherthing();
}
题目1:这两个 for 循环，哪个的时间效率更高?即哪个运行得更快?写出时间效率高的缘故起因。(5分)
第2个循环
优点：条件判断只执行一次；循环体内无条件分支，淘汰指令
缺点：重复编写两个相似循环体，占用空间大

题目 2:这两个for 循环，哪个的空间效率高?即哪个占用较少的步伐存储空间?写出空间效率高的缘故起因。(5分)
第1个循环
优点：代码简洁，无冗余循环体
缺点：每次循环都要执行条件判断
3.

1. void main()
2. {
4.         char a=0x06;
5.         char b=0x03;
6.        
9.         printf("a&&b=%d\r\n",a&&b);
10.        
11.         printf("a&b=%d\r\n",a&b);
12.        
13.         printf("a||b=%d\r\n",a||b);
14.        
15.         printf("a|b=%d\r\n",a|b);
16.        
17.         printf("a^b=%d\r\n",a^b);
19. }

复制代码

注意区别：
|（按位或运算符）：对两个操纵数的对应二进制位进行逻辑或运算。只要对应的两个二进制位中有一个为 1，则该位的效果为 1；只有当两个二进制位都为 0 时，效果才为 0。
&（按位与运算符）：对两个操纵数的对应二进制位进行逻辑与运算。只有当对应的两个二进制位都为 1 时，该位的效果才为 1；否则效果为 0。

&&（逻辑与运算符）：对两个操纵数进行逻辑与运算。只有当两个操纵数都为真（非 0）时，效果才为真（1）；只要有一个操纵数为假（0），效果就为假（0）。并且 && 具有短路特性，即如果第一个操纵数为假，则不会再盘算第二个操纵数。
||（逻辑或运算符）：对两个操纵数进行逻辑或运算。只要有一个操纵数为真（非 0），效果就为真（1）；只有当两个操纵数都为假（0）时，效果才为假（0）。|| 也具有短路特性，即如果第一个操纵数为真，则不会再盘算第二个操纵数
//-----------------------------------------------------------------------------------------------------
以是效果为

4.要求编写strcpy()函数原型
(1)不调用C++/C的字符串库函数,请编写函数 strcpy
char *strcpy(char *strDest, const char *strSrc)
{
        if(strDest == NULL || strSrc == NULL)return;
        Char *ret = strDest;
        While ((*strDest++ = *strSrc++) != ‘\0’);
        Return ret;
}
(2)strcpy能把strSrc的内容复制到strDest,为什么还要char * 类型的返回值?
为了实现连续赋值操纵,如:
Int strcpy(str1, strcpy(str2, str3));

5.

二：
1.

• %d ：用于输出十进制整数。
  
• %u：用于输出无符号十进制整数。
  
• %f：用于输出浮点数。
  
• %s：用于输出字符串。
  
• %c：用于输出字符。
  
• %p：用于输出指针。
  

(1)char：1 字节
(2)short：2 字节  相称与short int
(3)int：4 字节
(4)long：4 字节（32位机），8 字节（64位机） 相称于long int
(5)long long：8 字节
(6)float：4 字节
(7)double：8 字节

1. void main()
2. {
4.         char a,a1,a2,a3,a4;
5.         int b,b1,b2,b3;
6.         short int  c;
7.         long int d;
8. //        long long int e;
9.         char *f;
10.         int *g;
11.         short int *h;
12.         long int *i;
13. //        long long int *j;
15.     char k[20]="98765432";
16.        
18.         b1=3;
19.         b2=0;
20.         b3=6;
22.         f=&k[2];
23.        
24.         printf("f=%p\r\n",f);
25.         printf("f=%c\r\n",*f);
27.         //-----++f  使用变量前自增----------
28.         //-----f++  使用变量后自增----------
29.        
31.         /*
32.                 1.如果 *和++/--都在指针变量的左边，结合方向为从右到左；
33.                 2.如果 *和++/--分别在指针变量的左边/右边，结合方向为从左到右；
34.                 3.有括号的先执行括号的表达式，然后在执行规律 1 或者规律 2；
36.    */
37.        
39.         a1=(*f)++;  //
41.     printf("f1=%p\r\n",f);   //f1地址=f地址=0019FEE6
42.         printf("a1=%c\r\n",a1); //*f等于7，所以a1=7;
43.         //printf("*f=%c\r\n",*f); //使用后自增,所以*f等于8
45.         a2=*f++;  //等于a2=(*f)++,先计算*f,f地址自增1
47.         printf("f2=%p\r\n",f);  //地址0019FEE7
48.         printf("a2=%c\r\n",a2);//*f等于8，所以a2=8
49.         printf("*f=%c\r\n",*f);  //取地址0019FEE7的值，*f等于6
50.        
52.         a3=*++f;  //等于*(++f)，f地址自增1,再计算*(f++)
54.         printf("f3=%p\r\n",f); //地址0019FEE8
55.         printf("a3=%c\r\n",a3);//取地址0019FEE8的值，所以a3=5
57.         a4=*(f++); //f地址自增1,再计算*f
59.         printf("f4=%p\r\n",f); //地址0019FEE9
60.         printf("a4=%c\r\n",a4);//取地址0019FEE8的值，所以a4=5
63.         printf("out1=%d\r\n",sizeof(a));
64.         printf("out2=%d\r\n",sizeof(b));
65.         printf("out3=%d\r\n",sizeof(c));
66.         printf("out4=%d\r\n",sizeof(d));
67. //        printf("out5=%d\r\n",sizeof(e));
68.         printf("out6=%d\r\n",sizeof(f));
69.         printf("out7=%d\r\n",sizeof(g));
70.         printf("out8=%d\r\n",sizeof(h));
71.         printf("out9=%d\r\n",sizeof(i));
72. //        printf("out10=%d\r\n",sizeof(j));
74.         printf("out11=%d\r\n",sizeof(k));
75.     printf("out12=%d\r\n",strlen(k));
77.         printf("out13=%d\r\n",sizeof("adcdefg"));
78.         printf("out14=%d\r\n",strlen("adcdefg"));
80.         printf("out15=%c\r\n",a1);
81.         printf("out16=%c\r\n",a2);
82.         printf("out17=%c\r\n",a3);
83.         printf("out18=%c\r\n",a4);
87. }

复制代码

2.#ifdef #endif作用
防止头文件重复包罗‌
条件编译‌：可以根据差异的编译环境或条件选择性地编译代码段，便于调试和功能开关
3.const作用

• 界说常量‌：利用const可以界说一个常量值，确保该值在初始化后不会被修改。这有助于防止步伐中出现意外的数据变更，进步代码的可读性和安全性。
  
• ‌进步代码可读性‌：当看到用const界说的变量时，可以立即知道这个变量的值是不会改变的，这使得代码更易读、易维护。
  
• ‌优化性能‌：在某些编程语言中，编译器可以利用const变量的不变性进行优化，从而进步步伐的运行效率。
  

4.有关内存的思考题
（1）、

1. void GetMemory(char *p)
2. {
3.    p = (char *)malloc(100);
4. }
5. void Test(void)
6. {
7.     char *str = NULL;
8.     GetMemory(str);
9.     strcpy(str, "hello world");
10.     printf(str);
11. }

复制代码

请问运行Test 函数会有什么样的效果？
答：步伐崩溃。
由于GetMemory 并不能传递动态内存，
Test 函数中的 str 一直都是 NULL。
strcpy(str, "hello world");将使步伐崩
溃。
（2）、

1. char *GetMemory(void)
2. {
3.     char p[] = "hello world";
4.     return p;
5. }
6. void Test(void)
7. {
8.     char *str = NULL;
9.     str = GetMemory();
10.     printf(str);
11. }

复制代码

请问运行Test 函数会有什么样的效果？
答：大概是乱码。
由于GetMemory 返回的是指向“栈内存”
的指针，该指针的地点不是 NULL，但其原
现的内容已经被清除，新内容不可知。
（3）、

1. void GetMemory2(char **p, int num)
2. {
3.     *p = (char *)malloc(num);
4. }
5. void Test(void)
6. {
7.     char *str = NULL;
8.     GetMemory(&str, 100);
9.     strcpy(str, "hello");
10.     printf(str);
11. }

复制代码

请问运行Test 函数会有什么样的效果？
答：（1）能够输出hello；（2）内存走漏
（4）、

1. void Test(void)
2. {
3.     char *str = (char *) malloc(100);
4.     strcpy(str, “hello”);
5.     free(str);
6.     if(str != NULL)
7.     {
8.         strcpy(str, “world”);
9.         printf(str);
10.     }
11. }

复制代码

请问运行Test 函数会有什么样的效果？
答：篡改动态内存区的内容，后果难以预
料，非常危险。
由于free(str);之后，str 成为野指针，
if(str != NULL)语句不起作用。
其他：为啥离职？项目难点？怎么分析需求？

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。