2024嵌入式面试：OPPO嵌入式面试题及参考答案

时间：2025-04-06 09:04:54

目录

TCP 与 UDP 的区别是什么？

请简述 TCP 的三次握手过程。

HTTP 协议的工作原理是什么？

C++11 引入了哪些新特性？

什么是智能指针？如何解决其内存泄漏问题？

进程间有哪些通信方式？

CPU 的调度策略有哪些？

如何保证线程安全？多线程编程需要注意哪些问题？

SPI 是什么？它有几条线？支持几种模式？

是否使用过 IO 模拟 SPI？请描述一下。

堆和栈在内存管理中有什么区别？

调用函数时，哪些内容需要压栈？

请简述 uboot 的启动流程。

uboot 启动前需要做哪些准备工作？

uboot 启动时使用的是物理地址还是虚拟地址？是否需要开启 MMU？

x86 汇编和 Arm 汇编之间有哪些区别？

请介绍一个你熟悉的驱动程序。

你是否学过操作系统？自旋锁和信号量有什么区别？

Linux 系统的启动流程是怎样的？

你学过哪些专业课？哪些课程学得比较好？

你在 Linux 下写过哪些驱动程序？

你是否了解 linux epoll？

请讲述一下 LCD 驱动和 input 子系统。

驱动的中断函数应该如何编写？

你是否了解 key_report 的底层实现？

如何编写一个字符设备驱动程序？

如何编写一个按键驱动程序，并实现其中断函数？

请讲讲数组和链表的异同。

你对 SPI 和中断的理解是什么？

你对 Linux 中断的理解是什么？

你对多线程编程有哪些了解？

你对内存管理有哪些了解？

什么是僵尸进程、孤儿进程、守护进程？

僵尸进程有什么危害？

线程间有哪些通信方法？

什么是友元？在 C++ 中如何使用？

基类的构造函数和析构函数能否被派生类继承？

哪些函数不能声明为虚函数？

vector 的底层实现是怎样的？

什么是野指针？如何产生？如何避免？

栈在 C 语言中有什么作用？

C++ 的内存管理是如何进行的？

什么是内存泄漏？如何判断和减少内存泄漏？

字节对齐问题对程序有何影响？

C 语言函数参数压栈顺序是怎样的？

C++ 如何处理返回值？

栈的空间最大值是多少？在 1G 内存的计算机中能否 malloc (1.2G)？为什么？

strcat、strncat、strcmp、strcpy 等函数在什么情况下会导致内存溢出？如何改进？

malloc、calloc、realloc 等内存申请函数有何区别和使用场景？

TCP 与 UDP 的区别是什么？

TCP（Transmission Control Protocol，传输控制协议）和 UDP（User Datagram Protocol，用户数据报协议）是两种不同的网络传输协议，它们在许多方面存在区别：

  1. 连接性

    • TCP 是面向连接的协议，在通信之前需要建立连接，确保数据传输的可靠性和顺序性。
    • UDP 是无连接的协议，不需要建立连接，直接发送数据报，可能会出现数据丢失、乱序等情况。

  2. 可靠性

    • TCP 提供可靠的数据传输，通过确认、重传、拥塞控制等机制保证数据的完整性和准确性。
    • UDP 不保证数据的可靠交付，接收方收到的数据可能是不完整或错误的。

  3. 顺序性

    • TCP 确保数据按照发送的顺序到达接收方。
    • UDP 不保证数据的顺序，数据可能会乱序到达。

  4. 头部开销

    • TCP 头部较大，包含更多的控制信息，如序列号、确认号、窗口大小等。
    • UDP 头部较小，只有源端口、目的端口、长度和校验和等少量字段。

  5. 应用场景

    • TCP 适用于对数据准确性和顺序性要求较高的应用，如文件传输、电子邮件、网页浏览等。
    • UDP 适用于对实时性要求较高、对数据准确性要求较低的应用，如视频直播、语音通话、在线游戏等。

例如，在文件下载中，我们希望数据完整且按顺序到达，所以使用 TCP 协议；而在实时视频流中，偶尔的丢包或乱序对观看体验影响不大，但需要快速传输数据，所以通常使用 UDP 协议。

请简述 TCP 的三次握手过程。

TCP 的三次握手过程是建立可靠连接的重要步骤，具体如下：

第一次握手：客户端向服务器发送一个 SYN（同步）包，其中包含客户端选择的初始序列号（SEQ）。此时客户端进入 SYN_SENT 状态。

第二次握手：服务器收到客户端的 SYN 包后，向客户端发送一个 SYN/ACK（同步确认）包，其中确认号为客户端的 SEQ + 1，同时也包含服务器选择的初始序列号。此时服务器进入 SYN_RECV 状态。

第三次握手：客户端收到服务器的 SYN/ACK 包后，向服务器发送一个 ACK（确认）包，确认号为服务器的 SEQ + 1。此时客户端进入 ESTABLISHED 状态，服务器收到 ACK 包后也进入 ESTABLISHED 状态，连接建立成功。

通过三次握手，客户端和服务器能够相互确认对方的接收和发送能力，为后续的数据传输做好准备。

例如，假设客户端的初始序列号为 1000，服务器的初始序列号为 2000。第一次握手，客户端发送 SYN 包，SEQ = 1000；第二次握手，服务器回应 SYN/ACK 包，ACK = 1001，SEQ = 2000；第三次握手，客户端发送 ACK 包，ACK = 2001。

HTTP 协议的工作原理是什么？

HTTP（HyperText Transfer Protocol，超文本传输协议）是用于在 Web 上传输数据的应用层协议，其工作原理包括以下几个主要步骤：

  1. 客户端发起请求

    • 客户端（通常是浏览器）通过输入 URL 向服务器发送 HTTP 请求。请求包括请求方法（如 GET、POST 等）、请求头（包含客户端的信息和期望的响应格式等）和请求体（如果有数据要发送）。

  2. 服务器处理请求

    • 服务器接收到请求后，根据请求的 URL 和方法进行相应的处理。例如，如果是 GET 请求，服务器会从数据库或文件系统中获取相应的资源。

  3. 服务器响应

    • 服务器处理完请求后，向客户端发送 HTTP 响应。响应包括响应状态码（表示请求的处理结果，如 200 表示成功，404 表示未找到资源等）、响应头（包含服务器的信息和响应的相关参数）和响应体（包含请求的资源内容）。

  4. 客户端接收和处理响应

    • 客户端接收到响应后，根据响应状态码和响应头进行相应的处理。如果状态码表示成功，客户端会根据响应头中的信息解析响应体，并将其显示在页面上。

