嵌入式经典面试

嵌入式工程师的经典面试题

2018嵌入式底层面试

嵌入式软件工程师经典面试题

题一，堆和栈的区别是？
题二，Volatile与Register的区别是？
题三，ARM里的大端格式和小端格式分别是什么意思？

题一答案：
（1）存储内容不同
栈：在函数调用时，栈中存放的是函数中（最底下是函数调用后的下一条指令）的各个参数（局部变量）。
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员分配。
（2）管理方式上不同
栈：由系统自动分配并释放空间。 例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间，当对应的生存周期结束后栈空间被自动释放。
堆：需要程序员指定大小手动申请和手动释放，在C语言中使用malloc函数申请，使用free函数释放。
（3）空间大小不同
栈：获取空间较小。在Windows下一般大小是1M或2M，当剩余栈空间不足时，分配失败overflow。
堆：获得空间根据系统的有效虚拟内存有关，比较灵活、大。
（4）能否产生碎片不同
栈：不会产生碎片，空间连续。
堆：采用的是链表的存储方式，会产生碎片。
（5）生长方向不同
栈： 向低地址扩展的数据结构，是一块连续的内存区域。
堆： 向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表空闲内存地址来存储的，自然不连续，而链表的遍历方向是由低地址向高地址。
（6）分配方式不同
栈：有2种分配方式：静态分配和动态分配，静态由编译器完成，例如局部变量；动态由malloc函数实现，由编译器进行释放。
堆： 都是动态分配的，没有静态分配的堆。
（7）分配效率不同
栈：由系统自动分配，速度较快。但程序员无法控制。
堆：由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便。

题二答案：
a.volatile
1.告诉compiler不能做任何优化
2.表示用volatile定义的变量会在程序外被改变,每次都必须从内存中读取，而不能把他放在cache或寄存器中重复使用。

volatile是易变的，不稳定的意思，volatile是关键字，是一种类型修饰符，用它修饰的变量表示可以被某些编译器未知的因素更改，比如操作系统、硬件或者其他线程等，遇到这个关键字声明的变量，编译器对访问该变量的代码不在进行优化，从而可以提供对特殊地址的稳定访问。那么什么是编译器优化呢？

为了提高运行效率，攻城师们费尽心机地把代码优化，优化程序运行时存取速度。一般，分为硬件优化和软件优化。硬件优化，流水线工作，详细可以参考《计算机组成原理》。软件优化，一部分是程序猿们做的代码优化（前提你得有优化的思路和能力），还有一部分就是我们的编译器优化了。

现代的编译器经过那么多年的发展，已经比较成熟，它会把多余的变量忽略掉，让代码的运行效率更高。默认情况下，编译器都会对代码进行优化，会把一些变量在寄存器里存取，而不是在内存里存取，如此一来，CPU在自己家里拿东西当然比从内存那里拿东西要快得多。举个小栗子：
int i = 5;
int a = i;
……
int b = i;

编译器发现两次从i读数据的代码之间，并没有对i进行过操作，它会自动把上次读的数据放在b中，而不是重新从i里面读取。

而volatile关键字告诉编译器该变量是随时可能发生变化的，每次使用它的时候必须从内存中取出它的值，因而编译器生成的汇编代码会从原内存地址中读取数据使用，而不是从寄存器或者缓存中读取，从而保证了对特殊地址的稳定访问。

简言之，状态要经常变化的，为了防止我们编译优化而导致的存取的数据不同步的问题，这时我们就需要用到volatile。那具体到什么场景下需要用到volatile关键字呢？

1、并行设备的硬件寄存器（如：状态寄存器）；
2、一个中断服务子程序中会访问到的非自动变量()；
3、多线程应用中被几个任务共享的变量；
上面提到了非自动变量，这里进一步对几种变量做一番解释：

自动变量：是在函数内部定义和使用的变量，它是局部变量。
非自动变量：有两种，一种是全局变量，一种是静态变量。
全局变量：在函数外面定义的变量，只能定义一次，不能有重复的定义，不然就会发生错误，而其他的文件要想使用这个变量，需要extern来声明这个变量（也可省略，因为默认就是extern），这个声明叫做引用声明。

