C++:重载全局new/delete实现跨平台多线程内存检测

最新推荐文章于 2023-11-04 13:52:26 发布
最新推荐文章于 2023-11-04 13:52:26 发布
阅读量185 收藏
点赞数
文章标签： c/c++ python
原文链接：https://my.oschina.net/u/4000302/blog/3057686
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

实现类：

DumpMemoryLeaks.h

/**
* @file DumpMemoryLeaks.h
* @brief 跟踪内存分配并定时输到文件，以协助检查有无内存泄漏
*
* 修订记录 
* @author   jack3z
* @version  1.00
* @date 2014-05-18
*
*/
 
#ifndef DUMPMEMORYLEAKS_H
#define DUMPMEMORYLEAKS_H
 
#ifdef __linux__
# include <pthread.h>
#else
# include <Windows.h>
#endif
 
#include <stdio.h>
#include <stdlib.h>
 
#include <malloc.h>
 
#include <time.h>
 
#include <string>
#include <map>
#include <list>
 
#include <assert.h>
 
#ifndef DUMP_MEM_REPORT_FREQUENCY
//# define DUMP_MEM_REPORT_FREQUENCY (30*60) //每隔30分钟输出一次内存分配情况
//# define DUMP_MEM_REPORT_FREQUENCY 60 //每隔一分钟输出一次内存分配情况
# define DUMP_MEM_REPORT_FREQUENCY 10 //测试时，10秒输出一次内存分配情况
#endif
 
struct StMemAllocRec
{
    void* addr;
    size_t nSize;
};
 
class CAllocLocalInfo
{
public:
    CAllocLocalInfo()
    {
        m_nLine = -1;
    }
 
    std::string m_strFile;
    int m_nLine;
 
    bool operator<(const CAllocLocalInfo& other) const
    {
        return m_strFile < other.m_strFile || (m_strFile==other.m_strFile && m_nLine < other.m_nLine);
    }
};
 
 
class CDumpMemoryLeaks
{
private:
    CDumpMemoryLeaks(void);
    ~CDumpMemoryLeaks(void);
 
public: 
    static CDumpMemoryLeaks& GetInstance()
    {
        static CDumpMemoryLeaks inst;
        return inst;
    }
 
    void Init();
 
    void AddTrack(void* addr, size_t asize, const char *fname, int lnum);
 
    void RemoveTrack(void* addr);
 
protected:
 
    bool IsTheTime2Dump()
    {
        return m_timeDump < time(NULL);
    }
 
    void ResetDumpTime()
    {
        m_timeDump = time(NULL) + DUMP_MEM_REPORT_FREQUENCY;
    }
 
    void Dump();
 
    void lock()
    {
#ifdef __linux__
        pthread_mutex_lock(&m_mtx);
#else
        EnterCriticalSection(&m_mtx);
#endif
    }
 
    void unlock()
    {
#ifdef __linux__
        pthread_mutex_unlock(&m_mtx);
#else
        LeaveCriticalSection(&m_mtx);
#endif
    }
 
protected:
    bool m_bInit;
 
    FILE* m_fpDumpFile;
    std::string m_strDumpFile;
 
    std::map< CAllocLocalInfo, std::list<StMemAllocRec> > m_mapAllocRec;
 
    std::map<void *,CAllocLocalInfo> m_mapAddr2AllocLocal;
 
    time_t m_timeDump;
 
    std::string m_strMsg;
 
    char m_szBuf[1024];
 
#ifdef __linux__
    pthread_mutex_t m_mtx;
#else
    CRITICAL_SECTION m_mtx;
#endif
};
 
//#ifdef DEBUG_REPORT_NEW_ALLOC  
 
inline void * operator new(size_t size, const char* file, const size_t line)
{
    void *ptr = (void*)malloc(size);  
    CDumpMemoryLeaks::GetInstance().AddTrack(ptr, size, file, line);  
    return(ptr);
}
 
inline void * operator new [](size_t size, const char* file, const size_t line)
{
    void *ptr = (void*)malloc(size);  
    CDumpMemoryLeaks::GetInstance().AddTrack(ptr, size, file, line);  
    return ptr; 
}
 
