C++内存泄漏检测工具(Valgrind之memcheck)

已于 2023-08-27 16:30:19 修改
阅读量415 收藏
点赞数
分类专栏： c++之valgrind 文章标签： c++
于 2023-08-27 16:22:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/youngzhiyong/article/details/132524663
版权

文章目录

应用场景

请想象以下场景：
辛苦了几个星期，新鲜出炉的几K代码，终于运行起来了。开始测试各项功能指标，一顿操作猛如虎，几个小时过去了，正当准备测试最后一项的时候，程序崩溃了。经过一顿定位，查看日志，发现内存申请失败了。

其实，对于程序员来说，这再正常不过的家常便饭了，谁还没写出过bug，谁还没写出过内存泄漏的代码，只是泄漏多与少的问题。不要慌，不要乱，带上你的排坑卫士Valgrind一起跑，等程序运行结束了，就会给出坑位在哪儿的地图，然后再根据地图指示进行快速填坑。

内存泄漏的常见情况

一句话：内存申请使用后，未释放内存。

细分：

  • malloc/calloc/realloc之后，未使用free释放内存
  • new之后，未使用delete释放内存
  • 多线程场景下：未做多线程保护，重复为同一个变量申请内存
  • 线程未正常退出，资源未释放

内存泄漏检测工具局限性

  • 只能检测程序运行过的流程中的内存资源是否存在泄漏，未运行的流程分支，都无法检测。因为未运行，就不涉及内存的申请与释放。因此，需要覆盖完全的话，则需要覆盖所有的分支和流程。
  • 如果程序退出时，还与申请内存的变量在同一个作用域范围内，无法检测到内存泄漏
  • 仅支持程序的正常退出和信号为SIGINT(ctrl+c)的程序退出，不支持kill -9程序的操作

工具安装

1. 下载开源软件包

请点击valgrind 3.21.0.tar.bz2下载。或直接在valgrind官网下载最新的版本。

2. 编译安装

解压软件包：

tar -xf valgrind-3.21.0.tar.bz2

编译软件包：

cd valgrind-3.21.0
sudo mkdir -p /home/soft/valgrind
./configure --prefix=/home/soft/valgrind    # 软件包安装位置:/home/soft/valgrind
sudo make install

3.配置环境变量

配置环境变量，支持在Linux的任何一个目录，都支持访问valgrind可执行程序.

vim ~/.bashrc

# begin: 以下内存为 ~/.bashrc 文件尾部追加
export PATH=$PATH:/home/soft/valgrind/bin
# end: 以上内存为 ~/.bashrc 文件尾部追加

source ~/.bashrc

4.检查安装结果

valgrind --version # 在Linux的任何一个目录中执行此命令

工具使用

1.编译未优化，且带调试信息版本的可执行程序

g++ Xxxx.cpp -O0 -o Xxxx

2.程序运行

日志文件中%p，代表不同的进程，每次运行避免日志文件被覆盖。

valgrind --tool=memcheck --leak-check=full --log-file=Xxxx%p.log ./Xxxx

3.查看报告结果
找到运行输出的日志文件Xxxx%.log。

  • definitely lost：表示明确的内存泄漏，必须解决清0
  • indirectly lost:表示间接的内存泄漏，必须解决清0
  • possibly lost:可能内存泄漏，需要再排查一下，是否在进程退出时，内存的泄漏。

常见场景举例

不存在内存泄漏

代码示例：

#include <cstdlib>

void Demo()
{
    int* ptr = reinterpret_cast<int*>(malloc(10 * sizeof(int)));    
    if (ptr != nullptr) {
        free(ptr);
    }
}

int main()
{
    Demo();

    return 0;
}

通过工具使用章节，运行后的结果如下：

==273== Memcheck, a memory error detector
==273== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==273== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==273== Command: ./test
==273== Parent PID: 186
==273== 
==273== 
==273== HEAP SUMMARY:
==273==     in use at exit: 0 bytes in 0 blocks
==273==   total heap usage: 1 allocs, 1 frees, 40 bytes allocated
==273== 
==273== All heap blocks were freed -- no leaks are possible
==273== 
==273== For lists of detected and suppressed errors, rerun with: -s
==273== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

malloc内存未free

代码示例：

#include <cstdlib>

void Demo()
{
    int* ptr = reinterpret_cast<int*>(malloc(10 * sizeof(int)));    
}

int main()
{
    Demo();

    return 0;
}

通过工具使用章节，运行后的结果如下：