若不想被其他文件访问，则用static关键字声明为静态变量。静态变量与自动变量的本质区别是，静态变量并不像自动变量那样使用堆栈机制来使用内存。

而是为静态变量分配固定的内存，在程序运行的整个过程中，它都会被保持，而不会被销毁。这就是说静态变量的持续性是程序运行的整个周期。这有利于我们共享一些数据。

如果静态变量在函数内部定义，则它的作用域就是在这个函数内部，仅在这个函数内部使用它才有效，但是它不同于自动变量，自动变量离开函数后就会被销毁，而静态变量不会被销毁。他在函数的整个运行周期内都会存在。
转载什么是代码区、常量区、静态区（全局区）、堆区、栈区？

b. register
这个关键字请求编译器尽可能的将变量存在CPU内部寄存器中，而不是通过内存寻址访问，以提高效率。注意是尽可能，不是绝对。你想想，一个CPU 的寄存器也就那么几个或几十个，你要是定义了很多很多register 变量，它累死也可能不能全部把这些变量放入寄存器吧。

题三答案：
当前的存储器，多以byte为访问的最小单元，当一个逻辑上的地址必须分割为物理上的若干单元时就存在了先放谁后放谁的问题, 于是端(endian)的问题应运而生了, 对于不同的存储方法, 就有大端(big-endian)和小端(little- endian)两个描述。
字节排序按分为大端和小端，概念如下
大端(big endian): 低地址存放高有效字节
小端(little endian): 低字节存放低有效字节

现在主流的CPU, intel系列的是采用的little endian的格式存放数据，而motorola系列的CPU采用的是big endian，ARM则同时支持 big和little。
举个例子
int a = 0x12345678;
a是四字节的int类型变量，需要占四个字节空间，假设变量a的首地址是0x2000,那么数据存储在地址中的格式如下：
这里写图片描述

char b=a;
输出b=78则为小端，b=12则为大段模式。

题一:
简述memcpy和strcpy的区别？
题二：
信号量与互斥锁的区别？
题三：
简述程序编译的过程？

题一答案：
（1）、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。
（2）、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符”\0”才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。
（3）、用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy

题二答案：
（1）、互斥量用于线程的互斥，信号量用于线程的同步。互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。
同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源。
（2）、互斥量值只能为0/1，信号量值可以为非负整数。也就是说，一个互斥量只能用于一个资源的互斥访问，它不能实现多个资源的多线程互斥问题。信号量可以实现多个同类资源的多线程互斥和同步。当信号量为单值信号量是，也可以完成一个资源的互斥访问。
（3）、互斥量的加锁和解锁必须由同一线程分别对应使用，信号量可以由一个线程释放，另一个线程得到。
题三答案：
预处理：预处理相当于根据预处理命令组装成新的C程序，不过常以i为扩展名。
编译： 将得到的i文件翻译成汇编代码.s文件。
汇编：将汇编文件翻译成机器指令，并打包成可重定位目标程序的O文件。该文件是二进制文件。
链接：将引用的其他O文件并入到我们程序所在的o文件中，处理得到最终的可执行文件。

进程是操作系统分配资源的最小单元，线程是操作系统调度的最小单元
一个程序至少有一个进程，一个进程至少有一个线程。

################################
char *p=“abcde”;
这种方式是定义了一个字符型指针，指向常量字符串"abcde"
char p[]=“abcde”;
这种方式是定义了一个字符数组，其长度自动设置其等于"abcde"，
所以第一种指向了常量区（申请了空间在常量区），存放了字符串；（2）在字符串尾加上了“\0”。（3）返回地址，无法修改。
第二种定义了普通的数组变量，数据就存储在堆栈空间，堆栈空间的内容是可以修改的，就不会出现运行时错误，可以修改。

