1、线程、进程的区别？最小执行单元是进程还是线程？

线程和进程都是程序的执行实体，但是它们有以下区别：

进程是操作系统分配资源的基本单位，每个进程都有自己的独立的地址空间，代码段，数据段，堆栈段等。进程之间的切换需要保存和恢复上下文，开销较大。
线程是操作系统调度的基本单位，每个线程都属于某个进程，一个进程可以有多个线程，它们共享进程的地址空间，但是有自己的栈和寄存器。线程之间的切换只需要保存和恢复少量的寄存器，开销较小。
最小的执行单元是线程，因为一个进程至少要有一个线程，而一个线程可以独立运行。

2、如何计算一个整数是不是2的n次方？

一个整数是2的n次方，当且仅当它的二进制表示中只有一个1，其余都是0。例如，23=8=(1000)2​
，只有一个1。所以，我们可以用以下的方法来判断一个整数x是否是2的n次方：

如果x小于等于0，那么它不是2的n次方。
如果x大于0，那么我们可以用位运算的技巧，将x与x-1做按位与，如果结果为0，那么x是2的n次方，否则不是。例如，8&(8−1)=8&7=(1000)2​&(0111)2​=(0000)2​=0
，所以8是2的n次方。而9&(9−1)=9&8=(1001)2​&(1000)2​=(1000)2​=0
，所以9不是2的n次方。

3、printf的具体实现？

printf是C语言中的一个标准库函数，用于向标准输出流（通常是屏幕）打印格式化的字符串。它的具体实现可能因编译器和操作系统的不同而有所差异，但是一般来说，它的主要步骤如下：

首先，printf会解析第一个参数，也就是格式化字符串，根据其中的转换说明符（如%d, %f, %s等），确定需要打印的数据类型和格式。
然后，printf会从第二个参数开始，依次获取对应的数据，并将其转换为字符串，拼接到格式化字符串的相应位置。如果参数的个数和类型与格式化字符串不匹配，可能会导致错误或未定义的行为。
最后，printf会调用底层的系统函数，将拼接好的字符串写入到标准输出流中，并返回成功写入的字符数。如果发生错误，返回负值。

4、什么是大小端？如何区分？有几种方法？

大小端是指数据在内存中的存储顺序，大端表示高位字节存放在低地址，低位字节存放在高地址，小端表示高位字节存放在高地址，低位字节存放在低地址。例如，一个32位的整数0x12345678，在大端模式下，存储为0x12 0x34 0x56 0x78，而在小端模式下，存储为0x78 0x56 0x34 0x12。
区分大小端的方法有以下几种：
通过联合体（union）的方式，将一个整数和一个字符数组放在同一个联合体中，然后判断字符数组的第一个元素是不是整数的最低字节，如果是，说明是小端，否则是大端。
通过指针的方式，将一个整数的地址赋给一个字符指针，然后判断指针指向的内容是不是整数的最低字节，如果是，说明是小端，否则是大端。
通过位运算的方式，将一个整数右移24位，然后与0xFF做按位与，得到的结果是不是整数的最高字节，如果是，说明是大端，否则是小端。

5、new与malloc的区别？

new和malloc都是用于动态分配内存的，但是它们有以下区别：
new是C++中的运算符，malloc是C语言中的函数，它们的用法不同。new可以直接分配对象，而malloc只能分配字节，需要强制类型转换。
new会调用对象的构造函数，初始化对象，而malloc只是分配原始的内存空间，不做任何初始化。
new会根据对象的类型，自动计算所需的内存大小，而malloc需要手动指定分配的字节数。
new分配失败时，会抛出异常，而malloc分配失败时，会返回NULL指针。
new对应的释放内存的运算符是delete，而malloc对应的释放内存的函数是free。

6、程序链接完毕之后分几部分？

程序链接完毕之后，一般分为以下几个部分：
代码段（text segment），存放程序的指令和常量。
数据段（data segment），存放程序的全局变量和静态变量。
堆（heap），存放程序动态分配的内存空间。
栈（stack），存放程序的局部变量，函数参数，返回地址等。
BSS段（bss segment），存放程序未初始化的全局变量和静态变量。