inline void operator delete(void *p)  
{  
    CDumpMemoryLeaks::GetInstance().RemoveTrack(p);  
    free(p);  
}
 
inline void operator delete(void *p, size_t size)  
{  
    CDumpMemoryLeaks::GetInstance().RemoveTrack(p);  
    free(p);  
}
 
inline void operator delete(void *p, const char* file, const size_t line)  
{  
    CDumpMemoryLeaks::GetInstance().RemoveTrack(p);  
    free(p);  
}
 
inline void operator delete [](void *p)
{  
    CDumpMemoryLeaks::GetInstance().RemoveTrack(p);  
    free(p);  
}
 
inline void operator delete [](void *p, size_t size)
{  
    CDumpMemoryLeaks::GetInstance().RemoveTrack(p);  
    free(p);  
}
 
inline void operator delete [](void *p, const char* file, const size_t line)
{  
    CDumpMemoryLeaks::GetInstance().RemoveTrack(p);  
    free(p);  
}
 
#define malloc(s) ((void*)new unsigned char[s])
 
#define free(p)   (delete [] (char*)(p));
 
#define new new(__FILE__, __LINE__)  //1st parameter:size is not needed, passed by the compiler  
 
//#endif  
 
 
#endif

DumpMemoryLeaks.cpp
#include "DumpMemoryLeaks.h"
 
#ifndef localtime_r
 
#if _MSC_VER >= 1400
//Visual C++ 2005 以及更高版本
# define localtime_r(_Time_ptr,_Tm_ptr) (localtime_s((_Tm_ptr),(_Time_ptr)) == 0 ? (_Tm_ptr) : NULL)
#else
# define localtime_r(_Time_ptr,_Tm_ptr) ( *(_Tm_ptr) = *localtime(_Time_ptr), (_Tm_ptr))
#endif //#if _MSC_VER >= 1500 
 
#endif //#ifndef localtime_r
 
#ifdef _MSC_VER
# ifndef snprintf
#  define snprintf _snprintf
# endif//snprintf
#endif //_MSC_VER
 
CDumpMemoryLeaks::CDumpMemoryLeaks(void)
{
    m_bInit = false;
 
    m_fpDumpFile = NULL;
 
    m_timeDump = NULL;
 
    memset(m_szBuf,0,sizeof(m_szBuf));
 
#ifdef __linux__
    pthread_mutexattr_t mattr;
    pthread_mutexattr_init(&mattr);
    pthread_mutexattr_settype(&mattr , PTHREAD_MUTEX_RECURSIVE);
    pthread_mutex_init(&m_mtx,&mattr);
#else
    InitializeCriticalSection(&m_mtx);
#endif
 
}
 
CDumpMemoryLeaks::~CDumpMemoryLeaks(void)
{
    if (m_fpDumpFile)
    {
        fclose(m_fpDumpFile);
        m_fpDumpFile = NULL;
    }
 
#ifdef __linux__
    pthread_mutex_destroy(&m_mtx);
#else
    DeleteCriticalSection(&m_mtx);
#endif
}
 
void CDumpMemoryLeaks::Init()
{
    lock();
 
    if (!m_bInit)
    {
        ResetDumpTime();
 
        m_bInit = true;
    }
 
    unlock();
 
}
 
void CDumpMemoryLeaks::AddTrack(void* addr, size_t asize, const char *fname, int lnum)
{
    lock();
 
    if (!m_bInit)
    {
        Init();
    }
 
    CAllocLocalInfo alloc_local;
    alloc_local.m_strFile = fname;
    alloc_local.m_nLine = lnum;
 
    StMemAllocRec mem_alloc_rec;
    mem_alloc_rec.addr = addr;
    mem_alloc_rec.nSize = asize;
 
    m_mapAllocRec[alloc_local].push_back(mem_alloc_rec);
 
    m_mapAddr2AllocLocal[addr] = alloc_local;
 
    if (IsTheTime2Dump())
    {
        Dump();
 
        ResetDumpTime();
    }
 
    unlock();
}
 