例如，当用户在浏览器中输入一个网址，浏览器会向服务器发送一个 GET 请求获取网页的 HTML 内容。服务器处理请求后，返回包含 HTML 代码的响应，浏览器解析并显示网页。

C++11 引入了哪些新特性？

C++11 引入了许多新特性，大大增强了 C++ 的功能和编程的便利性：

  1. 自动类型推导

    • 使用 auto 关键字可以让编译器根据初始化的值自动推断变量的类型。

  2. 范围 for 循环

    • 使得遍历容器或数组更加简洁和直观。

  3. 初始化列表

    • 可以更方便地对对象进行初始化。

  4. 右值引用和移动语义

    • 提高了资源管理和性能优化的能力。

  5. lambda 表达式

    • 允许在需要的地方定义匿名函数。

  6. 智能指针

    • 如 unique_ptr 和 shared_ptr，更好地管理动态内存，减少内存泄漏的风险。

  7. 并发支持

    • 包括线程库、互斥量、条件变量等，方便进行多线程编程。

例如，使用自动类型推导可以这样写：auto num = 42; 而不需要明确指定类型。使用范围 for 循环遍历数组：int arr[] = {1, 2, 3}; for (auto& x : arr) {... }

什么是智能指针？如何解决其内存泄漏问题？

智能指针是 C++ 中用于自动管理动态分配内存的工具。

智能指针的主要类型包括 unique_ptr（独占所有权）、shared_ptr（共享所有权）和 weak_ptr（弱引用）。

智能指针解决内存泄漏问题的原理是通过自动管理内存的生命周期。当智能指针超出其作用域或不再被使用时，它会自动释放所管理的内存。

以 unique_ptr 为例，它确保在任何时候只有一个指针拥有所指向的资源，当 unique_ptr 被销毁时，其指向的内存会被自动释放。

shared_ptr 通过引用计数来管理内存。多个 shared_ptr 可以共享对同一内存的所有权，当最后一个 shared_ptr 被销毁且引用计数为 0 时，内存被释放。

为了正确使用智能指针避免内存泄漏，需要注意以下几点：

  1. 避免循环引用，特别是在使用 shared_ptr 时。
  2. 确保智能指针的所有权转移和共享逻辑清晰。

例如，如果有两个对象相互持有对方的 shared_ptr ，就会导致内存无法释放，形成循环引用。

进程间有哪些通信方式？

进程间通信方式主要包括以下几种：

  1. 管道（Pipe）

    • 分为匿名管道和命名管道。匿名管道只能在具有亲缘关系的进程间使用，而命名管道可以在无亲缘关系的进程间通信。

  2. 消息队列（Message Queue）

    • 消息以链表的形式存储在内存中，进程可以向队列发送消息或从队列接收消息。

  3. 共享内存（Shared Memory）

    • 多个进程可以共享同一块内存区域，直接读写数据，实现快速的数据交换，但需要同步机制来保证数据的一致性。

  4. 信号量（Semaphore）

    • 用于实现进程间的同步和互斥。

  5. 套接字（Socket）

    • 不仅可以用于同一台机器上的进程间通信，还可以用于不同机器上的进程通信。

例如，在生产者 - 消费者问题中，可以使用消息队列来传递生产的产品信息；在多线程对共享资源的访问中，可以使用信号量来实现互斥。

CPU 的调度策略有哪些？

CPU 的调度策略主要有以下几种：

  1. 先来先服务（First Come First Served，FCFS）

    • 按照进程到达的先后顺序进行调度。

  2. 短作业优先（Shortest Job First，SJF）

    • 优先调度执行时间短的进程。

  3. 时间片轮转（Round Robin，RR）

    • 给每个进程分配一个时间片，当时间片用完后切换到下一个进程。

  4. 优先级调度

    • 为每个进程分配一个优先级，优先级高的进程优先获得 CPU 资源。

  5. 多级反馈队列调度

    • 结合了多种调度策略的特点，设置多个优先级不同的队列。

例如，对于交互性要求高的系统，可能采用时间片轮转调度；对于对响应时间要求高的实时系统，可能采用优先级调度。

如何保证线程安全？多线程编程需要注意哪些问题？

保证线程安全可以采取以下几种常见的方法：

  1. 互斥锁（Mutex）

    • 通过加锁和解锁来保证同一时刻只有一个线程访问共享资源。

  2. 条件变量（Condition Variable）

    • 用于线程间的同步和等待。

  3. 原子操作

    • 保证操作的原子性，不会被其他线程中断。

多线程编程需要注意以下问题：

  1. 数据竞争

    • 多个线程同时访问和修改共享数据时可能导致不一致的结果。

  2. 死锁

    • 线程相互等待对方持有的资源，导致系统无法继续执行。

  3. 线程过多导致的性能下降

    • 过多的线程切换会消耗系统资源。

例如，在一个多线程的银行账户操作中，使用互斥锁来保护账户余额的修改，避免出现数据不一致的情况。在复杂的资源竞争场景中，要小心设计避免死锁的发生。

SPI 是什么？它有几条线？支持几种模式？

SPI（Serial Peripheral Interface，串行外设接口）是一种高速的、全双工、同步的通信总线。

SPI 通常由四条线组成：

  1. SCLK（Serial Clock，时钟线）：用于同步数据传输。
  2. MOSI（Master Output Slave Input，主设备输出从设备输入线）：主设备向从设备发送数据。
  3. MISO（Master Input Slave Output，主设备输入从设备输出线）：从设备向主设备发送数据。
  4. SS/CS（Slave Select/Chip Select，从设备选择线）：用于选择要与之通信的从设备。

