当前位置： 首页 > news >正文

嵌入式面试高频（5）！！！C++语言（嵌入式八股文，嵌入式面经）

news 来源：原创 2025/6/8 6:18:38

一、C++有几种传值方式之间的区别

一、值传递（Pass by Value）

  • 机制：创建参数的副本，函数内操作不影响原始数据
  • 语法：void func(int x)
  • 特点：
    • 数据安全：原始数据不受影响
    • 性能开销：需要复制大对象（如结构体、类）
    • 示例：
void increment(int x) { x++; } // 修改副本，不影响原始值
int a = 10;
increment(a); // a仍为10引用高效移动资源

 

二、指针传递（Pass by Pointer）

  • 机制：传递变量的地址，函数通过指针间接操作原始数据
  • 语法：void func(int* ptr)
  • 特点：
    • 可修改原始数据：通过*ptr修改
    • 空指针风险：需检查ptr != nullptr
    • 示例：
void increment(int* ptr) { if (ptr) (*ptr)++; // 安全检查
}
int a = 10;
increment(&a); // a变为11

 

三、引用传递（Pass by Reference）

  • 机制：传递变量的别名，函数直接操作原始数据
  • 语法：void func(int& ref)
  • 特点：
    • 可修改原始数据：直接操作引用
    • 安全性：引用必须初始化，无空引用
    • 示例：
void increment(int& ref) { ref++; } // 直接操作原始值
int a = 10;
increment(a); // a变为11

 

四、核心区别对比

特性值传递指针传递引用传递
操作对象副本原始数据（通过地址）原始数据（通过别名）
是否修改原值否是是
语法复杂度简单（直接传值）较复杂（需解引用）简单（类似值传递）
空值风险无有空指针风险无（必须初始化）
典型用途简单数据、只读操作需显式传递地址、可空对象参数、避免拷贝

五、示例对比 

// 值传递
void passByValue(int val) { val = 20; } // 不影响原始值// 指针传递
void passByPointer(int* ptr) { if (ptr) *ptr = 20; // 需检查空指针
}// 引用传递
void passByReference(int& ref) { ref = 20; } // 直接修改int main() {int x = 10;passByValue(x);     // x仍为10passByPointer(&x);  // x变为20passByReference(x); // x变为20return 0;
}

 

六、C++11 新增：右值引用（Move Semantics）

  • 机制：专门处理临时对象（右值）的引用，避免深拷贝
  • 语法：void func(Type&& rvalue)
  • 典型用途：移动构造函数、移动赋值运算符
  • 示例：
std::vector<int> createVector() {return std::vector<int>{1,2,3};
}std::vector<int> vec = createVector(); // 通过右值引用高效移动资源

 二.数组指针与指针数组的区别

一、核心区别

特性数组指针（Pointer to Array）指针数组（Array of Pointers）
本质指针：指向一个数组数组：存储多个指针
语法int (*ptr)[5];（括号强制 ptr 为指针）int* arr[5];（arr 先与 [] 结合为数组）
指向对象整个数组数组的元素（每个元素是一个指针）
指针运算ptr + 1 跳过整个数组（如 5 个 int）arr + 1 指向下一个元素（下一个指针）
典型用途传递多维数组、精确控制内存布局管理多个动态分配的对象、字符串数组

二、语法对比

1. 数组指针（指向数组的指针） 

int arr[5] = {1,2,3,4,5};
int (*ptr)[5] = &arr;  // 指向包含5个int的数组// 访问元素
(*ptr)[0] = 10;  // 修改arr[0]为10

2. 指针数组（包含指针的数组） 

 

int a = 1, b = 2, c = 3;
int* arr[3] = {&a, &b, &c};  // 数组的每个元素是int*// 访问元素
*arr[0] = 10;  // 修改a为10

 三、内存布局差异

1. 数组指针 

ptr ──> [1, 2, 3, 4, 5]  // 指向整个数组

 

  • ptr 存储整个数组的起始地址
  • sizeof(ptr) 为指针大小（通常 4/8 字节）

2. 指针数组 

arr ──> [&a, &b, &c]     // 数组元素为指针│    │    │▼    ▼    ▼a    b    c

 

  • arr 是一个数组，包含多个指针
  • sizeof(arr) 为 3 * sizeof(int*)

四、典型应用场景

1. 数组指针的应用
// 传递多维数组
void printMatrix(int (*matrix)[4], int rows) {for (int i = 0; i < rows; i++) {for (int j = 0; j < 4; j++) {printf("%d ", matrix[i][j]);}printf("\n");}
}int main() {int matrix[3][4] = {...};printMatrix(matrix, 3);  // matrix退化为int (*)[4]
}

 2. 指针数组的应用

