【CPP】内存泄漏详解

C++内存泄漏详解与解决方法
原创 已于 2025-04-08 11:25:51 修改 · 1.4k 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #linux #服务器 #算法

于 2025-04-07 20:16:53 首次发布

一、内存泄漏概念

内存泄漏（Memory Leak）是指程序在运行过程中申请了内存而未能释放，导致这部分内存无法被系统回收，从而造成内存资源的浪费。内存泄漏通常会逐渐积累，导致程序占用过多的内存资源，最终可能引发程序崩溃、系统卡顿，甚至在长时间运行的系统中发生内存溢出。内存泄漏问题在开发过程中必须引起足够重视，因为它会显著降低系统性能并影响程序的稳定性。

在 C++ 中，内存泄漏通常是由于开发者在使用动态内存分配（如 new / malloc）时未能正确释放内存（如未使用 delete / free）所导致。内存泄漏不仅仅发生在堆内存分配时，还可能发生在其他资源（如文件句柄、数据库连接等）未正确释放时。

二、内存泄漏常见场景

1）忘记释放堆内存

当使用 new 或 malloc 分配堆内存时，如果没有使用 delete 或 free 释放这部分内存，就会导致内存泄漏。这种情况是最常见的内存泄漏问题。忘记释放内存会导致程序持续占用内存，最终耗尽系统资源。

#include <iostream>

void leakMemory() {
    int* p = new int(10);  // 动态分配内存
    // 忘记释放内存
}

int main() {
    leakMemory();
    return 0;
}
  • 在上面的代码中，new int(10) 分配了堆内存，但没有释放内存，导致内存泄漏。程序退出时，系统无法回收这部分内存。

2）异常路径未释放资源

如果程序中发生异常，且没有适当地释放已分配的资源（例如堆内存、文件句柄等），也会导致内存泄漏。特别是在使用裸指针或手动资源管理时，容易漏掉释放的步骤。异常发生时未进行资源清理，常常会导致程序不稳定。

#include <iostream>
#include <stdexcept>

void functionWithException() {
    int* p = new int(20);  // 分配内存
    throw std::runtime_error("An error occurred");  // 异常发生
    delete p;  // 这行代码不会被执行
}

int main() {
    try {
        functionWithException();
    } catch (const std::exception& e) {
        std::cout << e.what() << std::endl;
    }
    return 0;
}
  • 在 functionWithException 函数中，分配了堆内存并抛出异常。由于 delete p 没有执行，导致分配的内存没有被释放。

3）容器中指针未清理

C++ 容器（如 std::vector, std::list, std::map）存储的是指向对象的指针。如果在容器中存储指针类型数据而没有正确释放对象的内存，会导致内存泄漏。容器在销毁时并不会自动释放容器内存中的指针对象。

#include <iostream>
#include <vector>

class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass destructor" << std::endl; }
};

void containerMemoryLeak() {
    std::vector<MyClass*> vec;
    for (int i = 0; i < 10; ++i) {
        vec.push_back(new MyClass());  // 分配内存
    }
    // 忘记调用 delete 删除指针
}

int main() {
    containerMemoryLeak();
    return 0;
}
  • 在 containerMemoryLeak 函数中，std::vector 存储了 MyClass 类型的裸指针。由于没有调用 delete 释放内存，这些指针指向的对象不会被销毁，导致内存泄漏。

4）循环引用

循环引用是指两个或多个对象互相持有对方的引用，导致它们的生命周期无法结束。这种情况通常发生在使用智能指针时，尤其是 std::shared_ptr，因为 shared_ptr 会引用计数，只要引用计数不为零，对象就不会被销毁。

#include <iostream>
#include <memory>

class A;

class B {
public:
    std::shared_ptr<A> a;
    ~B() { std::cout << "B destroyed" << std::endl; }
};

class A {
public:
    std::shared_ptr<B> b;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

void circularReference() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    
    a->b = b;  // A 拥有 B
    b->a = a;  // B 拥有 A
    // 循环引用导致 A 和 B 永远不会被销毁
}

int main() {
    circularReference();
    return 0;
}
  • 在 circularReference 函数中，A 类和 B 类相互持有 std::shared_ptr，造成了循环引用。由于 shared_ptr 会递增引用计数，导致 A 和 B 永远无法被销毁，内存泄漏发生。

5）系统资源泄漏

除此之外，程序中还可能发生其他类型的资源泄漏，特别是系统资源，如文件描述符、网络连接、数据库连接等。系统资源泄漏指的是在程序运行时，分配了某些资源但未能及时释放，导致这些资源无法再被使用，可能会导致系统性能下降或甚至崩溃。