SPI 支持四种工作模式，主要区别在于时钟极性（CPOL）和时钟相位（CPHA）的组合：

  1. 模式 0：CPOL = 0，CPHA = 0。在时钟的空闲状态为低电平，数据在时钟的上升沿被采样。
  2. 模式 1：CPOL = 0，CPHA = 1。在时钟的空闲状态为低电平，数据在时钟的下降沿被采样。
  3. 模式 2：CPOL = 1，CPHA = 0。在时钟的空闲状态为高电平，数据在时钟的下降沿被采样。
  4. 模式 3：CPOL = 1，CPHA = 1。在时钟的空闲状态为高电平，数据在时钟的上升沿被采样。

例如，在一些传感器模块与微控制器的通信中，根据传感器的规格要求选择合适的 SPI 模式来确保数据的准确传输。

是否使用过 IO 模拟 SPI？请描述一下。

我使用过 IO 模拟 SPI 进行通信。

IO 模拟 SPI 是在没有硬件 SPI 接口的情况下，通过软件控制普通的 GPIO 引脚来实现 SPI 通信的功能。

首先，需要设置相关的 GPIO 引脚为输出或输入模式。对于时钟引脚，按照 SPI 协议的要求产生特定频率和极性的时钟信号。在发送数据时，根据要发送的数据位，在时钟的上升沿或下降沿改变 MOSI 引脚的电平状态。同时，在相应的时钟沿读取 MISO 引脚的电平以接收数据。

例如，在一个简单的项目中，使用单片机的普通 GPIO 引脚模拟 SPI 与一个 SPI 接口的 EEPROM 进行通信，实现数据的读写操作。在这个过程中，需要精确控制引脚的电平变化和时间间隔，以符合 SPI 协议的时序要求。

堆和栈在内存管理中有什么区别？

堆和栈是在内存管理中两个重要的概念，它们有以下显著的区别：

  1. 内存分配方式

    • 栈是由编译器自动分配和释放的，存储局部变量、函数参数等。当函数调用结束时，栈上的空间会自动回收。
    • 堆是由程序员手动分配和释放的，使用如 malloc、new 等函数进行分配，使用 free、delete 等函数进行释放。

  2. 内存分配效率

    • 栈的分配和释放速度很快，因为其操作简单，由编译器自动管理。
    • 堆的分配和释放相对较慢，因为涉及到系统的内存管理机制和复杂的算法。

  3. 内存空间大小

    • 栈的空间通常较小，一般是几兆字节。
    • 堆的空间大小几乎没有限制，取决于系统的物理内存和虚拟内存。

  4. 存储内容

    • 栈主要存储函数的调用信息、局部变量等，具有确定性和临时性。
    • 堆可以存储较大的数据结构、动态分配的对象等，具有更大的灵活性。

例如，在一个函数中定义的局部变量就存储在栈中，而动态创建的大型数组或对象通常分配在堆上。

调用函数时，哪些内容需要压栈？

在函数调用时，以下内容通常需要压栈：

  1. 函数的返回地址

    • 用于函数执行完毕后能够正确返回调用点继续执行。

  2. 函数的参数

    • 按照参数的传递顺序依次压栈。

  3. 调用者的栈帧指针

    • 用于恢复调用者的栈帧。

  4. 一些寄存器的值

    • 例如一些关键的通用寄存器，以保证函数执行过程中不会破坏调用者的寄存器状态。

例如，当函数 func(int a, int b) 被调用时，参数 a 和 b 、返回地址以及相关寄存器的值都会被压入栈中。在函数内部，可能还会进一步压栈来保存局部变量等信息。

请简述 uboot 的启动流程。

uboot（Universal Boot Loader，通用引导加载程序）的启动流程大致如下：

  1. 硬件初始化

    • 初始化处理器、时钟、内存控制器等基本硬件。

  2. 环境变量初始化

    • 读取和设置一些关键的环境变量，如启动参数、网络配置等。

  3. 加载内核镜像

    • 从存储设备（如 Flash 、SD 卡等）中读取内核镜像到内存。

  4. 校验内核镜像

    • 对加载的内核镜像进行完整性和正确性的校验。

  5. 传递参数给内核

    • 将一些必要的参数传递给内核，以便内核正确启动。

  6. 跳转到内核启动

    • 完成准备工作后，跳转到内核的入口点启动内核。

例如，在一个嵌入式系统中，uboot 首先完成硬件的基本初始化，然后从特定的存储位置加载经过压缩的内核镜像，校验无误后将相关参数传递给内核并启动内核。

uboot 启动前需要做哪些准备工作？

在 uboot 启动之前，需要进行以下准备工作：

  1. 硬件初始化

    • 包括初始化处理器核心、设置时钟频率、初始化内存控制器以确保内存可用。

  2. 配置存储设备

    • 识别和初始化用于存储 uboot 、内核镜像和文件系统的存储介质，如 Flash 、SD 卡等。

  3. 初始化串口

    • 用于输出调试信息和与用户进行交互。

  4. 加载引导配置

    • 从特定的存储位置读取引导配置信息，如启动模式、默认参数等。

例如，在一个基于特定芯片的嵌入式系统中，需要在 uboot 启动前配置好芯片的引脚功能，以确保与存储设备的正确连接。

uboot 启动时使用的是物理地址还是虚拟地址？是否需要开启 MMU？

uboot 启动时使用的是物理地址，不需要开启 MMU（Memory Management Unit，内存管理单元）。

在 uboot 阶段，系统处于初始化的早期阶段，还没有建立完整的内存管理和虚拟地址映射机制。此时，直接操作物理地址来访问硬件资源和进行内存读写。

只有在后续内核启动后，才会开启 MMU 来进行虚拟地址到物理地址的映射，实现更复杂的内存管理和保护机制。

例如，在一些嵌入式系统中，uboot 直接使用物理地址来读写 Flash 中的数据，而在内核启动并配置好 MMU 后，应用程序则通过虚拟地址进行访问。

x86 汇编和 Arm 汇编之间有哪些区别？