// 字符串数组
const char* fruits[3] = {"Apple","Banana","Cherry"
};// 动态内存管理
int* ptrs[5];
for (int i = 0; i < 5; i++) {ptrs[i] = new int(i);
}

 

五、常见混淆点

1. 括号位置决定类型

 

int (*ptr)[5];  // 数组指针：ptr是指向包含5个int的数组的指针
int* ptr[5];    // 指针数组：ptr是包含5个int*的数组
2. 数组名 vs 数组指针
int arr[5];
int* ptr1 = arr;      // 指向首元素的指针（隐式转换）
int (*ptr2)[5] = &arr; // 指向整个数组的指针printf("%p\n", arr);     // 数组首元素地址
printf("%p\n", &arr);    // 整个数组的地址（数值相同，但类型不同）
printf("%p\n", arr + 1); // 跳过1个元素
printf("%p\n", &arr + 1); // 跳过整个数组（5个元素）

 三.指针函数与函数指针的区别

一、核心区别

特性指针函数（Function Returning Pointer）函数指针（Pointer to Function）
本质函数：返回值为指针类型指针：指向一个函数
语法int* func(int a);（返回 int*）int (*ptr)(int a);（ptr 为指针）
用途返回动态分配的内存或全局变量地址作为参数传递函数、实现回调机制
调用方式int* result = func(10);int val = (*ptr)(10); 或 ptr(10);

 

二、语法对比

1. 指针函数（返回指针的函数）
int* createArray(int size) {int* arr = new int[size];for (int i = 0; i < size; i++) {arr[i] = i;}return arr;  // 返回动态分配的数组指针
}// 调用
int* ptr = createArray(5);
2. 函数指针（指向函数的指针）
int add(int a, int b) { return a + b; }// 定义函数指针并初始化
int (*op)(int, int) = add;// 调用方式1
int result = (*op)(3, 4);  // 显式解引用// 调用方式2（C++允许隐式解引用）
int result2 = op(3, 4);    // 等价于上一行

 

三、典型应用场景

1. 指针函数的应用
// 返回静态变量的地址
const char* getMessage() {static const char* msg = "Hello";return msg;
}

 2. 函数指针的应用

// 回调函数示例
void process(int a, int b, int (*func)(int, int)) {int result = func(a, b);printf("Result: %d\n", result);
}int main() {int (*add)(int, int) = [](int a, int b) { return a + b; };process(3, 4, add);  // 输出7
}

 

四、常见混淆点

1. 括号位置决定类型
int* func(int a);  // 指针函数：返回int*
int (*ptr)(int a); // 函数指针：ptr指向返回int的函数

 2. 函数指针作为参数

// 排序函数接受比较函数指针
void sort(int* arr, int size, bool (*compare)(int, int)) {// 排序逻辑...
}bool ascending(int a, int b) { return a < b; }// 调用
sort(array, 10, ascending);

 四.malloc和calloc的区别

 

一、核心区别

特性malloccalloc
初始化不初始化分配的内存（内容随机）将内存初始化为 0
参数单个参数：所需内存字节数两个参数：元素数量和元素大小
原型void* malloc(size_t size);void* calloc(size_t num, size_t size);
性能略快（无需初始化）略慢（需清零内存）

二、示例对比

1. malloc 的使用

 

int* ptr = (int*)malloc(5 * sizeof(int));  // 分配5个int的内存
if (ptr != NULL) {// 内存内容未初始化，可能包含随机值for (int i = 0; i < 5; i++) {printf("%d ", ptr[i]);  // 输出随机值}
}
2. calloc 的使用
int* ptr = (int*)calloc(5, sizeof(int));  // 分配5个int的内存并初始化为0
if (ptr != NULL) {// 内存内容已初始化为0for (int i = 0; i < 5; i++) {printf("%d ", ptr[i]);  // 输出: 0 0 0 0 0}
}

 三、内存布局差异

 

// malloc分配的内存（未初始化）
ptr ──> [随机值][随机值][随机值][随机值][随机值]// calloc分配的内存（初始化为0）
ptr ──> [0][0][0][0][0]

四、安全与性能考量

  1. 安全性：

    • calloc适合需要初始化的场景（如存储结构体、数组）
    • malloc需手动初始化（如使用memset）：
int* ptr = malloc(5 * sizeof(int));
memset(ptr, 0, 5 * sizeof(int));  // 手动清零

 

  1. 性能：calloc因初始化操作会稍慢

    • 大数据块初始化可能影响性能

五、典型应用场景