void CDumpMemoryLeaks::RemoveTrack(void* addr)
{
    lock();
 
    if (!m_bInit)
    {
        Init();
    }
 
    bool bRemoveSuccess = false;
 
    std::map<void *, CAllocLocalInfo>::iterator itorAddr2AllocLocal = m_mapAddr2AllocLocal.find(addr);
 
    if (itorAddr2AllocLocal == m_mapAddr2AllocLocal.end())
    {
        unlock();
        return;
    }
    else
    {
        std::map< CAllocLocalInfo, std::list<StMemAllocRec> >::iterator itorAllocRec = m_mapAllocRec.find(itorAddr2AllocLocal->second);
        assert(itorAllocRec != m_mapAllocRec.end());
 
        std::list<StMemAllocRec>& listAllocRec = itorAllocRec->second;
 
        for (std::list<StMemAllocRec>::iterator itor = listAllocRec.begin();
            itor != listAllocRec.end();
            ++itor)
        {
            if ((*itor).addr == addr)
            {
                listAllocRec.erase(itor);
                bRemoveSuccess = true;
 
                break;
            }
        }
 
        if (listAllocRec.empty())
        {
            m_mapAllocRec.erase(itorAllocRec);
            m_mapAddr2AllocLocal.erase(itorAddr2AllocLocal);
        }
    }
 
    assert(bRemoveSuccess);
 
    if (IsTheTime2Dump())
    {
        Dump();
 
        ResetDumpTime();
    }
 
    unlock();
}
 
void CDumpMemoryLeaks::Dump()
{
    time_t timeNow = time(NULL);
    struct tm tmNow;
    if (NULL == localtime_r(&timeNow,&tmNow))
    {
        assert(false);
    }
 
    if (m_strMsg.empty())
    {//生成信息
 
        size_t nTotalAlloc = 0;
 
        std::list<CAllocLocalInfo> listLocal;//按内存大到小排序
 
        std::map<CAllocLocalInfo,size_t> mapLocal2Size;
 
        for (std::map< CAllocLocalInfo, std::list<StMemAllocRec> >::iterator itor = m_mapAllocRec.begin();
            itor != m_mapAllocRec.end();
            ++itor)
        {
            const CAllocLocalInfo& local = itor->first;
 
            std::list<StMemAllocRec>& listAllocRec = itor->second;
 
            for (std::list<StMemAllocRec>::iterator itor = listAllocRec.begin();
                itor != listAllocRec.end();
                ++itor)
            {
                nTotalAlloc += itor->nSize;
 
                mapLocal2Size[local] += itor->nSize;
            }
        }
 
        for (std::map<CAllocLocalInfo,size_t>::iterator itor = mapLocal2Size.begin();
            itor != mapLocal2Size.end();
            ++itor)
        {
            std::list<CAllocLocalInfo>::iterator itorLocalList = listLocal.begin();
 
            for (;
                itorLocalList != listLocal.end();
                ++itorLocalList)
            {
                if (itor->second >= mapLocal2Size[*itorLocalList])
                {
                    break;
                }
            }
 
            listLocal.insert(itorLocalList,itor->first);
        }
 
        snprintf(m_szBuf,sizeof(m_szBuf)-1,"Total unfree:%lu \n",(unsigned long)nTotalAlloc);
 
        m_strMsg += "\n";
 
        m_strMsg += m_szBuf;
 
        m_strMsg += "--------------------------------------------------------------------------\n";
 
        snprintf(m_szBuf,sizeof(m_szBuf)-1,
            "Time: %04u-%02u-%02u %02u:%02u:%02u\n\n",
            tmNow.tm_year + 1900,
            tmNow.tm_mon + 1,
            tmNow.tm_mday,
            tmNow.tm_hour,
            tmNow.tm_min,
            tmNow.tm_sec
            );
 
        m_strMsg += m_szBuf;
 
        double dTotalReciprocal = 1.0/(double)nTotalAlloc;
 
        for (std::list<CAllocLocalInfo>::iterator itorLocalList = listLocal.begin();
            itorLocalList != listLocal.end();
            ++itorLocalList)
        {
            size_t nSize = mapLocal2Size[*itorLocalList];
 
            snprintf(m_szBuf,sizeof(m_szBuf)-1,
                "%s:line %d, unfreed size:%lu, percentage:%lf %%; alloc times:%lu\n",
                itorLocalList->m_strFile.c_str(),
                itorLocalList->m_nLine,
                nSize,
                nSize*dTotalReciprocal*100,
                (unsigned long)m_mapAllocRec[*itorLocalList].size()
                );
 
            m_strMsg += m_szBuf;
        }
 
        m_strMsg += "--------------------------------------------------------------------------\n";
 
    }
 
    //
    //文件操作：打开文件,分割文件并写入
 
    snprintf(m_szBuf,sizeof(m_szBuf)-1,
        "MemoryAllocReport_%04u-%02u-%02u.txt",
        tmNow.tm_year + 1900,
        tmNow.tm_mon + 1,
        tmNow.tm_mday
        );
 
    if (!m_fpDumpFile)
    {
        m_fpDumpFile = fopen(m_szBuf,"a");
 
        m_strDumpFile = m_szBuf;
 
        fprintf(m_fpDumpFile, "\n\n---------------- DumpMemoryLeaks begin! ----------------\n");
        
    }
    else
    {
        if (m_strDumpFile != m_szBuf)
        {
            fclose(m_fpDumpFile);
 
            m_fpDumpFile = fopen(m_szBuf,"w");
 
            m_strDumpFile = m_szBuf;
        }
    }
 
    fwrite(m_strMsg.c_str(),m_strMsg.length(),1,m_fpDumpFile);
 
    //文件操作结束
    //
 
    m_strMsg.clear();
}
 
 