7、Linux、Windows与FreeRtos的区别？

Linux、Windows和FreeRtos都是操作系统，但是它们有以下区别：
Linux是一个开源的，基于Unix的，多用户，多任务，支持多种硬件平台的操作系统，它有很多不同的发行版，如Ubuntu，RedHat，Debian等。Linux适合用于服务器，嵌入式系统，桌面系统等。
Windows是一个闭源的，基于NT内核的，多用户，多任务，主要支持x86和x64架构的操作系统，它有很多不同的版本，如Windows 10，Windows Server，Windows CE等。Windows适合用于桌面系统，移动设备，游戏机等。
FreeRtos是一个开源的，基于微内核的，实时，多任务，支持多种嵌入式平台的操作系统，它有很多不同的移植，如ARM，MIPS，AVR等。FreeRtos适合用于实时控制，物联网，低功耗设备等。

8、Linux系统中的中断为什么分为上下两个部分？

Linux系统中的中断为了提高效率和响应时间，分为上半部（top half）和下半部（bottom half）。上半部是指中断处理程序（interrupt handler），它负责处理中断的紧急事务，如保存寄存器，清除中断标志，识别中断源等。下半部是指中断延迟服务程序（interrupt deferred service routine），它负责处理中断的非紧急事务，如数据传输，设备驱动，信号发送等。上半部和下半部的区别如下：
上半部在中断上下文中执行，下半部在进程上下文中执行。
上半部不能被其他中断打断，下半部可以被其他中断打断。
上半部不能睡眠，下半部可以睡眠。
上半部不能调用可能导致阻塞的函数，如malloc，copy_to_user等，下半部可以调用这些函数。
上半部的执行时间应该尽可能短，下半部的执行时间可以较长。

9、会快速排序吗？简要说一下？

快速排序是一种基于分治思想的排序算法，它的基本步骤如下：

从待排序的数组中选择一个元素作为基准（pivot），通常选择第一个或者最后一个元素。
将数组分成两个子数组，一个子数组中的元素都小于或等于基准，另一个子数组中的元素都大于基准，这个过程称为划分（partition）。
对两个子数组递归地进行快速排序，直到子数组的长度为1或0。
将排好序的子数组合并，得到最终的排序结果。

快速排序的平均时间复杂度是O(nlogn)
，最坏情况是O(n^2)
，空间复杂度是O(logn)
，它是一种不稳定的排序算法。

10、static关键字的作用？

static是一个修饰符，它可以用于变量和函数，它有以下作用：

用于全局变量，表示该变量只能在本文件中访问，不能被其他文件引用，这样可以避免命名冲突。
用于局部变量，表示该变量的生命周期是整个程序，而不是函数调用结束，这样可以保持变量的值不被销毁。
用于函数，表示该函数只能在本文件中调用，不能被其他文件引用，这样可以提高函数的封装性和安全性。

11、extern 关键字的作用？

extern是一个修饰符，它可以用于变量和函数，它有以下作用：
用于变量，表示该变量是在其他文件中定义的，需要在本文件中引用，这样可以避免重复定义。
用于函数，表示该函数是在其他文件中定义的，需要在本文件中声明，这样可以避免隐式声明。

12、volatile关键字的作用？

volatile是一个修饰符，它可以用于变量，它有以下作用：
用于变量，表示该变量可能会被外部因素（如中断，多线程，硬件等）改变，需要每次都从内存中读取，而不是从寄存器或缓存中读取，这样可以保证变量的实时性和一致性。
用于变量，表示该变量不会被编译器优化，需要按照程序的顺序执行，而不是进行重排或删除，这样可以避免编译器的干扰。

13、编译原理分哪几步？

编译原理是指将一种高级语言（源语言）的程序转换为另一种低级语言（目标语言）的程序的原理和方法，它一般分为以下几个步骤：
词法分析（lexical analysis），将源程序的字符序列分割成有意义的单词（token）。
语法分析（syntax analysis），将单词序列组织成语法树（parse tree）或抽象语法树（abstract syntax tree），表示程序的结构和语义。
语义分析（semantic analysis），检查程序是否符合语言的语法规则和语义规则，如类型检查，作用域分析等。
中间代码生成（intermediate code generation），将抽象语法树转换为一种中间表示（intermediate representation），如三地址码，四元式，后缀表达式等，便于优化和目标代码生成。
代码优化（code optimization），对中间表示进行一些变换，以提高程序的执行效率，如常量折叠，公共子表达式消除，循环优化，死代码删除等。
目标代码生成（target code generation），将中间表示转换为目标语言的代码，如汇编语言，机器语言等，同时进行一些分配，如寄存器分配，指令选择等。