常见的系统资源泄漏场景包括：

  • 文件描述符泄漏：在程序中打开文件后，没有及时关闭文件描述符，导致文件描述符在程序结束时依然保持打开状态。随着时间的推移，打开的文件描述符数量会累积，最终可能达到系统的最大文件描述符限制，导致程序无法再打开新的文件。
  • 网络连接泄漏：在程序中创建了网络连接（例如，套接字连接）后，如果没有适当关闭这些连接，会导致连接池资源被耗尽，从而影响程序的网络通信功能。
  • 数据库连接泄漏：在使用数据库时，如果没有关闭数据库连接池中的连接，会导致连接泄漏，最终导致数据库连接池中的连接数量达到上限，影响系统的数据库操作。
#include <iostream>
#include <fstream>

void fileLeak() {
    std::ofstream file("example.txt");  // 打开文件
    // 文件没有关闭，会导致文件描述符泄漏
    // 由于 file 对象是局部变量，程序结束时会自动析构，但如果没有显示调用 close()，会造成文件描述符泄漏
}

int main() {
    fileLeak();
    return 0;
}

三、内存泄漏避免

1) 使用智能指针

智能指针是 C++11 引入的一种指针类型，用于自动管理内存的分配和释放。std::unique_ptr 和 std::shared_ptr 是两种常用的智能指针，它们能够自动在超出作用域时释放内存，避免忘记释放的风险。

  • std::unique_ptr：用于独占所有权的智能指针。一个 unique_ptr 只能有一个所有者，因此当其作用域结束时，内存会自动释放。
  • std::shared_ptr：用于共享所有权的智能指针。多个 shared_ptr 可以共享同一个资源，只有当最后一个 shared_ptr 被销毁时，内存才会被释放。
#include <memory>

void exampleUniquePtr() {
    std::unique_ptr<int> p(new int(10));  // 使用 unique_ptr 自动管理内存
    // 不需要手动调用 delete，内存会在作用域结束时自动释放
}

void exampleSharedPtr() {
    std::shared_ptr<int> p1 = std::make_shared<int>(20);  // 使用 shared_ptr 自动管理内存
    std::shared_ptr<int> p2 = p1;  // p1 和 p2 共享内存
    // 内存会在 p1 和 p2 被销毁时自动释放
}

2) RAII 原则

RAII（Resource Acquisition Is Initialization）是 C++ 中的一种资源管理模式，意味着资源（如内存、文件句柄、网络连接等）在对象的构造函数中分配，并且在析构函数中释放。通过这种方式，可以确保资源在对象生命周期结束时被正确释放，从而避免内存泄漏。

#include <iostream>

class ResourceManager {
public:
    ResourceManager() {
        p = new int(10);  // 构造函数中分配资源
    }

    ~ResourceManager() {
        delete p;  // 析构函数中释放资源
    }

private:
    int* p;
};

void exampleRAII() {
    ResourceManager rm;  // 自动管理内存，RAII原理
    // 不需要手动释放内存，析构函数会自动调用
}

3) 避免裸指针长期持有资源

裸指针容易导致内存泄漏，特别是在长时间持有资源时。如果在某些情况下必须使用裸指针，确保有合适的释放逻辑。通常情况下，推荐使用智能指针来管理内存，避免裸指针长期持有资源。

#include <memory>

class MyClass {
public:
    void* ptr;
    MyClass() { 
        ptr = malloc(100);  // 分配内存
    }
    ~MyClass() {
        if (ptr) {
            free(ptr);  // 确保资源被释放
        }
    }
};

4) 规范编码

确保每个 new 对应一个 delete，每个 malloc 对应一个 free。为了避免内存泄漏，必须确保每次使用 new 或 malloc 分配内存时，都会有相应的 delete 或 free 语句释放内存。在复杂的函数中，特别是有多个分支的函数中，需要格外注意确保每条路径都能正确释放资源。

#include <iostream>

void safeMemoryManagement() {
    int* p = new int(10);  // 使用 new 分配内存
    if (p == nullptr) {
        // 内存分配失败的处理
        return;
    }

    // 确保在所有路径中都能释放内存
    delete p;  // 对应的 delete
}

5) 避免循环引用

循环引用通常发生在智能指针（特别是 std::shared_ptr）之间，导致对象永远不能被销毁。为了避免循环引用，可以使用 std::weak_ptr，它不会增加引用计数，从而避免循环引用带来的内存泄漏。

#include <iostream>
#include <memory>

class A;
class B {
public:
    std::weak_ptr<A> a;  // 使用 weak_ptr 避免循环引用
};