实现方法：把文件保存到项目源文件目录下并在全局头文件添加# include "DumpMemoryLeaks.h"

如在win32工程中的stdafx.h文件内添加：

#ifdef _DEBUG
# include "DumpMemoryLeaks.h"
#endif // _DEBUG

测试：
// DbgMemLeak.cpp : 定义控制台应用程序的入口点。
//
 
#include "stdafx.h"
#include <list>
using namespace std;
 
class A
{
public:
    A()
    {
        m_i = 9;
    }
 
    ~A()
    {
        if (m_i != 9)
        {
            assert(false);
        }
 
        m_i = 1;
    }
 
    int m_i;
};
 
class B
{
public:
    B()
    {
        printf("new B instance %p \n", this);
    }
 
    ~B()
    {
        printf("delete B instance %p \n", this);
    }
};
 
int main(int argc, _TCHAR* argv[])
{
    /*
    {//测试构造和析构
        B* pB = new B();
        delete pB;
        Sleep(3*1000);//方便观察终端输出内容
    }
    */
 
    {//测试数组构造和析构
        B* pArray = new B[4];
        delete[] pArray;
        pArray = NULL;
 
        Sleep(3*1000);//方便观察终端输出内容
    }
    
    /*
    {//测试new和delete基础类型数组
        char* pChArr = new char[1024];
        delete pChArr;
    }
    */
 
    //模拟内存泄漏
    for (int i = 0; i < 60*30*10; ++i)
    {
        A* p =  new A ;
 
        Sleep(100);
 
        if (i%2 == 0)
        {
            delete p;
        }
    }
 
 
    for (int i = 0; ; ++i)
    {
        A* p =  new A ;
 
        Sleep(1);
 
        if (i%4 == 0)
        {
            delete p;
        }
        
    }
 
    return 0;
}
 
生成的报告：

--------------------- 
作者：jack3z 
来源：CSDN 
原文：https://blog.csdn.net/u014023615/article/details/39551191 
版权声明：本文为博主原创文章，转载请附上博文链接！

转载于:https://my.oschina.net/u/4000302/blog/3057686