14、内存分区？

内存分区是指将物理内存划分为若干个逻辑区域，以便于管理和使用。内存分区的方式有以下几种：
固定分区，将内存分为大小相等或不等的若干个区域，每个区域只能装入一个进程，如果进程的大小超过区域的大小，就会产生内部碎片。
动态分区，根据进程的大小和数量，动态地分配和回收内存空间，每个区域可以装入一个或多个进程，如果进程的大小不是区域的整数倍，就会产生外部碎片。
页式分区，将进程的地址空间划分为大小相等的若干个页，将物理内存划分为大小相等的若干个页框，然后将页映射到页框，实现非连续的内存分配，避免了外部碎片，但是可能产生内部碎片。
段式分区，将进程的地址空间划分为大小不等的若干个段，每个段有自己的逻辑地址和属性，然后将段映射到物理内存，实现非连续的内存分配，避免了内部碎片，但是可能产生外部碎片。
段页式分区，将进程的地址空间划分为若干个段，每个段再划分为若干个页，然后将页映射到物理内存的页框，实现非连续的内存分配，避免了内部碎片和外部碎片，但是增加了地址转换的复杂度。

15、freertos启动流程？

freertos是一个实时操作系统，它的启动流程一般如下：
首先，执行硬件初始化，如设置时钟，中断，堆栈等。
然后，执行软件初始化，如创建任务，队列，信号量，定时器等。
接着，调用vTaskStartScheduler ()函数，启动调度器，选择优先级最高的就绪任务运行。
最后，当发生中断，延时，阻塞等事件时，调度器会根据算法，如优先级抢占式，时间片轮转式等，切换任务，实现多任务的并发执行。

16、互斥锁与信号量的区别？

互斥锁（mutex）和信号量（semaphore）都是用于实现多任务的同步和互斥的机制，但是它们有以下区别：
互斥锁是一个二元的同步对象，它只有两种状态：锁定和解锁。一个互斥锁只能被一个任务拥有，当一个任务获取互斥锁后，其他任务就不能再获取该互斥锁，直到拥有者释放它。互斥锁通常用于保护临界区的访问，避免数据的不一致。
信号量是一个计数的同步对象，它有一个初始值，表示可用的资源数量。一个信号量可以被多个任务共享，当一个任务获取信号量后，信号量的值减一，表示资源被占用。当信号量的值为零时，表示没有可用的资源，其他任务就要等待，直到有任务释放信号量，信号量的值加一，表示资源被释放。信号量通常用于实现生产者-消费者模型，控制资源的分配和回收。

17、什么是死锁？死锁产生的原因？如何避免？

死锁是指多个任务因为争夺有限的资源而相互等待，导致无法继续执行的现象。死锁产生的原因一般有以下四个必要条件：
互斥条件，指每个资源只能被一个任务拥有，其他任务不能访问。
占有且等待条件，指一个任务已经占有了至少一个资源，但是又申请了其他已经被占有的资源，同时不释放自己已经占有的资源。
不可抢占条件，指一个任务占有的资源不能被其他任务强行剥夺，只能由占有者主动释放。
循环等待条件，指多个任务形成一个环路，每个任务都在等待下一个任务占有的资源。
避免死锁的方法有以下几种：
破坏互斥条件，使用非互斥的资源，如可复制的资源，或者使用软件技术，如事务，来实现对资源的虚拟访问。
破坏占有且等待条件，要求一个任务在申请资源时，必须一次性申请所有需要的资源，或者在申请新的资源时，必须先释放已经占有的资源。
破坏不可抢占条件，允许一个任务在占有资源时，被其他任务抢占，或者主动释放资源，以满足其他任务的需求。
破坏循环等待条件，给每个资源分配一个优先级，要求一个任务只能申请优先级高于或等于自己已经占有的资源的资源，或者按照一定的顺序申请资源，避免形成环路。