class A {
public:
    std::shared_ptr<B> b;
};

void fixCircularReference() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->b = b;
    b->a = a;  // 使用 weak_ptr 解决循环引用
}

int main() {
    fixCircularReference();
    return 0;
}

四、内存泄漏排查

内存泄漏的排查和定位是开发过程中重要的调试任务。尽早发现并修复内存泄漏能够提高程序的稳定性，减少系统资源的浪费。以下是一些常用的内存泄漏排查方法：

1) 使用内存检测工具

内存检测工具可以帮助开发人员检测和定位内存泄漏。最常用的工具包括：

  • Valgrind：Valgrind 是一个开源的内存调试工具，它能够在程序运行时监控内存的分配和释放，帮助开发者检测内存泄漏、越界访问、未初始化内存的使用等问题。Valgrind 提供了 memcheck 工具来检测内存泄漏。
  • AddressSanitizer：AddressSanitizer（简称 ASan）是一个快速的内存错误检测工具，能够检测内存泄漏、越界访问等问题。它通过编译时插桩，在程序运行时进行检查。
  • heaptrack：heaptrack 是一个专门用于跟踪 C++ 程序内存分配的工具，它能够提供详细的内存分配跟踪，并生成分析报告，帮助开发者精确定位内存泄漏问题。

2) 手动代码审查

除了工具，手动代码审查也是排查内存泄漏的重要手段。通过代码审查，开发人员可以查找可能的内存泄漏点，以下是常见的检查点：

  • 确保每个 new 或 malloc 都有相应的 delete 或 free： 对于每次动态内存分配，必须确保有对应的释放操作，避免遗忘释放。
  • 确保异常发生时的内存释放： 在函数中，特别是有异常处理的函数中，确保即使在异常发生时也能够释放已分配的内存。可以使用 RAII 原则（通过构造函数分配资源，析构函数释放资源）来避免异常未释放资源。
  • 查找是否有未释放的容器内存： 特别是在容器中存储动态分配的内存时，确保容器的析构函数正确释放内存。
  • 检查是否有裸指针的使用： 裸指针可能导致内存管理不当，使用智能指针（如 std::unique_ptr 和 std::shared_ptr）可以避免许多内存泄漏问题。
  • 检查 shared_ptr 是否存在循环引用： 在使用 std::shared_ptr 时，确保不存在循环引用的情况，循环引用会导致内存无法释放。可以使用 std::weak_ptr 来避免这种问题。

3) 日志和堆栈跟踪

通过在代码中加入日志打印，可以帮助开发者跟踪内存的分配和释放过程。特别是在调试复杂的程序时，堆栈跟踪信息也能帮助定位内存泄漏的根源。

  • 日志打印：可以在内存分配和释放的关键点添加日志，记录指针值和内存分配的上下文信息。

    #include <iostream>
	 
	 void* operator new(size_t size) {
     
     
	     std::cout << "Allocating memory of size " << size << " bytes\n";
	     return malloc(size);
	 }
	 
	 void operator delete(void* pointer) noexcept {
     
     
	     std::cout << "Freeing memory at " << pointer << "\n";
	     free(pointer);
	 }
	 
	 void exampleMemoryLeak() {
     
     
	     int* p = new int(10);
	     // 忘记释放内存
	 }
	 
	 int main() {
     
     
	     exampleMemoryLeak();
	     return 0;
	 }

  • 堆栈跟踪：使用调试器（如 GDB）时，启用调试符号并查看堆栈跟踪，帮助开发者更好地定位内存泄漏的根源。

    g++ -g your_program.cpp -o your_program
gdb ./your_program

4) 内存管理策略的优化

通过优化内存管理策略，可以减少内存泄漏的发生：

  • 使用智能指针：在 C++ 中，尽量使用智能指针（如 std::unique_ptr 和 std::shared_ptr），它们能够自动管理内存的分配和释放，避免手动管理带来的内存泄漏问题。
  • 使用容器和算法：在适当的情况下，使用标准库中的容器和算法（如 std::vector, std::map, std::string 等），这些容器能够自动管理内存，减少内存泄漏的风险。

五、Valgrind

1）Valgrind使用

  • valgrind [选项] <可执行程序>

    valgrind --leak-check=full --show-leak-kinds=all ./your_program

    • --leak-check=full：启用内存泄漏检测，并显示详细的泄漏信息。full 选项会提供有关内存泄漏的详细报告，包括泄漏的内存量、泄漏发生的代码行以及调用栈等信息。
    • --show-leak-kinds=all：显示所有类型的内存泄漏，包括直接泄漏、间接泄漏、可能泄漏等。
    • --track-origins=yes：追踪未初始化内存的来源。这对于调试未初始化内存访问非常有帮助。
    • --tool=memcheck：选择 memcheck 工具来进行内存检查，memcheck 是 Valgrind 默认的内存检查工具。
    • --log-file=<file>：将 Valgrind 的输出记录到指定的文件中。对于大型程序或长时间运行的程序，这个选项非常有用。
  • 编译代码时要使用-g选项