x86 汇编和 Arm 汇编有以下一些区别：

  1. 指令集架构

    • x86 是复杂指令集（CISC）架构，指令长度和格式较为多样。
    • Arm 是精简指令集（RISC）架构，指令相对简单和规整。

  2. 寄存器

    • x86 有较多的通用寄存器，但名称和功能较为复杂。
    • Arm 有相对较少但功能明确的通用寄存器。

  3. 内存访问方式

    • x86 对内存的访问方式较为灵活，但也更复杂。
    • Arm 通常采用更简单和规整的内存访问模式。

  4. 指令编码

    • x86 指令编码相对复杂，长度可变。
    • Arm 指令编码通常较为简单，长度固定。

  5. 应用场景

    • x86 常见于个人电脑和服务器。
    • Arm 广泛应用于移动设备、嵌入式系统等。

例如，在进行一些简单的计算操作时，Arm 汇编的指令可能更简洁直观，而在处理复杂的操作系统和大型应用时，x86 汇编可能有更多的特定指令来优化性能。

请介绍一个你熟悉的驱动程序。

我熟悉的驱动程序是 USB 驱动程序。

USB（Universal Serial Bus，通用串行总线）驱动程序负责实现主机与 USB 设备之间的通信。它需要处理各种 USB 设备的连接、断开、数据传输以及电源管理等功能。

在实现 USB 驱动程序时，首先需要了解 USB 协议的规范和各种设备类型的特点。例如，常见的 USB 设备包括存储设备（如 U 盘）、输入设备（如鼠标、键盘）、音频设备等，每种设备都有其特定的协议要求和数据格式。

对于设备的连接和断开检测，驱动程序需要能够实时响应硬件中断或轮询状态，以确定设备的存在和可用性。在数据传输方面，要根据不同的传输类型（如控制传输、批量传输、中断传输、等时传输）来处理数据的发送和接收。同时，还需要考虑错误处理和恢复机制，以确保数据传输的可靠性。

以一个 USB 鼠标驱动为例，当鼠标连接到主机时，驱动程序会检测到设备的插入，并获取设备的描述符来了解其特性，如分辨率、按键数量等。在数据传输过程中，驱动程序会不断接收鼠标发送的位置和按键状态信息，并将其传递给操作系统的上层应用程序进行处理。

另外，为了提高系统的电源效率，USB 驱动程序还需要参与电源管理，例如在设备空闲时降低功耗或在设备长时间不使用时进入省电模式。

你是否学过操作系统？自旋锁和信号量有什么区别？

我学过操作系统。

自旋锁和信号量是操作系统中用于实现同步和互斥的两种不同机制，它们有以下区别：

  1. 等待机制

    • 自旋锁：当获取锁失败时，线程会在原地 “自旋”，持续尝试获取锁，不会进入睡眠状态。
    • 信号量：当获取信号量失败时，线程会进入睡眠状态，等待被唤醒。

  2. 适用场景

    • 自旋锁：适用于短时间内能够获得锁的情况，因为自旋不会导致线程切换，开销较小。但如果长时间无法获取锁，会浪费 CPU 资源。
    • 信号量：适用于获取锁可能需要较长时间的情况，因为线程进入睡眠可以避免 CPU 空转。

  3. CPU 占用

    • 自旋锁：在等待锁的过程中，线程会一直占用 CPU。
    • 信号量：等待期间线程不占用 CPU。

例如，在多核环境下，如果多个核心都可能竞争一个自旋锁，且获取锁的时间较短，使用自旋锁较为合适。而在一个单核心系统中，或者获取锁的时间不确定且可能较长时，使用信号量更为合适，以避免 CPU 资源的浪费。

Linux 系统的启动流程是怎样的？

Linux 系统的启动流程大致如下：

  1. BIOS 自检

    • 计算机开机后，首先由 BIOS（Basic Input/Output System，基本输入输出系统）进行硬件自检，包括检查内存、硬盘、显卡等设备是否正常。

  2. 引导加载程序

    • BIOS 完成自检后，根据设置选择启动设备（如硬盘、U 盘等），并加载该设备上的引导加载程序，常见的有 GRUB（Grand Unified Bootloader）。

  3. 加载内核

    • 引导加载程序从指定位置读取 Linux 内核镜像，并将其加载到内存中。

  4. 内核初始化

    • 内核开始初始化，包括检测硬件设备、建立内存管理机制、初始化各种内核数据结构等。

  5. 启动第一个进程

    • 内核启动第一个进程，通常是 init 进程。

  6. 运行 init 进程

    • init 进程根据配置文件（如 /etc/inittab）决定系统的运行级别，并启动相应的服务和进程。

  7. 启动系统服务

    • 根据运行级别，启动各种系统服务，如网络服务、文件系统服务等。

  8. 登录界面

    • 系统服务启动完成后，显示登录界面，等待用户登录。

例如，在一个服务器系统中，内核初始化阶段会检测多个网络接口和存储设备，init 进程会根据服务器的配置启动特定的网络服务和数据库服务。

你学过哪些专业课？哪些课程学得比较好？

我学过的专业课包括：计算机组成原理、操作系统、数据结构与算法、计算机网络、嵌入式系统原理等。

在这些课程中，我在操作系统和数据结构与算法这两门课程上学得相对较好。

在操作系统课程中，我深入理解了进程管理、内存管理、文件系统、设备管理等核心概念和机制。通过实际的编程和实验，掌握了进程调度算法的实现、内存分配策略的应用以及文件系统的操作等。这使我能够更好地理解计算机系统的资源管理和优化。

在数据结构与算法课程中，我熟练掌握了常见的数据结构，如链表、栈、队列、树、图等，以及各种算法，如排序算法、搜索算法、动态规划等。能够根据具体的问题选择合适的数据结构和算法来提高程序的效率和性能。

例如，在解决一个复杂的路径规划问题时，我能够运用图的数据结构和相关的算法来找到最优解。

你在 Linux 下写过哪些驱动程序？

在 Linux 下，我写过字符设备驱动程序。

字符设备驱动程序是 Linux 设备驱动中的一种常见类型，用于实现对字符型设备的操作和控制。

在编写字符设备驱动程序时，需要实现一系列的接口函数，如 open、close、read、write 等，以处理设备的打开、关闭、读、写等操作。同时，还需要处理设备的注册、注销，以及与内核的交互。