18、什么是内存泄漏？

内存泄漏是指程序在运行过程中，动态分配了一些内存空间，但是没有及时释放，导致这些内存空间无法被其他程序使用，造成内存的浪费和紧张。内存泄漏可能会导致程序的性能下降，甚至崩溃。

19、系统死机了怎么排查原因？逐一看代码？工程量太大了吧？

系统死机是指系统无法响应用户的输入，或者出现异常的错误，导致系统无法正常运行。排查系统死机的原因有以下几种方法：
通过日志文件，查看系统在死机前的运行状态，是否有异常的信息，如错误码，警告，断言等，以及死机的时间，位置，频率等，从而定位可能的问题源。
通过调试工具，如gdb，lldb等，对系统进行调试，查看系统的内存，寄存器，堆栈，断点等，分析系统的运行流程，发现潜在的错误，如内存泄漏，空指针，死锁等。
通过测试工具，如valgrind，asan等，对系统进行测试，检测系统的内存管理，性能，覆盖率等，发现系统的缺陷，如内存错误，资源泄漏，性能瓶颈等。
通过代码审查，对系统的代码进行分析，检查代码的风格，规范，逻辑，注释等，发现代码的不合理，不一致，不完善等，提高代码的质量，可读性，可维护性等。
通过重现问题，对系统的死机现象进行复现，观察系统的表现，输入，输出等，找出问题的触发条件，规律，范围等，缩小问题的范围，提高问题的可解决性。

20、同一类型的结构体定义两个变量能用内存大小来比较判断两者一样吗？（没懂）

同一类型的结构体定义两个变量，不能用内存大小来比较判断两者一样，因为内存大小只能反映结构体的占用空间，而不能反映结构体的内容。例如，以下两个结构体变量的内存大小都是8字节，但是它们的内容是不一样的：

struct Point {
    int x;
    int y;
};

struct Point p1 = {1, 2};
struct Point p2 = {3, 4};

如果要比较两个结构体变量是否一样，需要逐个比较它们的成员，或者使用memcmp函数比较它们的内存内容。例如：

// 逐个比较
if (p1.x == p2.x && p1.y == p2.y) {
    printf("p1 and p2 are equal\n");
} else {
    printf("p1 and p2 are not equal\n");
}

// 使用memcmp比较
if (memcmp(&p1, &p2, sizeof(struct Point)) == 0) {
    printf("p1 and p2 are equal\n");
} else {
    printf("p1 and p2 are not equal\n");
}

21、freertos中EventBits_t是干啥的？

EventBits_t是一个数据类型，它用于表示事件标志组（event group）中的每个位的状态，每个位可以表示一个事件的发生或者一个条件的满足。EventBits_t通常是一个无符号整数，它可以使用位运算来设置，清除，读取或等待事件标志。

22、freertos使任务切换的方式有哪些？

freertos使任务切换的方式有以下几种：

时间片轮转法，按照任务的优先级和时间片的长度，依次轮流执行每个就绪任务，当一个任务的时间片用完或者主动放弃时，切换到下一个任务。
优先级抢占法，按照任务的优先级，总是执行优先级最高的就绪任务，当有更高优先级的任务就绪时，立即抢占当前任务，切换到更高优先级的任务。
混合法，结合时间片轮转法和优先级抢占法，对于同一优先级的任务，使用时间片轮转法，对于不同优先级的任务，使用优先级抢占法，实现任务的公平性和效率。

23、项目中用到网络了吗？

这个问题的答案取决于你的项目的具体情况，如果你的项目需要与其他设备或服务器进行通信，或者需要访问互联网上的资源，那么你的项目就用到了网络。如果你的项目只是在本地运行，不需要与外界交互，那么你的项目就没有用到网络。

24、了解Socket吗？

Socket是一种通信机制，它可以实现不同进程或不同设备之间的数据交换。Socket通常基于TCP/IP协议，提供了可靠的，双向的，面向连接的通信服务。Socket的基本操作包括创建，绑定，监听，连接，发送，接收，关闭等。Socket的编程接口通常是一组函数或类，不同的编程语言或平台可能有不同的实现，如C语言的socket.h，Java语言的java.net.Socket等。