场景推荐函数原因
存储需要初始化的数据calloc自动清零，避免未定义行为
存储无需初始化的数据malloc略高效
分配二进制缓冲区malloc后续会写入数据，无需提前初始化
分配结构体数组calloc确保结构体成员初始化为有效值

 五.内存泄漏，如何检测和避免？

一、什么是内存泄漏？

  • 定义：程序动态分配的内存（如malloc/new）未被正确释放（如free/delete），导致这部分内存永久无法被回收
  • 危害：
    • 随着程序运行，可用内存逐渐减少
    • 最终导致系统性能下降、程序崩溃或系统崩溃

二、内存泄漏的常见原因

  1. 忘记释放内存：

 

void func() {int* ptr = new int[100];  // 分配内存// 忘记调用delete[] ptr;
}

异常导致路径未释放：

void func() {int* ptr = new int[100];if (condition) {throw std::exception();  // 异常退出，未释放内存}delete[] ptr;
}

 指针覆盖：

int* ptr = new int;
ptr = new int;  // 原内存丢失，无法释放

 循环分配内存：

while (true) {int* ptr = new int[1000];  // 持续分配，无释放
}

 类中未定义析构函数：

class Resource {
public:Resource() { data = new int[100]; }// 未定义析构函数释放data
private:int* data;
};

 

三、检测内存泄漏的方法

1. 静态代码分析工具
  • 工具：Cppcheck、Clang-Tidy、PC-Lint
  • 特点：
    • 不运行程序，直接分析代码
    • 检测常见模式（如分配后未释放）
  • 示例命令：

cppcheck --enable=all --inconclusive your_file.cpp

2. 动态内存分析工具

  • Valgrind（Linux）：

  • valgrind --leak-check=full ./your_program

 

四、避免内存泄漏的最佳实践

1. RAII（资源获取即初始化）原则
  • 使用智能指针（C++）：

    cpp

    运行

    #include <memory>void func() {std::unique_ptr<int[]> ptr(new int[100]);  // 自动释放// 无需手动delete
}
2. 容器替代原始数组

cpp

运行

#include <vector>void func() {std::vector<int> data(100);  // 自动管理内存
}
3. 异常安全
  • 使用try-catch确保资源释放：

    cpp

    运行

    void func() {int* ptr = new int[100];try {// 可能抛出异常的代码} catch (...) {delete[] ptr;throw;}delete[] ptr;
}
4. 遵循配对原则
  • malloc → free
  • new → delete
  • new[] → delete[]
5. 避免指针浅拷贝
  • 使用深拷贝或禁用拷贝构造函数
  • 使用智能指针的移动语义
6. 代码审查
  • 重点检查：
    • 长时间运行的程序（如服务器）
    • 循环中的内存分配
    • 复杂函数中的多条返回路径

五、高级技术

1. 内存池（Memory Pool）
  • 预先分配大块内存，按需分配小块，减少系统调用
  • 避免频繁分配 / 释放导致的碎片
2. 智能指针的使用场景
类型用途
std::unique_ptr独占所有权
std::shared_ptr共享所有权（引用计数）
std::weak_ptr弱引用，避免循环引用

相关文章：

  • JAVA学习 DAY3 注释与编码规范讲解
  • Kerberos面试内容整理-未来发展趋势
  • SQL进阶之旅 Day 20：锁与并发控制技巧
  • 霍夫变换（Hough Transform）原理简要介绍
  • 基于51单片机的多功能洗衣机仿真
  • 食品计算—Food Portion Estimation via 3D Object Scaling
  • 力扣HOT100之二分查找：153. 寻找旋转排序数组中的最小值
  • 第二十八课：深度学习及pytorch简介
  • Vue3中computed和watch的区别
  • Faiss vs Milvus 深度对比：向量数据库技术选型指南
  • [面试精选] 0094. 二叉树的中序遍历
  • UDP 与 TCP 调用接口的差异：面试高频问题解析与实战总结
  • SQL慢可能是触发了ring buffer
  • Ubuntu下有关UDP网络通信的指令
  • Vue学习之---nextTick
  • 《经济学原理》第9版第5章弹性及其应用
  • Nodejs工程化实践：构建高性能前后端交互系统
  • PC与Windows远程连接与串流：方案简介（ZeroTier + Parsec、Moonlight + Sunshine、网易UU远程）
  • [C++] list双向链表使用方法
  • Spring AI 核心工作流
  • 网站优化哪里好/全国疫情突然又严重了
  • 怎么用div做网站/超级优化大师下载
  • 驻马店网站建设zmdsem/广东seo排名
  • 门户网站建设统计表/广州推广引流公司
  • app定制公司/新乡网站seo
  • 北京优化网站公司/百度产品优化排名软件