2）Valgrind输出

Valgrind 的输出可以帮助开发者详细了解程序中的内存问题，特别是内存泄漏的情况。以下是一个典型的 Valgrind 输出示例：

==1208228== Memcheck, a memory error detector
==1208228== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==1208228== Using Valgrind-3.18.1 and LibVEX; rerun with -h for copyright info
==1208228== Command: ./a.out
==1208228== 
==1208228== 
==1208228== HEAP SUMMARY:
==1208228==     in use at exit: 20 bytes in 1 blocks
==1208228==   total heap usage: 1 allocs, 0 frees, 20 bytes allocated
==1208228== 
==1208228== 20 bytes in 1 blocks are definitely lost in loss record 1 of 1
==1208228==    at 0x4848899: malloc (in /usr/libexec/valgrind/vgpreload_memcheck-amd64-linux.so)
==1208228==    by 0x1091B0: make_copy(char const*) (in /home/Raizeroko/code/MemoryLeak/a.out)
==1208228==    by 0x1091E4: main (in /home/Raizeroko/code/MemoryLeak/a.out)
==1208228== 
==1208228== LEAK SUMMARY:
==1208228==    definitely lost: 20 bytes in 1 blocks
==1208228==    indirectly lost: 0 bytes in 0 blocks
==1208228==      possibly lost: 0 bytes in 0 blocks
==1208228==    still reachable: 0 bytes in 0 blocks
==1208228==         suppressed: 0 bytes in 0 blocks
==1208228== 
==1208228== For lists of detected and suppressed errors, rerun with: -s
==1208228== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)
  • HEAP SUMMARY：
    • in use at exit: 20 bytes in 1 blocks：表示程序退出时，有 20 字节的内存依然在使用中，且是 1 个内存块。
    • total heap usage: 1 allocs, 0 frees, 20 bytes allocated：表示程序共进行了 1 次内存分配操作，且没有进行内存释放，分配了 20 字节的内存。
  • 内存泄漏详细信息：
    • 20 bytes in 1 blocks are definitely lost in loss record 1 of 1：表明程序确实发生了 20 字节的内存泄漏，这块内存没有被释放。
    • at 0x4848899: malloc：泄漏发生的位置是 malloc 函数内存分配的地方。
  • 泄漏发生的调用堆栈：
    • by 0x1091B0: make_copy(char const*)：表示泄漏的内存是在 make_copy 函数中分配的。
    • by 0x1091E4: main：泄漏发生在 main 函数中调用 make_copy 时。
  • LEAK SUMMARY：
    • definitely lost：真·泄漏，程序没有任何指针指向这块内存了
    • indirectly lost：间接泄漏，一块泄漏的内存引用了另一块
    • possibly lost：可能泄漏，Valgrind 不确定程序是否还保留了这块内存的地址
    • still reachable：程序结束时仍有指针指向，不一定是 bug，比如全局缓存
    • suppressed：被你通过配置 suppress 文件显式屏蔽的问题，Valgrind 不再报告它们。
  • ERROR SUMMARY：
    • 1 errors from 1 contexts (suppressed: 0 from 0)：表明总共检测到 1 个错误，且没有被抑制。

definitely lost、indirectly lost、possibly lost 和 still reachable 之间的区别

  • definitely lost（确定泄漏）

    这表示程序没有任何指针指向该内存块，内存已经丢失。也就是说，程序员再也无法访问到这块内存，它完全“失去了控制”。

    int main() {
      
      
    int* ptr = (int*)malloc(sizeof(int));  // 动态分配内存
    // 这里忘了释放内存
    return 0;
}

    • 泄漏信息

      ==12345== 4 bytes in 1 blocks are definitely lost in loss record 1 of 1
==12345==    at 0x4C2FB55: malloc (vg_replace_malloc.c:299)
==12345==    by 0x4011F3: main (main.cpp:5)

  • indirectly lost（间接泄漏）

    这种情况通常发生在某个指针指向的内存块无法释放，而该指针本身是由另一个对象或结构体所指向的。间接泄漏意味着某块内存可能是由于其他内存块的丢失而无法释放的。

     struct Node