例如，我编写过一个简单的虚拟字符设备驱动，用于模拟一个数据采集设备。在驱动程序中，通过实现 read 函数来提供采集到的数据，用户空间的应用程序可以通过系统调用读取这些数据进行处理和分析。

另外，还需要处理设备的中断，当设备有新的数据产生或者状态发生变化时，通过中断通知内核和用户空间的应用程序。

你是否了解 linux epoll？

我了解 Linux 的 epoll 。

epoll 是 Linux 下一种高效的 I/O 多路复用机制。

与传统的 select 和 poll 机制相比，epoll 具有显著的优势。它解决了 select 和 poll 在处理大量文件描述符时效率低下的问题。

epoll 的工作原理主要基于事件驱动。通过创建一个 epoll 实例，将需要关注的文件描述符添加到其中，并指定感兴趣的事件类型（如可读、可写等）。epoll 会在内核中维护这些文件描述符的状态，并在有事件发生时通知应用程序。

epoll 支持两种工作模式：水平触发（LT）和边缘触发（ET）。水平触发模式下，只要文件描述符上有数据可读或可写，就会不断触发通知。边缘触发模式下，只有在状态从不可读 / 写变为可读 / 写时才触发通知。

例如，在一个高并发的网络服务器中，使用 epoll 可以高效地处理大量的网络连接，及时响应客户端的请求，提高服务器的性能和响应能力。

请讲述一下 LCD 驱动和 input 子系统。

LCD 驱动：

LCD（Liquid Crystal Display，液晶显示器）驱动是用于控制液晶显示屏工作的程序。它负责与硬件交互，设置显示参数，如分辨率、颜色深度、刷新率等，并将图像数据发送到显示屏进行显示。

在实现 LCD 驱动时，需要了解显示屏的硬件接口和控制协议，如常见的 SPI、I2C 等接口。还需要处理显示缓冲区的管理，以及与图形库或应用程序的接口。

例如，在一个嵌入式系统中，LCD 驱动需要根据系统的资源和性能要求，合理地分配显示缓冲区，以确保图像的流畅显示。

input 子系统：

input 子系统是 Linux 内核中用于处理输入设备的框架。它提供了统一的接口，方便驱动程序开发者实现各种输入设备的驱动，如键盘、鼠标、触摸屏等。

input 子系统将输入设备的硬件操作抽象为事件，如按键按下、鼠标移动、触摸操作等，并将这些事件传递给上层应用程序。

在编写 input 设备驱动时，需要向 input 子系统注册设备，并实现相关的事件处理函数。

例如，对于触摸屏驱动，需要在检测到触摸操作时，通过 input 子系统上报触摸坐标和操作类型等信息。

驱动的中断函数应该如何编写？

编写驱动的中断函数需要遵循以下步骤和注意事项：

首先，需要确定中断的类型和触发条件。中断可以是硬件中断，由外部设备产生，也可以是软件中断，由程序主动触发。

在函数内部，要做以下关键操作：

  1. 保存现场：将当前进程的关键寄存器值等保存起来，以保证中断处理完成后能够正确恢复执行环境。
  2. 处理中断事务：根据中断的来源和目的，进行相应的数据处理、状态更新等操作。
  3. 清除中断标志：确保中断处理完成后，清除相关的中断标志，以便下次中断能够正确触发。
  4. 恢复现场：将之前保存的寄存器值等恢复，使被中断的进程能够继续执行。

在编写中断函数时，还需要注意以下几点：

  1. 尽量短小精悍：中断处理函数应该快速执行，避免长时间占用 CPU 资源，影响系统的实时性。
  2. 避免阻塞操作：不要在中断函数中进行可能导致阻塞的操作，如等待资源、睡眠等。
  3. 注意并发：考虑多中断同时发生的情况，确保数据的一致性和操作的正确性。

例如，在一个网络驱动的中断函数中，可能只是简单地接收数据包并放入缓冲区，然后通知上层进行处理，而具体的数据解析和处理则在其他非中断上下文中进行。

你是否了解 key_report 的底层实现？

key_report 通常用于报告按键事件，其底层实现涉及到操作系统的输入子系统和相关的硬件接口。

在底层，当按键被按下或释放时，硬件会产生一个电信号。这个电信号会被连接到计算机系统的输入接口，例如通过 GPIO 引脚或专门的键盘接口。

操作系统通过驱动程序来监测这些接口的状态变化。驱动程序会将硬件的原始信号转换为有意义的按键事件信息，包括按键码、按下或释放状态以及可能的其他相关属性。

这些按键事件信息会被传递给输入子系统，输入子系统负责对这些事件进行进一步的处理和分发。它可能会根据当前的焦点窗口或应用程序，将按键事件传递给相应的进程进行处理。

例如，在一个嵌入式系统中，当用户按下一个按键时，硬件电路产生的信号被微控制器的引脚捕获，驱动程序读取该引脚的状态变化，并将其转换为特定的按键码，然后通过输入子系统传递给正在运行的应用程序，从而实现对按键操作的响应。

如何编写一个字符设备驱动程序？

编写一个字符设备驱动程序通常包括以下主要步骤：

  1. 定义设备结构体

    • 包含设备的私有数据和相关操作函数指针。

  2. 实现设备操作函数

    • 如 open、close、read、write 等。这些函数处理与设备的打开、关闭、读、写操作相关的逻辑。

  3. 注册设备

    • 向内核注册设备，使其能够被系统识别和管理。

  4. 处理中断（如果需要）

    • 对于可能产生中断的设备，实现中断处理函数。

  5. 实现 file_operations 结构体

    • 将定义的操作函数与内核的接口关联起来。

  6. 模块加载和卸载函数

    • 在模块加载时进行必要的初始化工作，在卸载时释放资源。

以一个简单的字符设备驱动为例，假设我们要实现一个用于计数的设备。在 open 函数中初始化计数器，read 函数返回当前计数值，write 函数根据写入的数据进行相应的操作（如重置计数器）。在模块加载函数中注册设备，卸载函数中注销设备并释放相关资源。