==337== Memcheck, a memory error detector
==337== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==337== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==337== Command: ./test
==337== Parent PID: 186
==337== 
==337== 
==337== HEAP SUMMARY:
==337==     in use at exit: 40 bytes in 1 blocks
==337==   total heap usage: 1 allocs, 0 frees, 40 bytes allocated
==337== 
==337== 40 bytes in 1 blocks are definitely lost in loss record 1 of 1
==337==    at 0x483B7F3: malloc (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==337==    by 0x10915E: Demo() (in /tmp/memleak/test)
==337==    by 0x109172: main (in /tmp/memleak/test)
==337== 
==337== LEAK SUMMARY:
==337==    definitely lost: 40 bytes in 1 blocks
==337==    indirectly lost: 0 bytes in 0 blocks
==337==      possibly lost: 0 bytes in 0 blocks
==337==    still reachable: 0 bytes in 0 blocks
==337==         suppressed: 0 bytes in 0 blocks
==337== 
==337== For lists of detected and suppressed errors, rerun with: -s
==337== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

解决方案

使用free释放内存

new内存未delete

代码示例：

void Demo()
{
    int* ptr = new int[10]();    
}

int main()
{
    Demo();

    return 0;
}

通过工具使用章节，运行后的结果如下：

==392== Memcheck, a memory error detector
==392== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==392== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==392== Command: ./test
==392== Parent PID: 186
==392== 
==392== 
==392== HEAP SUMMARY:
==392==     in use at exit: 40 bytes in 1 blocks
==392==   total heap usage: 2 allocs, 1 frees, 72,744 bytes allocated
==392== 
==392== 40 bytes in 1 blocks are definitely lost in loss record 1 of 1
==392==    at 0x483C583: operator new[](unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==392==    by 0x10915E: Demo() (in /tmp/memleak/test)
==392==    by 0x109192: main (in /tmp/memleak/test)
==392== 
==392== LEAK SUMMARY:
==392==    definitely lost: 40 bytes in 1 blocks
==392==    indirectly lost: 0 bytes in 0 blocks
==392==      possibly lost: 0 bytes in 0 blocks
==392==    still reachable: 0 bytes in 0 blocks
==392==         suppressed: 0 bytes in 0 blocks
==392== 
==392== For lists of detected and suppressed errors, rerun with: -s
==392== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

解决方案

使用delete释放内存

new[]内存使用delete

代码示例：

void Demo()
{
    int* ptr = new int[10]();    
    if (ptr != nullptr) {
        delete ptr;
    }
}

int main()
{
    Demo();

    return 0;
}

通过工具使用章节，运行后的结果如下：

不存在内存泄漏，但是内存申请和释放不匹配。

==478== Memcheck, a memory error detector
==478== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==478== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==478== Command: ./test
==478== Parent PID: 186
==478== 
==478== Mismatched free() / delete / delete []
==478==    at 0x483D1CF: operator delete(void*, unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==478==    by 0x1091BF: Demo() (in /tmp/memleak/test)
==478==    by 0x1091CF: main (in /tmp/memleak/test)
==478==  Address 0x4db1c80 is 0 bytes inside a block of size 40 alloc'd
==478==    at 0x483C583: operator new[](unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==478==    by 0x10917E: Demo() (in /tmp/memleak/test)
==478==    by 0x1091CF: main (in /tmp/memleak/test)
==478== 
==478== 
==478== HEAP SUMMARY:
==478==     in use at exit: 0 bytes in 0 blocks
==478==   total heap usage: 2 allocs, 2 frees, 72,744 bytes allocated
==478== 
==478== All heap blocks were freed -- no leaks are possible
==478== 
==478== For lists of detected and suppressed errors, rerun with: -s
==478== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

解决方案

使用delete[]释放内存

多线程重复申请

代码示例：

#include <thread>
#include <vector>
using namespace std;

int* g_ptr = nullptr;

void Run()
{
    g_ptr = new int[10]();
}

void MultiThread()
{
    vector<thread> threads;
    constexpr int num = 10;
    for (int i = 0; i < num; ++i) {
        threads.emplace_back(thread(Run));
    }

    for (auto& th : threads) {
        th.join();
    }
}

int main()
{
    MultiThread();

    if (g_ptr != nullptr) {
        delete[] g_ptr;
    }

    return 0;
}

注意：涉及多线程时，编译需要增加 -lpthread 的链接选项。

通过工具使用章节，运行后的结果如下：

==2281== Memcheck, a memory error detector
==2281== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==2281== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==2281== Command: ./test
==2281== Parent PID: 186
==2281== 
==2281== 
==2281== HEAP SUMMARY:
==2281==     in use at exit: 360 bytes in 9 blocks
==2281==   total heap usage: 36 allocs, 27 frees, 76,392 bytes allocated
==2281== 
==2281== 360 bytes in 9 blocks are definitely lost in loss record 1 of 1
==2281==    at 0x483C583: operator new[](unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==2281==    by 0x10933A: Run() (in /tmp/memleak/test)
==2281==    by 0x10B009: void std::__invoke_impl<void, void (*)()>(std::__invoke_other, void (*&&)()) (in /tmp/memleak/test)
==2281==    by 0x10AFA1: std::__invoke_result<void (*)()>::type std::__invoke<void (*)()>(void (*&&)()) (in /tmp/memleak/test)
==2281==    by 0x10AF33: void std::thread::_Invoker<std::tuple<void (*)()> >::_M_invoke<0ul>(std::_Index_tuple<0ul>) (in /tmp/memleak/test)
==2281==    by 0x10AEF0: std::thread::_Invoker<std::tuple<void (*)()> >::operator()() (in /tmp/memleak/test)
==2281==    by 0x10AEC1: std::thread::_State_impl<std::thread::_Invoker<std::tuple<void (*)()> > >::_M_run() (in /tmp/memleak/test)
==2281==    by 0x4956DE3: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==2281==    by 0x4865608: start_thread (pthread_create.c:477)
==2281==    by 0x4B9C132: clone (clone.S:95)
==2281== 
==2281== LEAK SUMMARY:
==2281==    definitely lost: 360 bytes in 9 blocks
==2281==    indirectly lost: 0 bytes in 0 blocks
==2281==      possibly lost: 0 bytes in 0 blocks
==2281==    still reachable: 0 bytes in 0 blocks
==2281==         suppressed: 0 bytes in 0 blocks
==2281== 
==2281== For lists of detected and suppressed errors, rerun with: -s
==2281== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

解决方案

多线程场景下，需要对共同写的变量做互斥保护。

线程运行未结束异常退出

代码示例：

#include <chrono>
#include <thread>
using namespace std;

void Run()
{
    this_thread::sleep_for(chrono::seconds(10));
}

void OneThread()
{
    thread th(Run);
    th.join();
}

int main()
{
    OneThread();

    return 0;
}

注：该程序，需要在程序未运行结束之前使用ctrl+c终止程序。

通过工具使用章节，运行后的结果如下：

==2526== Memcheck, a memory error detector
==2526== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==2526== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==2526== Command: ./test
==2526== Parent PID: 186
==2526== 
==2526== 
==2526== Process terminating with default action of signal 2 (SIGINT)
==2526==    at 0x4866CD7: __pthread_clockjoin_ex (pthread_join_common.c:145)
==2526==    by 0x4957046: std::thread::join() (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==2526==    by 0x1092FB: OneThread() (in /tmp/memleak/test)
==2526==    by 0x109350: main (in /tmp/memleak/test)
==2526== 
==2526== HEAP SUMMARY:
==2526==     in use at exit: 304 bytes in 2 blocks
==2526==   total heap usage: 3 allocs, 1 frees, 73,008 bytes allocated
==2526== 
==2526== 288 bytes in 1 blocks are possibly lost in loss record 2 of 2
==2526==    at 0x483DD99: calloc (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==2526==    by 0x40149DA: allocate_dtv (dl-tls.c:286)
==2526==    by 0x40149DA: _dl_allocate_tls (dl-tls.c:532)
==2526==    by 0x4866322: allocate_stack (allocatestack.c:622)
==2526==    by 0x4866322: pthread_create@@GLIBC_2.2.5 (pthread_create.c:660)
==2526==    by 0x49570A8: std::thread::_M_start_thread(std::unique_ptr<std::thread::_State, std::default_delete<std::thread::_State> >, void (*)()) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==2526==    by 0x109838: std::thread::thread<void (&)(), , void>(void (&)()) (in /tmp/memleak/test)
==2526==    by 0x1092EF: OneThread() (in /tmp/memleak/test)
==2526==    by 0x109350: main (in /tmp/memleak/test)
==2526== 
==2526== LEAK SUMMARY:
==2526==    definitely lost: 0 bytes in 0 blocks
==2526==    indirectly lost: 0 bytes in 0 blocks
==2526==      possibly lost: 288 bytes in 1 blocks
==2526==    still reachable: 16 bytes in 1 blocks
==2526==         suppressed: 0 bytes in 0 blocks
==2526== Reachable blocks (those to which a pointer was found) are not shown.
==2526== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==2526== 
==2526== For lists of detected and suppressed errors, rerun with: -s
==2526== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

解决方案

此种场景主要是程序退出时未正常释放内存资源，出现的可能内存泄漏。让运行的线程能够正常的退出。

memcheck无法检测的场景

此种场景，是无法检测出内存泄漏的。

申请内存在同一个上下文，程序异常退出

代码示例：

#include <thread>
#include <chrono>
using namespace std;

int main()
{
    int* ptr = new int[10]();

    this_thread::sleep_for(chrono::seconds(10));

    return 0;
}

注：该程序，需要在程序未运行结束之前使用ctrl+c终止程序。

通过工具使用章节，运行后的结果如下：

==3189== Memcheck, a memory error detector
==3189== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==3189== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==3189== Command: ./test
==3189== Parent PID: 186
==3189== 
==3189== 
==3189== Process terminating with default action of signal 2 (SIGINT)
==3189==    at 0x4B1C1B4: clock_nanosleep@@GLIBC_2.17 (clock_nanosleep.c:78)
==3189==    by 0x4B21EC6: nanosleep (nanosleep.c:27)
==3189==    by 0x10959D: void std::this_thread::sleep_for<long, std::ratio<1l, 1l> >(std::chrono::duration<long, std::ratio<1l, 1l> > const&) (in /tmp/memleak/test)
==3189==    by 0x109217: main (in /tmp/memleak/test)
==3189== 
==3189== HEAP SUMMARY:
==3189==     in use at exit: 40 bytes in 1 blocks
==3189==   total heap usage: 2 allocs, 1 frees, 72,744 bytes allocated
==3189== 
==3189== LEAK SUMMARY:
==3189==    definitely lost: 0 bytes in 0 blocks
==3189==    indirectly lost: 0 bytes in 0 blocks
==3189==      possibly lost: 0 bytes in 0 blocks
==3189==    still reachable: 40 bytes in 1 blocks
==3189==         suppressed: 0 bytes in 0 blocks
==3189== Reachable blocks (those to which a pointer was found) are not shown.
==3189== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==3189== 
==3189== For lists of detected and suppressed errors, rerun with: -s
==3189== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

容器或者缓存一直增长

代码示例：

#include <cstdint>
#include <thread>
#include <chrono>
#include <vector>

using namespace std;

vector<uint32_t> g_memPool;

void Fun(uint32_t num)
{
    g_memPool.push_back(num);
}

int32_t main()
{
    for (uint8_t i = 0; i < 256; ++i) {
        Fun(i);
        this_thread::sleep_for(chrono::milliseconds(10));
    }

    return 0;
}

注：该程序，需要在程序未运行结束之前使用ctrl+c终止程序。

通过工具使用章节，运行后的结果如下：

==636== Memcheck, a memory error detector
==636== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==636== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==636== Command: ./test
==636== Parent PID: 383
==636== 
==636== 
==636== Process terminating with default action of signal 2 (SIGINT)
==636==    at 0x4B371B4: clock_nanosleep@@GLIBC_2.17 (clock_nanosleep.c:78)
==636==    by 0x4B3CEC6: nanosleep (nanosleep.c:27)
==636==    by 0x109908: void std::this_thread::sleep_for<long, std::ratio<1l, 1000l> >(std::chrono::duration<long, std::ratio<1l, 1000l> > const&) (in /tmp/memleak/test)
==636==    by 0x10933D: main (in /tmp/memleak/test)
==636== 
==636== HEAP SUMMARY:
==636==     in use at exit: 32,768 bytes in 1 blocks
==636==   total heap usage: 15 allocs, 14 frees, 138,236 bytes allocated
==636== 
==636== LEAK SUMMARY:
==636==    definitely lost: 0 bytes in 0 blocks
==636==    indirectly lost: 0 bytes in 0 blocks
==636==      possibly lost: 0 bytes in 0 blocks
==636==    still reachable: 32,768 bytes in 1 blocks
==636==         suppressed: 0 bytes in 0 blocks
==636== Reachable blocks (those to which a pointer was found) are not shown.
==636== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==636== 
==636== For lists of detected and suppressed errors, rerun with: -s
==636== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

question

以上的两种情况该如何通过工具检测出来呢？请看下集内存使用统计工具

youngzhiyong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++内存检测工具valgrind--memcheck
Peerless__的博客
10-09 2963
Valgrind简介 Valgrind是运行在Linux上的一套基于仿真技术的程序调试和分析工具，作者是获得过Google-O’Reilly开源大奖的Julian Seward，它包含一个内核 —— 一个软件合成的CPU，和一系列的小工具，每个工具都可以完成一项任务──调试，分析，或测试等，内存检测，我们可以使用它的工具：Memcheck。 Valgrind安装 方法 1. valgrind官网：http://valgrind.org下载 方法 2. Ubuntu： sudo apt-get install
C++内存泄漏排查以及几个工具
CODE实验室
08-28 7509
近期排查老项目App的偶发闪退问题过程中，发现程序竟然有内存泄漏的情况，表现为连续运行多天后程序占用的虚拟内存和物理内存都会持续升高，经过排查修改，找出了多处内存泄漏，现对排查过程做个小结。...
C++ 内存泄漏检测工具valgrind简单使用
m0_46684679的博客
10-24 2418
valgrind内存泄漏工具简单使用和说明
c/c++开发，内存泄漏检测检测工具Valgrind
技术需要分享
03-22 1133
c/c++开发，内存泄漏检测检测工具Valgrind ，Valgrind工具的安装及使用步骤。
C/C++内存泄露检查利器—valgrind
Linuxer_Martin
05-05 2710
Valgrind是一套Linux下，开放源代码（GPL V2）的仿真调试工具的集合。Valgrind由内核（core）以及基于内核的其他调试工具组成。内核类似于一个框架（framework），它模拟了一个CPU环境，并提供服务给其他工具；而其他工具则类似于插件 (plug-in)，利用内核提供的服务完成各种特定的内存调试任务。Memcheck。
Linux之内存泄漏检测valgrind-memcheck. 附件测试代码.cpp
07-19
【2】其中包含5种内存泄漏情况的C++代码。分别是 1.使用野指针，即未初始化的指针； 2.释放野指针，即未初始化的指针； 3. 动态内存越界； 4. 堆内存泄漏，没有成对使用malloc/free和new/delete； 5.两次释放内存；
Unix下C程序内存泄漏检测工具Valgrind的安装与使用详解
09-05
Valgrind是一款强大的开源软件开发工具，主要用于C和C++程序的内存调试、内存泄漏检测以及性能分析。它由Julian Seward创建，并且遵循GNU通用公共许可证（GPL），因此是一个自由软件。Valgrind的强大之处在于其能够...
使用Valgrind memcheck工具进行CC++的内存泄漏检测
03-10
Linux C语言程序内存泄漏检测工具-Valgrind.doc
06-12
Linux C语言程序内存泄漏检测工具-Valgrind Valgrind 是一款 Linux 下的免费内存调试工具包，包含多个工具，如 Memcheck、Cachegrind、Helgrind、Callgrind、Massif。它可以对编译后的二进制程序进行内存使用监测...
VLD内存泄漏检测工具
02-11
VLD，全称为Valgrind Leak Detector，是一款强大的内存泄漏检测工具，主要针对C和C++编程语言。在软件开发过程中，尤其是对于那些需要长期运行的服务，内存泄漏问题可能导致资源耗尽，严重影响程序的稳定性和性能。...
C++内存泄漏及检测工具详解
01-20
首先我们需要知道程序有没有内存泄露，然后定位到底是哪行代码出现内存泄露了，这样才能将其修复。 最简单的方法当然是借助于专业的检测工具，比较有名如BoundsCheck,功能非常强大，相信做C++开发的人都离不开它。此外就是不使用任何工具，而是自己来实现对内存泄露的监控，分如下两种情况： 一. 在 MFC 中检测内存泄漏 假如是用MFC的程序的话，很简单。默认的就有内存泄露检测的功能。 我们用VS2005生成了一个MFC的对话框的程序,发现他可以自动的检测内存泄露.不用我们做任何特殊的操作. 仔细观察,发现在每个CPP文件中,都有下面的代码: 代码如下:#ifdef _DEBUG#define
Valgrind -- Memcheck: a memory error detector
Mac Track
03-30 3130
Memcheck is a memory error detector. It can detect the following problems that are common in C and C++ programs. Accessing memory you shouldnt, e.g. overrunning and underrunning heap blocks, ov
【调试】Valgrind内存泄漏内存越界|运行时间|调用|cache命中率|多线程竞态|堆栈分析
bandaoyu的note
06-10 5894
目录 即可即用 简介 Valgrind工具详解 安装 使用 检测内存泄漏 其他内存问题 memcheck 工具的常用选型 其他选项 附录 其他类似工具 即可即用 1、没有安装的先在程序运行的主机上安装，安装教程见：1.4安装。 2、使用： 命令： valgrind--leak-check=full --log-file=leak.log/...
【linux】Valgrind工具集详解（七）：Memcheck（内存错误检测器）
郭老二
11-05 7758
一、概述 Memcheck是一个内存错误检测器。它可以检测C和C ++程序中常见的以下问题： 1、非法内存：如越界、释放后继续访问； 2、使用未初始化的值； 3、释放内存错误：如double-free（同一内存上执行了两次free）、或者 malloc、new、new[] 与 free、delete、delete[]错配使用 4、memcpy函数（或其它相关函数）中src和dst指针重叠； 5、分...
c/c++内存泄漏检测工具（上）
我的E家
03-28 2679
1/  VC自带的CRT:_CrtCheckMemory   调试器和 CRT 调试堆函数 用法 /************************************************************************ *   环境：VC6.0 *   程序功能：CRT 检测内存泄漏      *   创建：  2014/3/20 * *   版本号：1.
【C/C++ 集成内存调试、内存泄漏检测和性能分析的工具 Valgrind 】Linux 下 Valgrind 工具的全面使用指南
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
07-11 1556
Valgrind 是一个非常强大的工具，主要用于内存管理错误检测，以及 CPU 和内存分析。
C++内存泄露检测工具（VLD）
世间所有的相遇都是久别重逢
01-14 1953
简述 C/C++ 程序越复杂，内存的管理显得越重要，稍有不慎就会出现泄漏。如果内存泄漏不是很严重，在短时间内对程序不会有太大影响，这也使得内存泄漏问题有很强的隐蔽性，不易被发现。然而不管内存泄漏多么轻微，当程序长时间运行时，其破坏力是惊人的 - 从性能下降到内存耗尽，甚至会影响其他程序的正常运行。 解决方法：VLD 工具 下载：Visual Leak Detector | Enhanced Memory Leak Detection for Visual C++ 百度云： 使用方法： 1、..
vs2019 C++自带了内存问题检测工具:AddressSanitizer(ASan)
热门推荐
zhenmu的专栏
03-25 1万+
vs2019 C++ 自带了 内存问题检测工具:AddressSanitizer(ASan)
安卓平台valgrind交叉编译
点滴路程
02-04 1595
本文主要讲述了在Android平台使用ndk23交叉编译工具链编译valgrind时遇到的问题及解决方法。主要问题包括不支持Android系统、结构体重复定义、无法找到libgcc.a库以及32位工具编译失败等。作者首先尝试通过修改configure参数和解决依赖问题来解决问题，但在目标机调试时仍然遇到断言错误。随后，作者尝试使用gcc编译而非clang，并找到了一个早期版本的ndk14，最终成功编译并调试了valgrind。有时换一个思路，也许会让你柳暗花明又一村，拥有意外收获。
C++内存泄漏分析工具
最新发布
03-05
C++内存泄漏是指在程序运行过程中，分配的内存没有被正确释放，导致内存资源无法再次使用，从而造成内存的浪费。为了解决和分析C++内存泄漏问题，可以使用以下几种工具： 1. Valgrind：Valgrind是一个开源的内存调试和性能分析工具，它可以检测出内存泄漏、内存错误、线程错误等问题。Valgrind提供了Memcheck工具，可以用于检测内存泄漏问题。 2. AddressSanitizer（ASan）：ASan是GCC和Clang编译器提供的一种内存错误检测工具，它可以检测出内存泄漏、缓冲区溢出等问题。ASan通过在编译时插入额外的代码来进行运行时检查。 3. LeakSanitizer（LSan）：LSan也是GCC和Clang编译器提供的一种内存泄漏检测工具，它专门用于检测内存泄漏问题。LSan通过在运行时跟踪内存分配和释放来检测泄漏。 4. Visual Leak Detector（VLD）：VLD是一个针对Windows平台的内存泄漏检测工具，它可以在程序运行时检测出内存泄漏问题，并在控制台或者调试器中输出相关信息。 5. C++ Memory Validator：C++ Memory Validator是一款商业化的内存泄漏检测工具，它可以在Windows平台上检测出内存泄漏问题，并提供详细的报告和分析功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值