嵌入式开发中C++内存泄漏的场景与解决办法

电子设计联盟 · 发表于 2025-4-4 08:04:00

vlr0xxq4nbg64014261741.gif

点击上方蓝色字体，关注我们

与桌面应用程序不同，嵌入式系统通常具有严格的内存限制，即使是小规模的内存泄漏也可能迅速导致系统崩溃或功能异常。

内存泄漏是指程序在申请内存后，无法释放已经不再使用的内存空间，通常发生在程序员创建了一个新的内存块，但忘记在使用完之后释放它。

在嵌入式C++开发中，内存泄漏的常见原因包括：

忘记释放动态分配的内存：最常见的内存泄漏原因，程序员分配了内存但忘记在不再需要时释放它。

异常处理不当：在函数执行过程中发生异常，导致提前退出，而未释放之前分配的内存。

循环引用：对象之间相互引用，导致它们的引用计数永远不为零，无法被正确释放。

递归调用过深或栈上分配大量数据：这可能导致堆栈崩溃，表现为内存泄漏。

使用不规范的库接口：某些旧库或API需要显式内存管理，使用不当可能导致内存泄漏。
场景一：忘记释放动态分配的内存
这是最常见的内存泄漏原因。当使用new关键字分配内存后，如果没有调用delete操作符释放内存，就会导致内存泄漏。

void someFunction() { int* ptr = new int(10); // 分配内存 // 没有 delete，导致内存泄漏}在这个例子中，someFunction函数分配了一个整数指针ptr，但在函数结束时没有释放这个内存。

当函数返回时，ptr将被销毁，但分配的内存仍然存在，无法被访问，从而导致内存泄漏。

确保在不再需要内存时调用delete释放它。

void someFunction() { int* ptr = new int(10); // 分配内存 delete ptr; // 释放内存}或者，使用智能指针自动管理内存：

void someFunction() { std::unique_ptrptr(new int(10)); // 使用智能指针 // 智能指针会自动释放内存}场景二：异常情况下的内存泄漏
当函数执行过程中发生异常，可能会导致提前退出，而未释放之前分配的内存，从而造成内存泄漏。

void someFunction() { int* ptr = new int(10); // 分配内存 // 可能在此处引发异常 someFunctionThatThrows(); }如果someFunctionThatThrows()函数抛出异常，控制流会直接跳到catch块或函数外，而不会执行后续的代码。

这意味着ptr指向的内存将永远不会被释放，导致内存泄漏。

使用try-catch块捕获异常，并确保在异常情况下释放已分配的内存。

void someFunction() { int* ptr = nullptr; try { ptr = new int(10); // 分配内存 someFunctionThatThrows(); // 可能抛出异常的函数 } catch(...) { delete ptr; // 释放内存 throw; // 重新抛出异常 }}或者，使用智能指针自动管理内存：

void someFunction() { std::unique_ptrptr; try { ptr = std::unique_ptr(new int(10)); // 分配内存 someFunctionThatThrows(); // 可能抛出异常的函数 } catch(...) { // 智能指针会自动释放内存，即使抛出异常 throw; // 重新抛出异常 }}
场景三：循环引用导致的内存泄漏
在使用共享指针（shared_ptr）时，对象之间的循环引用可能导致内存泄漏，因为每个共享指针都引用对方，导致引用计数永远不为零。

class Node {public: std::shared_ptrnext; std::shared_ptrprev;};int main() { std::shared_ptrnode1(new Node()); std::shared_ptrnode2(new Node()); node1->next = node2; node2->prev = node1; // 此时node1和node2互相引用，无法被自动释放 return 0;}在这个例子中，node1和node2互相引用，导致它们的引用计数永远不为零，无法被自动释放，从而导致内存泄漏。

使用弱指针（weak_ptr）打破循环引用：

class Node {public: std::shared_ptrnext; std::weak_ptrprev;};int main() { std::shared_ptrnode1(new Node()); std::shared_ptrnode2(new Node()); node1->next = node2; node2->prev = node1; // 当node1被销毁后，node2的prev将不再有效 return 0;}
场景四：递归调用过深导致的堆栈崩溃
在C/C++编程中，堆栈崩溃是一种常见的错误，它通常是由于递归调用过深、内存溢出或者栈上分配的大量数据导致栈空间耗尽而引发的。

void recursiveFunction(int depth) { int array[1000]; // 在栈上分配大量数据 if (depth 1000) { recursiveFunction(depth + 1); }}int main() { recursiveFunction(0); // 可能导致栈溢出 return 0;}在这个例子中，recursiveFunction函数递归调用自身1000次，并且每次在栈上分配一个大小为1000的整数数组。这可能导致栈溢出，引发堆栈崩溃。

减少递归深度：将递归转换为迭代，或者减少递归深度。

增加栈大小：在编译或运行时增加程序的栈大小。

使用内存池：将大数组的分配从栈上转移到堆上。[/ol]
场景五：使用不规范的库接口
某些旧库或API可能需要显式内存管理，使用不当可能导致内存泄漏。

void someFunction() { char* buffer = someOldAPIFunction(); // 分配内存 // 使用缓冲区 // 没有释放内存}在这个例子中，someOldAPIFunction()函数可能在堆上分配了一个字符缓冲区，并返回指针。

如果调用者没有显式释放这个内存，就会导致内存泄漏。

确保在不再需要内存时调用适当的释放函数：

void someFunction() { char* buffer = someOldAPIFunction(); // 分配内存 // 使用缓冲区 free(buffer); // 释放内存}

rm22s4ajyzj64014261841.jpg

ccvzbg1coya64014261941.gif

点击阅读原文，更精彩~