例如，在一个嵌入式系统中，编写一个温度传感器的字符设备驱动。read 函数从传感器读取当前温度值并返回给用户空间，write 函数可以设置传感器的一些配置参数。

如何编写一个按键驱动程序，并实现其中断函数？

编写一个按键驱动程序并实现其中断函数通常需要以下步骤：

  1. 硬件连接和初始化

    • 了解按键与微控制器的连接方式，配置相关的 GPIO 引脚为输入模式。

  2. 注册中断

    • 向内核注册按键对应的中断。

  3. 实现中断处理函数

    • 在中断处理函数中，快速处理关键事务，如记录按键状态、设置标志等。

  4. 轮询或等待标志

    • 在主程序中，通过轮询标志或等待事件的方式来获取按键状态的变化，并进行相应的处理。

例如，假设我们使用 STM32 微控制器，首先配置 GPIO 引脚为上拉输入。然后使用相应的中断控制器注册中断，并在中断处理函数中设置一个全局标志表示按键被按下。在主循环中，通过检查这个标志来执行相应的操作，如发送按键值给上层应用。

请讲讲数组和链表的异同。

数组和链表是两种常见的数据结构，它们有以下相同点和不同点：

相同点：

  1. 都是用于存储一组数据的结构。

不同点：

  1. 内存分配

    • 数组：在内存中是连续分配的，一旦创建，大小固定。
    • 链表：内存分配是不连续的，通过指针链接各个节点。

  2. 随机访问

    • 数组：可以通过索引直接快速访问任意元素。
    • 链表：不支持随机访问，要访问特定元素，需要从头节点开始逐个遍历。

  3. 插入和删除操作

    • 数组：插入和删除元素可能需要移动大量元素，效率较低。
    • 链表：只需修改指针，操作简单高效。

  4. 内存利用

    • 数组：可能存在内存浪费，如果预先分配的空间过大。
    • 链表：按需分配内存，但每个节点需要额外的指针空间。

例如，在需要频繁随机访问且数据规模固定的情况下，使用数组更合适，如存储一个固定大小的矩阵。而在频繁插入和删除元素的场景，如实现一个动态的任务队列，链表则更具优势。

你对 SPI 和中断的理解是什么？

SPI（Serial Peripheral Interface，串行外设接口）：

SPI 是一种同步串行通信接口标准，常用于微控制器与外部设备（如传感器、EEPROM、显示屏等）之间的通信。

SPI 具有以下特点：

  1. 全双工通信：可以同时发送和接收数据。
  2. 高速传输：能够实现相对较高的数据传输速率。
  3. 主从模式：通常有一个主设备控制通信，多个从设备响应。

中断：

中断是计算机系统中一种重要的机制，用于处理异步事件。

当某个事件发生时（如外部设备请求、定时器超时等），会触发中断，使 CPU 暂停当前正在执行的任务，转而去处理中断服务程序。中断处理完成后，再返回原来的任务继续执行。

中断的优点包括：

  1. 实时响应：能够及时处理紧急事件，提高系统的实时性。
  2. 提高效率：避免 CPU 一直轮询等待事件发生，节省 CPU 资源。

例如，在一个嵌入式系统中，通过 SPI 接口与外部的 ADC 芯片通信获取模拟量数据。当 ADC 转换完成时，通过中断通知 CPU 读取转换结果，从而实现高效的数据采集。

你对 Linux 中断的理解是什么？

在 Linux 中，中断是一种重要的机制，用于处理外部事件和异步操作。

Linux 中断分为硬件中断和软件中断。硬件中断由外部硬件设备产生，例如键盘按键、网络数据包到达等。软件中断通常是由内核或应用程序主动触发的。

当发生中断时，CPU 会暂停当前正在执行的进程，转而执行中断处理程序。中断处理程序需要快速执行关键操作，然后尽快返回，以减少对系统性能的影响。

Linux 内核使用中断下半部机制来处理耗时较长的中断任务，如工作队列、软中断等，以避免中断处理程序过长的执行时间影响系统的响应性。

例如，在网络通信中，当网卡接收到数据包时产生硬件中断，中断处理程序快速将数据包放入接收缓冲区，然后通过软中断在后续处理数据包的解析和分发。

你对多线程编程有哪些了解？

多线程编程是指在一个程序中同时运行多个线程，以实现并发执行任务的编程方式。

多线程编程的优点包括：

  1. 提高资源利用率：可以在等待某些操作（如 I/O 操作）时，切换到其他线程执行，充分利用 CPU 资源。
  2. 增强响应性：能够及时处理多个并发请求，提高程序的响应速度。
  3. 简化程序结构：对于一些可以并行处理的任务，使用多线程可以使程序逻辑更清晰。

然而，多线程编程也带来了一些挑战：

  1. 线程同步：多个线程可能同时访问共享资源，需要使用同步机制（如互斥锁、信号量等）来保证数据的一致性和正确性。
  2. 死锁问题：如果线程获取资源的顺序不当，可能导致死锁，使程序无法继续执行。
  3. 线程安全：需要确保共享数据在多线程环境下的操作是安全的。

例如，在一个文件下载程序中，可以使用一个线程负责下载文件，另一个线程负责更新下载进度显示，从而提高程序的效率和用户体验。

你对内存管理有哪些了解？

内存管理是操作系统中负责分配、回收和管理内存资源的重要部分。

内存管理的主要功能包括：

  1. 内存分配：为进程或程序分配所需的内存空间。
  2. 内存回收：当进程结束或不再需要某些内存时，回收这些内存以便再次使用。
  3. 地址转换：将逻辑地址转换为物理地址，实现虚拟内存机制，使程序可以使用比实际物理内存更大的地址空间。

常见的内存管理算法和策略有：

  1. 首次适应算法：从内存的起始位置开始查找，找到第一个满足需求的空闲分区进行分配。
  2. 最佳适应算法：选择大小最接近需求的空闲分区进行分配。
  3. 页式存储管理：将内存分为固定大小的页，通过页表进行地址转换。

内存管理还需要考虑内存碎片的问题，即内存被分割成许多小块，导致无法满足较大的内存请求。

