嵌入式面试高频（5）！！！C++语言（嵌入式八股文，嵌入式面经）
一、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仍为10
passByPointer(&x); // x变为20
passByReference(x); // x变为20
return 0;
}
六、C++11 新增：右值引用（Move Semantics）
- 机制：专门处理临时对象（右值）的引用，避免深拷贝
- 语法：
void func(Type&& rvalue) - 典型用途：移动构造函数、移动赋值运算符
- 示例：
std::vector createVector() {
return std::vector{1,2,3};
}
std::vector 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]为102. 指针数组（包含指针的数组）
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的区别
一、核心区别
| 特性 | malloc |
calloc |
|---|---|---|
| 初始化 | 不初始化分配的内存（内容随机） | 将内存初始化为 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) {
// 内存内容已初始化为0
for (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]四、安全与性能考量
-
安全性：
calloc适合需要初始化的场景（如存储结构体、数组）malloc需手动初始化（如使用memset）：
int* ptr = malloc(5 * sizeof(int));
memset(ptr, 0, 5 * sizeof(int)); // 手动清零
-
性能：
calloc因初始化操作会稍慢- 大数据块初始化可能影响性能
五、典型应用场景
| 场景 | 推荐函数 | 原因 |
|---|---|---|
| 存储需要初始化的数据 | calloc |
自动清零，避免未定义行为 |
| 存储无需初始化的数据 | malloc |
略高效 |
| 分配二进制缓冲区 | malloc |
后续会写入数据，无需提前初始化 |
| 分配结构体数组 | calloc |
确保结构体成员初始化为有效值 |
五.内存泄漏，如何检测和避免？
一、什么是内存泄漏？
- 定义：程序动态分配的内存（如
malloc/new）未被正确释放（如free/delete），导致这部分内存永久无法被回收 - 危害：
- 随着程序运行，可用内存逐渐减少
- 最终导致系统性能下降、程序崩溃或系统崩溃
二、内存泄漏的常见原因
-
忘记释放内存：
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
运行
#includevoid func() { std::unique_ptr
2. 容器替代原始数组
cpp
运行
#include
void func() {
std::vector data(100); // 自动管理内存
}
3. 异常安全
- 使用
try-catch确保资源释放：cpp
运行
void func() { int* ptr = new int[100]; try { // 可能抛出异常的代码 } catch (...) { delete[] ptr; throw; } delete[] ptr; }
4. 遵循配对原则
malloc→freenew→deletenew[]→delete[]
5. 避免指针浅拷贝
- 使用深拷贝或禁用拷贝构造函数
- 使用智能指针的移动语义
6. 代码审查
- 重点检查：
- 长时间运行的程序（如服务器）
- 循环中的内存分配
- 复杂函数中的多条返回路径
五、高级技术
1. 内存池（Memory Pool）
- 预先分配大块内存，按需分配小块，减少系统调用
- 避免频繁分配 / 释放导致的碎片
2. 智能指针的使用场景
| 类型 | 用途 |
|---|---|
std::unique_ptr |
独占所有权 |
std::shared_ptr |
共享所有权（引用计数） |
std::weak_ptr |
弱引用，避免循环引用 |