25、c++中set是什么？

set是C++标准模板库（STL）中的一个容器，它可以存储一组不重复的元素，并且按照一定的顺序排列。set的元素可以是任意类型，但是必须支持比较操作，如<，==等。set的底层实现通常是红黑树，所以它的插入，删除，查找等操作的时间复杂度都是O(logn)
，其中n是元素的个数。set的优点是可以快速地检查一个元素是否存在，以及保持元素的有序性。set的缺点是不能存储重复的元素，以及不能直接访问元素，只能通过迭代器遍历。

26、有没有用到C++模板？

C++模板是一种泛型编程的技术，它可以让程序员定义一种通用的模式，然后根据不同的类型或参数，生成不同的代码，从而实现代码的复用和抽象。C++模板有两种，一种是函数模板，用于定义通用的函数，另一种是类模板，用于定义通用的类。例如，以下是一个函数模板，用于比较两个值的大小：

template <typename T>
T max(T x, T y) {
    return (x > y) ? x : y;
}

我有用过C++模板，它们可以让我的代码更简洁，更灵活，更高效。我用过STL中的一些类模板，如vector，map，set等，也用过自己定义的一些函数模板和类模板，来实现一些通用的算法和数据结构。

27、有没有对代码裁剪的经验

代码裁剪是指对代码进行优化，删除不必要的或冗余的代码，减少代码的体积和复杂度，提高代码的可读性和可维护性。代码裁剪的目的是为了提高程序的性能，节省内存空间，降低编译时间，避免错误和漏洞等。
我有对代码裁剪的经验，我用过一些工具和方法来进行代码裁剪，如：
使用编译器的优化选项，如-Os，-O3等，让编译器自动进行一些代码裁剪，如常量折叠，死代码删除，循环展开等。
使用代码分析工具，如lint，coverity等，检查代码的质量，发现代码的缺陷，如未使用的变量，函数，参数等，以及代码的风格，规范，注释等，然后根据工具的建议，修改或删除代码。
使用代码重构工具，如refactor，eclipse等，对代码进行重构，改善代码的结构，设计，逻辑等，消除代码的冗余，重复，复杂等，提高代码的可读性，可维护性，可扩展性等。
使用代码压缩工具，如upx，gzip等，对代码进行压缩，减少代码的体积，提高代码的传输速度，节省存储空间等。

28、freertos系统是买模块时人家配置好的？还是移植的？

freertos系统是一个开源的，可移植的，实时的操作系统，它可以运行在多种嵌入式平台上，如ARM，MIPS，AVR等。freertos系统不是买模块时人家配置好的，而是需要根据不同的硬件和需求进行移植和定制的。移植freertos系统的步骤一般如下：
下载freertos的源码，选择合适的移植层，如portable/GCC/ARM_CM3等，根据目标平台的特性，修改一些配置参数，如configCPU_CLOCK_HZ，configTICK_RATE_HZ等。
编写启动代码，如设置时钟，中断，堆栈等，调用vPortStartFirstTask ()函数，启动第一个任务。
编写应用代码，如创建任务，队列，信号量，定时器等，调用vTaskStartScheduler ()函数，启动调度器。
编译，链接，下载，调试代码，检查系统的运行情况，如任务切换，中断响应，内存管理等。

29、任务里有两把锁的时候该怎么处理

任务里有两把锁的时候，可能会出现死锁的问题，即两个或多个任务因为互相等待对方占有的锁而无法继续执行。处理任务里有两把锁的时候，有以下几种方法：
避免使用两把锁，如果可能的话，尽量使用一把锁来保护临界区，或者使用其他同步机制，如信号量，事件标志等，来实现任务之间的协作。
按照一定的顺序获取和释放锁，如果必须使用两把锁，那么要求所有的任务都按照相同的顺序获取和释放锁，避免形成循环等待的条件。
使用超时机制，如果一个任务在获取锁时，发现锁已经被占用，那么不要无限期地等待，而是设置一个超时时间，如果超时时间到了，还没有获取到锁，那么就放弃获取，释放已经占有的锁，然后重新尝试或者执行其他操作。
使用优先级继承机制，如果一个任务在获取锁时，发现锁已经被占用，那么就把自己的优先级赋给占有锁的任务，让占有锁的任务尽快执行完毕，释放锁，然后恢复原来的优先级，这样可以避免优先级反转的问题。