例如，在一个多任务操作系统中，不同的进程通过内存管理机制获得各自独立的内存空间，互不干扰，同时有效地利用有限的物理内存资源。

什么是僵尸进程、孤儿进程、守护进程？

僵尸进程：

僵尸进程是指一个子进程已经结束，但其父进程尚未对其进行回收（获取其终止状态）的进程。子进程结束后，内核仍然会保留其少量信息（如进程号、终止状态、资源使用情况等），等待父进程获取。如果父进程一直不获取这些信息，子进程就会成为僵尸进程。

孤儿进程：

孤儿进程是指父进程先于子进程结束，此时子进程会被操作系统的 init 进程收养，init 进程会负责对其进行后续的资源回收等处理。

守护进程：

守护进程是在后台运行且不受终端控制的进程，通常在系统启动时自动启动，并一直运行直到系统关闭。它们独立于控制终端，提供各种系统服务，如打印服务、日志服务等。

僵尸进程有什么危害？

僵尸进程会带来以下危害：

  1. 资源占用：尽管僵尸进程占用的资源相对较少，但如果系统中存在大量的僵尸进程，累积起来也会消耗一定的系统资源，如进程表空间。

  2. 进程号浪费：每个进程都有唯一的进程号，僵尸进程占用的进程号无法被新进程使用，可能导致可用进程号减少。

  3. 影响系统性能：过多的僵尸进程可能会影响系统的性能和稳定性，特别是在资源紧张的情况下。

例如，在一个高并发的服务器环境中，如果存在大量的短生命周期的子进程，如果父进程处理不当，容易产生众多僵尸进程，从而影响服务器的整体性能和响应能力。

线程间有哪些通信方法？

线程间的通信方法主要有以下几种：

  1. 共享变量

    • 多个线程可以访问和修改同一个共享变量来实现通信。但需要使用同步机制（如互斥锁、条件变量等）来保证线程安全。

  2. 消息队列

    • 可以创建一个消息队列，线程通过向队列中发送消息和从队列中接收消息来进行通信。

  3. 管道

    • 类似于进程间的管道通信，线程间也可以使用管道来传递数据。

  4. 条件变量

    • 结合互斥锁使用，用于线程间的等待和通知。

  5. 信号量

    • 用于控制多个线程对共享资源的访问。

例如，在一个多线程的生产者 - 消费者模型中，生产者线程和消费者线程通过共享的缓冲区（共享变量）和条件变量进行通信。生产者在生产数据时，若缓冲区已满，则等待条件变量；消费者在消费数据时，若缓冲区为空，也等待条件变量。

什么是友元？在 C++ 中如何使用？

友元是 C++ 中的一种特殊机制，允许一个类将其他函数或类声明为友元。

友元函数或友元类可以访问该类的私有成员和保护成员，就好像它们是公共成员一样。

使用友元的主要步骤如下：

在类的定义内部，使用 friend 关键字声明友元。

例如，假设有一个 ClassA 类，希望一个函数 func 能访问其私有成员，可以这样声明：

    

  1. 

    

    
class ClassA {
    

    2. 

  2. 

    

    
private:
    

    3. 

  3. 

    

        int privateMember;
    

    4. 

  4. 

    

    
public:
    

    5. 

  5. 

    

        friend void func(ClassA& obj);
    

    6. 

  6. 

    

    };
    

    7. 

  7. 

    

     
    

    8. 

  8. 

    

    
void func(ClassA& obj) {
    

    9. 

  9. 

    

        // 可以访问 obj 的私有成员 privateMember

    

    10. 

  10. 

    

    }
    

    11.

友元的使用可以增加程序的灵活性，但也破坏了类的封装性，应谨慎使用。

基类的构造函数和析构函数能否被派生类继承？

基类的构造函数和析构函数不能被派生类继承。

当创建派生类对象时，首先会调用基类的构造函数来初始化从基类继承的成员，然后调用派生类自己的构造函数来完成派生类特有的初始化工作。

在对象销毁时，析构函数的调用顺序则相反，先调用派生类的析构函数，然后调用基类的析构函数。

例如，有一个基类 Base 和派生类 Derived ，创建 Derived 对象时，先调用 Base 的构造函数，再调用 Derived 的构造函数；对象销毁时，先调用 Derived 的析构函数，再调用 Base 的析构函数。

哪些函数不能声明为虚函数？

以下类型的函数通常不能声明为虚函数：

  1. 构造函数

    • 构造函数用于对象的初始化，在对象完全构建之前，虚机制还未生效。

  2. 静态成员函数

    • 静态成员函数不与特定的对象实例相关联，而是与整个类相关，不符合虚函数基于对象多态性的特点。

  3. 内联函数

    • 内联函数通常在编译时展开，如果声明为虚函数，可能会导致一些不符合预期的结果。

例如，一个类的静态成员函数用于计算类中所有对象的总数，它不需要基于对象的多态性，所以不能声明为虚函数。

vector 的底层实现是怎样的？

vector 是 C++ 标准库中的动态数组容器。

其底层实现通常是通过连续的内存空间来存储元素。

当 vector 需要扩容时，会重新分配一块更大的连续内存空间，并将原有的元素复制到新的空间。

为了提高效率，vector 通常会预留一定的额外空间，以减少频繁扩容带来的性能开销。

例如，初始创建一个 vector 时，可能只分配了能容纳几个元素的空间。当添加的元素数量超过当前容量时，会进行扩容，比如容量翻倍。

什么是野指针？如何产生？如何避免？

野指针是指向无效内存地址的指针。

野指针产生的原因通常有以下几种：

  1. 指针未初始化

    • 如果一个指针没有被初始化就被使用，它可能指向任意的内存地址。

  2. 指针所指的内存已被释放

    • 当使用 delete 或 free 释放了指针所指向的内存后，如果继续使用该指针，就会成为野指针。

  3. 指针超出了其作用域

    • 例如在一个函数内部定义的指针，在函数结束后，指针所指向的内存可能已经不存在，但指针本身仍然存在。