字符数组可以在定义时整体赋值，不能再赋值语句中整体赋值
1、定义的时候直接用字符串赋值
char a[10]=“hello”;
注意：不能先定义再给它赋值，如：
char a[10];
a=“hello”;
这是错误的，a虽然是指针，但是它已经指向在堆栈中分配的10个字符空间，现在这个情况a又指向数据区中的hello常量，这里的指针a出现混乱，不允许！
2、对数组中字符逐个赋值
char a[10]={‘h’,‘e’,‘l’,‘l’,‘o’};
3、利用strcpy
char a[10];
strcpy(a, “hello”);

char *a=“abc”;
char *b=“abc”;
a的内容修改后，b的内容也修改

sizeof与strlen区别
1、sizeof是C/C++中的一个运算符，其作用是返回一个对象或者类型在内存中所占用的字节数。求数据类型大小
注意：sizeof后面如果是类型则必须加括号，如 sizeof(char)；而如果是变量名则可以不加括号，如 sizeof a; 但是建议使用时 均加上括号。sizeof不能返回动态地被分配的数组的大小。

2、strlen是C语言中的库函数，所在头文件为#include <string.h>其函数原型为unsigned int strlen(char *s); 其中s为指定的字符串。
注意：strlen只能用char *作为参数，它求的是字符串的实际长度，方法是从开始到遇到第一个’\0’结束。

3、sizeof是在编译的时候就将结果计算出来了是类型所占空间的字节数，所以以数组名做参数时计算的是整个数组的大小。而strlen是在运行的时候才开始计算结果，这是计算的结果不再是类型所占内存的大小，数组名就退化为指针了。
char str[20]=“0123456789”;
int a=strlen(str); //a=10;
int b=sizeof(str); //而b=1x20;

text、data、stack、heap、rodata、bss段

//main.cpp 
int a = 0; 全局初始化为0 .bass
char *p1; 全局未初始化区 .bass
int b=1; 全局初始化非0 .data
const int c=1;常量去 。rodata

main() 
{ 
int b; 栈 
char s[] = "abc"; 栈 
char *p2; 栈 
char *p3 = "123456"; 
123456\0在常量区.rodata，p3在栈上。 

static int d =0； 初始化为0的静态变量 .bass
static int e =1； 已初始化静态变量 .data
p1 = (char *)malloc(10); 
p2 = (char *)malloc(20); 
//分配得来得10和20字节的区域就在堆区。 
strcpy(p1, "123456");
123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
}

.bss段：程序中未初始化的和已经初始化为0的全局变量和已经初始化为0的静态变量（static）
.data段：程序中已经初始化的非零的全局变量和已经初始化的非零的静态变量（static）
.text段：用来存放代码的地方，不可修改，存放在只读区域内。
heap：程序员自己申请的内存区域，也就是用malloc（）函数申请的内存区域，用free（）函数来释放的区域。
stack：存放局部变量的区域，函数中的局部变量都是存放在栈中。
rodata段:存储常量数据，比如程序中定义为const的全局变量，#define定义的常量，以及诸如“Hello World”的字符串常量。只读数据，存储在ROM中。

1，使用scanf()和gets()输入字符串有何利弊？
参考答案：
用scanf()函数输入字符串时，默认分隔符是空格、跳格（Tab）等，
因此scanf()函数不能输入含有上述字符的字符串，这是其不足之处；
与gets()相比，其优点是它可以一次输入多个字符串，而且还可以用于输入不同类型的数据，应用面较广。

用gets()函数输入时，可以输入含空格、跳格等字符的字符串，但其不足之处在于，它只能用于输入字符串，且一次只能输入一个。

2，for语句与while语句在实现循环时，哪一个更好
参考答案：
相对而言，for语句更好用，尤其是循环次数确定的情况下：
for(int i = 1;i<= 10; ++i)
{
sum += i;
}

而while语句，一般用于循环次数不确定的情况：
int i = 1;
while(i<=10)
{
sum+=i;
}
可以这么理解，只要while语句能实现的地方，用for语句都能实现
另外，如果是多重循环，while嵌套的时候，看起来比较繁琐。