EEPW论坛

内存泄漏是嵌入式系统开发中一个严峻的问题，尤其在资源有限的环境中。

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

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

在嵌入式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_ptr
ptr(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_ptr
ptr;
    try {
        ptr = std::unique_ptr
(new int(10)); // 分配内存
        someFunctionThatThrows(); // 可能抛出异常的函数
    } catch(...) {
        // 智能指针会自动释放内存，即使抛出异常
        throw; // 重新抛出异常
    }
}

场景三：循环引用导致的内存泄漏

在使用共享指针（shared_ptr）时，对象之间的循环引用可能导致内存泄漏，因为每个共享指针都引用对方，导致引用计数永远不为零。

class Node {
public:
    std::shared_ptr
next;
    std::shared_ptr
prev;
};
int main() {
    std::shared_ptr
node1(new Node());
    std::shared_ptr
node2(new Node());
    node1->next = node2;
    node2->prev = node1;
    // 此时node1和node2互相引用，无法被自动释放
    return 0;
}

在这个例子中，node1和node2互相引用，导致它们的引用计数永远不为零，无法被自动释放，从而导致内存泄漏。

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

class Node {
public:
    std::shared_ptr
next;
    std::weak_ptr
prev;
};
int main() {
    std::shared_ptr
node1(new Node());
    std::shared_ptr
node2(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的整数数组。这可能导致栈溢出，引发堆栈崩溃。

减少递归深度：将递归转换为迭代，或者减少递归深度。增加栈大小：在编译或运行时增加程序的栈大小。使用内存池：将大数组的分配从栈上转移到堆上。

场景五：使用不规范的库接口

某些旧库或API可能需要显式内存管理，使用不当可能导致内存泄漏。

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

在这个例子中，someOldAPIFunction()函数可能在堆上分配了一个字符缓冲区，并返回指针。

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

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

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