weixin_34185560
关注
【3】第三章：C++实现多进程、多线程（附C++代码）
qq_35635374的博客
08-02 666
认知有限，望大家多多包涵，有什么问题也希望能够与大家多交流，共同成长！本文先对C++实现多进程、多线程做个简单的介绍，具体内容后续再更，其他模块可以参考去我其他文章提示：以下是本篇文章正文内容C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示。
C++项目设计：构建高性能、线程安全的日志系统
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
05-25 3549
C++项目设计：构建高性能、线程安全的日志系统
C++之多线程
weixin_65743593的博客
02-05 602
C++之多线程, 死锁问题初谈
c++ thread and delete
Linux Job
03-21 839
涉及到多线程下对象的自动销毁，下面是网络上收集的相关资料：   boost 中文手册 http://67.223.234.84/boost_doc/index.html   当析构函数遇到多线程 ── C++ 中线程安全的对象回调 http://www.cnblogs.com/Solstice/archive/2010/02/10/dtor_meets_threads.html ...
C++关于delete的使用
AS588AS的博客
02-08 4844
1. delete安全用法：void safe_release() { void* t = m_ptr; //先赋值nullptr，再delete，可防止被在其它线程占用时，引起的错误 m_ptr = nullptr; //方便以后检查指针是否有效，亦防止再次访问无效的指针 delete t; //释放内存 }2. delete[]void fun() { ...
C++ 工程实践(2)：不要重载全局 ::operator new()
热门推荐
陈硕的Blog
02-22 2万+
对于现实生活中的 C++ 项目，重载 ::operator new() 几乎没有用武之地，因为很难处理好与程序所用的 C++ library 的关系。如果确实需要，我们可以从 malloc 层面入手，彻底而全面地替换内存分配器。
dbg_new.rar_c++ new源码
09-24
"dbg_new.rar_c++ new源码"提供了一个跨平台的内存泄漏检测工具，帮助开发者识别并修复这类问题。这个工具的核心是重新定义C++的`new`操作符，以便在分配和释放内存时进行跟踪。 首先，我们要理解C++中的`new`...
【C++ 并发与多线程】std::thread类-多线程的基本用法
Twinkle
04-29 4883
什么叫并发 concurrency? 一遍走路一边说话；你打球我游泳 单核计算机上的并发是个假象，其实只是任务切换（task switching）需要上下文切换 多处理器或一个处理器上有多个核上的并发才是自然的并发，叫硬件并发 并发种类： 1，多进程并发 这些进程间可通过正常的进程通信渠道（信号，套接字，文件，管道等） 缺点：1；通信建立较复杂或者慢；2；操作系统需要花时间启动进...
C++11 多线程学习笔记
最新发布
cosx_的博客
11-04 315
thread, mutex
C++11 线程库—线程操作（更新中）
m0_72563041的博客
06-23 400
C++11线程库—线程操作
C++ 内存泄漏以及delete 和 delete []的真正区别
坚持硬核
09-13 1505
c++中对new申请的内存的释放方式有delete和delete[两种方式，到底这两者有什么区别呢？ 1.我们通常从教科书上看到这样的说明： delete 释放new分配的单个对象指针指向的内存 delete[] 释放new分配的对象数组指针指向的内存 那么，按照教科书的理解，我们看下下面的代码： int *a = new int[10]; delete a; //方式1 del...
<c++ primer>--第五部分 高级主题
weixin_30509393的博客
09-25 74
一 多重继承与虚继承 1多重继承 派生类的对象包含每个基类的基类子对象。 派生类构造函数的次序按照基类构造函数在派生类类表中的出现顺序。 析构函数的次序是构造函数的逆序。 多个基类可能导致二义性。（含有相同的成员） 解决方法：1指定某个基类。2在派生类中定义这样一个成员。 2虚继承（virtual） 为了避免多次包含同一基类，定义虚继承。 类通过虚继承之处它希望共享其虚...
Vc++ new delete 线程非安全性
qingshuiaishui的专栏
06-29 1694
VC++ 6.0是目前我最喜欢的编译器之一。已有六年的使用历史，本以为已经相当熟悉了，可今天让我，之前不知道写了多少的new,delete都没有问题，同样的电脑，同样的操作系统，还是以前的VC6.0开发环境，今晚却让我苦逼了一晚上。 情景：有两个线程，一个线程用来读取文件（new 内存块），另一个线程用来处理读取的文件内容（有delete 内存块）。首先，删除的每一个内存块都是线程1合法new的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值