避免野指针的方法包括：

  1. 初始化指针

    • 在定义指针时将其初始化为 NULL 或有效的内存地址。

  2. 释放内存后将指针置为 NULL

    • 这样在后续使用时可以通过判断指针是否为 NULL 来避免错误。

  3. 注意指针的作用域

    • 不要在作用域结束后继续使用该指针。

例如，在使用动态分配内存的指针时，在释放内存后立即将其置为 NULL ，并在使用前检查是否为 NULL 。

栈在 C 语言中有什么作用？

在 C 语言中，栈具有以下重要作用：

  1. 存储局部变量

    • 函数内部定义的非静态变量会在栈上分配空间，函数执行结束后自动释放，节省了内存管理的开销。

  2. 保存函数调用信息

    • 包括函数的返回地址、参数、调用者的栈帧指针等，使得函数能够正确地返回和恢复执行上下文。

  3. 临时数据存储

    • 例如在函数执行过程中产生的中间结果、临时变量等。

例如，当一个函数被调用时，其参数会被压入栈中，函数内部定义的局部变量也在栈上分配空间。函数执行完毕后，这些栈空间会自动释放，避免了手动管理内存的复杂性和错误。

C++ 的内存管理是如何进行的？

C++ 的内存管理主要通过以下几种方式：

  1. 自动存储

    • 局部变量通常在栈上分配，函数结束时自动释放。

  2. 动态存储

    • 使用 new 操作符在堆上分配内存，使用 delete 释放。

  3. 静态存储

    • 全局变量和静态变量在程序的整个生命周期内存在，存储在静态存储区。

在使用动态内存分配时，程序员需要负责正确地管理内存，避免内存泄漏和非法访问。

例如，创建一个动态分配的对象：MyClass* ptr = new MyClass(); ，使用完毕后要通过 delete ptr; 释放内存。

什么是内存泄漏？如何判断和减少内存泄漏？

内存泄漏是指程序在运行过程中，由于动态分配了内存但在不再使用后没有正确释放，导致这些内存无法被回收和再利用。

判断内存泄漏的方法：

  1. 使用内存检测工具，如 Valgrind 等。
  2. 监测内存使用的趋势，如果在程序运行过程中内存持续增长且不释放，可能存在泄漏。

减少内存泄漏的方法：

  1. 养成良好的编程习惯，使用 new 分配的内存一定要使用 delete 释放，使用 malloc 分配的内存要用 free 释放。
  2. 使用智能指针等自动管理内存的机制。
  3. 在复杂的程序中，建立完善的内存管理策略和规范。

例如，在一个长时间运行的服务器程序中，如果存在内存泄漏，会导致服务器性能逐渐下降甚至崩溃。通过定期使用内存检测工具进行检查，可以及时发现并修复泄漏问题。

字节对齐问题对程序有何影响？

字节对齐是为了提高内存访问的效率。

字节对齐问题对程序的影响主要包括：

  1. 性能影响

    • 未对齐的访问可能导致多次内存读取或写入，降低程序的运行效率。

  2. 可移植性问题

    • 不同的硬件平台可能有不同的对齐要求，如果程序没有考虑到，可能在某些平台上出现错误。

  3. 结构体空间浪费

    • 可能导致结构体内部的填充字节，增加存储空间的消耗。

例如，在一些对性能要求较高的实时系统中，字节未对齐的访问可能导致关键任务的延迟增加。

C 语言函数参数压栈顺序是怎样的？

在 C 语言中，函数参数的压栈顺序通常是从右到左。

即先将最右边的参数压入栈，然后依次向左压入。

这样的压栈顺序主要是为了支持可变参数函数的实现，使得在不知道参数具体数量和类型的情况下，能够正确地访问参数。

例如，对于函数 func(int a, int b) ，先压入 b ，再压入 a 。

C++ 如何处理返回值？

在 C++ 中，返回值的处理方式取决于返回值的类型和大小。

对于较小的对象，通常通过寄存器返回。如果返回值较大，可能通过在调用者的栈上分配空间，然后被调函数将返回值复制到该空间。

对于引用返回，可以直接返回对象的引用，避免复制。

例如，返回一个简单的整数可以通过寄存器，而返回一个大型对象可能通过在调用者的栈上分配空间来处理。

栈的空间最大值是多少？在 1G 内存的计算机中能否 malloc (1.2G)？为什么？

栈的空间最大值取决于操作系统和编译器的设置，通常在几兆字节到几十兆字节之间。

在 1G 内存的计算机中，不能使用 malloc(1.2G) ，因为 malloc 是在堆上分配内存，而堆的大小受到物理内存和虚拟内存的限制。

即使物理内存有 1G ，但系统还需要为其他进程和系统本身保留一定的内存资源，无法提供 1.2G 的连续可用内存空间。

例如，在一个资源紧张的系统中，过度的内存分配请求可能导致内存分配失败，甚至导致系统崩溃。

strcat、strncat、strcmp、strcpy 等函数在什么情况下会导致内存溢出？如何改进？

strcat 和 strcpy 函数在源字符串长度超过目标字符串的剩余空间时会导致内存溢出。

strncat 如果指定的复制长度过长，也可能导致溢出。

改进方法：

  1. 使用 strncpy 和 strncat 时，要确保指定的长度合理，并手动添加结束符。
  2. 自行实现更安全的字符串操作函数，在操作前先检查字符串长度。

例如，在一个用户输入处理的程序中，如果使用 strcpy 直接复制用户输入的字符串到固定长度的缓冲区，可能会因为用户输入过长而导致内存溢出。

malloc、calloc、realloc 等内存申请函数有何区别和使用场景？

malloc 函数用于分配指定大小的内存空间，但不进行初始化。

calloc 函数分配指定数量和大小的内存空间，并将其初始化为 0 。

realloc 函数用于重新调整已分配内存块的大小。

使用场景：

malloc 适用于对初始值不关心，只需要分配指定大小内存的情况。

calloc 适用于需要分配并初始化一块内存的情况，例如创建一个数组。

realloc 适用于在已分配内存的基础上需要调整大小的情况。

例如，创建一个动态数组时，开始可以使用 calloc 初始化，后续需要扩展时使用 realloc 。

相关文章