30、熟悉Shell脚本吗？$和#啥意思？

Shell脚本是一种用于控制Unix或Linux系统的命令行解释器，它可以实现一些自动化的任务，如文件操作，文本处理，程序运行等。Shell脚本的语法和结构类似于C语言，但是更加简洁和灵活。Shell脚本的文件名通常以.sh为后缀，例如test.sh。
$和#是Shell脚本中的两个特殊符号，它们有以下含义：
$表示变量的引用，可以用来获取或设置变量的值，例如x=10，echo $x，表示将10赋值给变量x，然后打印x的值。

表示注释的开始，可以用来对代码进行说明，不会被执行，例如#echo hello，#这是一个注释，表示打印hello，后面的内容是一个注释。

31、知道#error吗？

、#error是一个预处理指令，它可以用来在编译时产生一个错误信息，中断编译过程。#error通常用来检查一些条件，如宏定义，平台，版本等，如果不满足条件，就提示错误，防止编译出错的代码。例如：

#ifdef __linux__
#error This code is not compatible with Linux
#endif

这段代码表示如果定义了__linux__宏，就产生一个错误信息，表示这段代码不兼容Linux系统。

32、freertos消息队列的的具体实现？

freertos消息队列是一种用于实现任务之间或任务与中断之间的异步通信的机制，它可以存储一组有序的消息，每个消息可以是任意类型的数据。freertos消息队列的具体实现如下：
消息队列是一个结构体，它包含了一些成员，如队列的头指针，尾指针，长度，容量，锁，信号量等，用来管理队列的状态和操作。
消息队列的存储空间是一个数组，它可以是静态分配的或动态分配的，它的大小要能够容纳队列的最大容量乘以每个消息的大小。
消息队列的操作有以下几种，如创建，删除，发送，接收等，它们都是通过调用一些API函数来实现的，如xQueueCreate，vQueueDelete，xQueueSend，xQueueReceive等。
消息队列的操作都是原子的，即在操作过程中，不会被其他任务或中断打断，这是通过使用临界区或中断屏蔽来实现的，以保证队列的一致性和完整性。
消息队列的操作都是阻塞的，即如果队列满了，就不能发送消息，如果队列空了，就不能接收消息，这是通过使用信号量来实现的，以实现任务的同步和等待。

33、堆栈区别？

堆（heap）和栈（stack）都是程序运行时使用的内存空间，但是它们有以下区别：
堆是动态分配的，程序员可以自由地申请和释放堆上的内存空间，堆的大小受到物理内存的限制，堆上的内存空间的地址是不连续的。
栈是静态分配的，编译器会自动地分配和回收栈上的内存空间，栈的大小受到操作系统的限制，栈上的内存空间的地址是连续的。
堆是全局共享的，堆上的内存空间可以被任何函数或模块访问，堆上的内存空间的生命周期是由程序员控制的，如果不及时释放，可能会导致内存泄漏。
栈是局部私有的，栈上的内存空间只能被当前函数或模块访问，栈上的内存空间的生命周期是由编译器控制的，当函数调用结束时，栈上的内存空间就会被自动释放。

34、程序存放状态和区别

程序存放状态是指程序在运行过程中的不同阶段，它有以下几种：
新建状态，指程序刚刚被创建，还没有被加载到内存中，等待调度器的调度。
就绪状态，指程序已经被加载到内存中，已经分配了必要的资源，等待处理器的分配。
运行状态，指程序已经被分配了处理器，正在执行程序的指令。
阻塞状态，指程序在执行过程中，因为等待某些事件的发生，如输入输出，信号量，中断等，而暂时停止执行，释放处理器，等待事件的完成。
终止状态，指程序已经执行完毕，或者因为某些原因，如错误，异常，中断等，而被终止，释放内存和资源，从系统中消失。