最低0.47元/天 解锁文章
Raizeroko
关注
【C++内存泄漏】引发C++程序内存泄漏的原因分析与排查内存泄漏的方法总结
dvlinker的技术专栏
12-30 4万+
本文根据多年的项目实践以及遇到的多个内存泄漏的问题案例及场景，详细介绍引发内存泄漏的原因以及排查方法。
C++内存泄漏及解决方法
热门推荐
Clever_Pig的博客
07-13 3万+
1.首先说到c++内存泄漏时要知道它的含义？ 内存泄漏(memory leak)是指由于疏忽或错误造成了程序未能释放掉不再使用的内存的情况。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。 2.内存泄漏的后果？  最难捉摸也最难检测到的错误之一是内存泄漏，即未能正确释放以前分配的内存的 bug。 只发生一次的小的内
面试题目：内存泄漏
xikangsoon的博客
12-31 841
内存泄漏(memory leak)是指由于疏忽或错误造成了程序未能释放掉不再使用的内存的情况。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。 内存泄漏的分类： 1. 堆内存泄漏 （Heap leak）。对内存指的是程序运行中根据需要分配通过malloc,realloc new等从堆中分配的一块内存，再是完成后必须通过调...
关注我，内存泄漏和内存溢出的定义及其解决方案
最新发布
weixin_55617272的博客
09-22 1771
​理解区别​：​泄漏是“只进不出”，溢出是“要太多却没有”​。泄漏是原因，溢出可能是结果。​重在预防​：​C/C++​​：优先使用 ​智能指针和 ​RAII​ 机制管理资源。​​：理解垃圾回收机制，注意避免循环引用​（特别是被全局变量或静态变量引用），必要时使用弱引用。​所有语言​：注意及时释放非内存资源​（文件、连接等）。​善用工具​：在开发测试阶段积极使用内存检测工具来发现潜在问题。​监控与 profiling​：对长期运行的系统，进行持续的内存使用监控。
Java的内存泄漏
elimago的专栏
12-18 7993
Java的一个重要优点就是通过垃圾收集器(Garbage Collection，GC)自动管理内存的回收，程序员不需要通过调用函数来释放内存。因此，很多程序员认为Java不存在内存泄漏问题，或者认为即使有内存泄漏也不是程序的责任，而是GC或JVM的问题。其实，这种想法是不正确的，因为Java也存在内存泄露，但它的表现与C++不同。问题的提出 Java的一个重要优点就是通过垃圾收集器(G
关于内存泄漏
TTKatrina的博客
10-13 1834
概念 造成影响 内存是如何分配的 内存泄漏产生原因 内存泄漏的出现场景 1单例造成的内存泄漏 非静态内部类创建其静态实例造成内存泄漏 匿名内部类异步线程造成内存泄漏 Handler机制造成内存泄漏 资源未回收导致内存泄漏 使用新版Android Studio检测内存泄露和性能 我们怎么检测内存泄露呢 追踪内存分配 查询方法执行的时间 我们如何判断可能有问题的方法 Android内存分析命令
C/C++内存泄漏分析和解决方法
贫道绝缘子的博客
09-13 3879
本文详细介绍了C/C++编程中的内存泄漏问题以及预防、解决办法。
Unity IL2CPP内存泄漏追踪方案（基于Memory Profiler）技术详解
voidinit的专栏
04-11 1633
/ 若未执行将泄漏。// 需调用NativeFree(_nativePtr);// 强制GC确保数据准确性。Profiler-->>User: 展示增长对象Top10。Profiler->>Profiler: 对比A/B快照。User->>Profiler: 捕获快照A。User->>Profiler: 捕获快照B。User->>Game: 进入疑似泄漏场景。// 使用Profiler标记Native内存区域。// 使用WeakReference检测对象泄漏。// 敌人销毁时未从列表移除将导致泄漏。
内存泄漏
qq_45386840的博客
07-15 264
内存泄露 1.什么是内存泄露 内存泄露是指因为疏忽或者错误而造成程序未能释放、已经不再使用的内存的情况。内存泄露并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因此造成了内存的浪费。 2.内存泄露的危害 内存泄露有很大的危害，如果一个长期运行的程序出现内存泄露，影响很大，如操作系统、后台服务等等，一旦内存泄露就会导致程序的响应越来越慢，最终卡死。 3.主要的内存泄露类型 堆内存泄露（Heap leak） 堆内存指的是程序执行中依据需要分配通过mallo
内存泄露
zwb8848happy的专栏
04-09 899
1. 什么是内存泄露（memory leak）？  指由于疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。  A memory leak is a particular type of unintentional memory consump
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值