首页 / C++ / Linux下c++程序内存泄漏检测代码范例

Linux下c++程序内存泄漏检测代码范例

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Linux下c++程序内存泄漏检测代码范例，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9825字，纯文字阅读大概需要15分钟。

内容图文

Linux下对于程序内存泄漏检测的方法很多，最常用的的莫过于使用valgrind工具。但是valgrind相当于让程序在虚拟机中运行，会带来较大的系统资源开销，还会对程序的运行效率产生较大影响，对于那种资源占用大的程序，如果需要长时间运行才能暴露的泄漏问题，它就显得不太好用。

linux下的c++程序中自己实现一个轻量级的泄漏检测代码其实是比较方便的，下面我就给出一个简单的范例，并作简单的说明。当然，我们还是应该提倡使用共享指针，用共享指针自动管理内存可以避免内存泄漏这样的不必要的麻烦。

 

 

基本原理：
1.利用glibc提供的__malloc_hook, __free_hook系列函数对内存分配是否做监控；（详见glibc的官方文档）
2.利用backtrace函数获取函数调用栈，并记录；
3.利用backtrace_symbols对调用栈对应的函数做解析；
进一步处理：
4.使用abi::__cxa_demangle把函数名解析为源代码风格；
5.使用addr2line解析出函数调用栈对应的代码行；
6.对于动态库（.so）中的地址解析，需要先在/proc/<pid>/maps文件中找到动态库映射的基地址，才能做解析。
注意：
编译连接参数中使用-g -rdynamic
 
以上每步具体实现的代码可能都没有达到最优，甚至可能是笨办法，如果有更好的实现方案请直接替换，也欢迎赐教。

示例代码：
leakmom.cpp

/* Prototypes for __malloc_hook, __free_hook */
#include   <malloc.h>
#include   <map>
#include   <utility>
#include   <execinfo.h>
#include   <errno.h>
#include     <assert.h>
#include   <cxxabi.h>
#include   <sys/types.h>
#include   <unistd.h>
#include   <stdlib.h>
#include   "leakmon.h"

CMutexLock   gLock   ;
std :: map   < void *,   _PtrInfo >   gPtrInfo   ;
std :: map   < const   LmCallStack *,   _AllocInfo   ,    __comp >   gLeakInfo ;


const   int   LmCallStack ::   MAX_STACK_LAYERS   = 32;

/* Prototypes for our hooks. */
static   void   my_init_hook   (   void );
static   void   * my_malloc_hook   (   size_t ,   const   void   *);
static   void   my_free_hook   (   void *,   const   void   *);

void   *(* __MALLOC_HOOK_VOLATILE   old_malloc_hook )(   size_t   __size   ,   const   void   *) ;
void   (* __MALLOC_HOOK_VOLATILE   old_free_hook ) (   void   * __ptr   ,   const   void   *);
/* Override initializing hook from the C library. */
void   (* __MALLOC_HOOK_VOLATILE   __malloc_initialize_hook ) (   void ) =   my_init_hook ;

void   my_init_hook   ( void )
{
      old_malloc_hook   =   __malloc_hook   ;
      old_free_hook   =   __free_hook   ;
      __malloc_hook   =   my_malloc_hook   ;
      __free_hook   =   my_free_hook   ;
}

static   void   * my_malloc_hook   (   size_t   size   ,   const   void   * caller   )
{
      void   * result   ;
         gLock . lock   ();
      /* Restore all old hooks */
      __malloc_hook   =   old_malloc_hook   ;
      __free_hook   =   old_free_hook   ;
      /* Call recursively */
      result   =   malloc   ( size );
      /* Save underlying hooks */
      old_malloc_hook   =   __malloc_hook   ;
      old_free_hook   =   __free_hook   ;
      /* printf might call malloc, so protect it too. */
      //printf ("malloc (%u) returns %p\n", (unsigned int) size, result);
         RecordPtr (   result   ,   size );

      /* Restore our own hooks */
      __malloc_hook   =   my_malloc_hook   ;
      __free_hook   =   my_free_hook   ;
         gLock . unlock   ();
      return   result   ;
}

static   void   my_free_hook   (   void   * ptr   ,   const   void   * caller   )
{
         gLock . lock   ();
      /* Restore all old hooks */
      __malloc_hook   =   old_malloc_hook   ;
      __free_hook   =   old_free_hook   ;
      /* Call recursively */
      free   ( ptr   );
      /* Save underlying hooks */
      old_malloc_hook   =   __malloc_hook   ;
      old_free_hook   =   __free_hook   ;
      /* printf might call free, so protect it too. */
      //printf ("freed pointer %p\n", ptr);

         RemovePtr (   ptr   );

      /* Restore our own hooks */
      __malloc_hook   =   my_malloc_hook   ;
      __free_hook   =   my_free_hook   ;
         gLock . unlock   ();
}

void   RecordPtr   (   void *   ptr ,   size_t   size )
{
         //   获取调用栈
         void   * array   [ LmCallStack ::   MAX_STACK_LAYERS ];
         int   cstSize   =   backtrace (   array ,   LmCallStack   :: MAX_STACK_LAYERS );

         //   保存指针   调用栈
         LmCallStack *   callstack   =   new   LmCallStack ( array   ,   cstSize );

         gLock . lock   ();

         std :: map   < const   LmCallStack *,   _AllocInfo   ,    __comp >::   iterator   it   =   gLeakInfo . find   ( callstack );
         if   ( it   !=   gLeakInfo .   end ())
      {
               it -> second   . size   +=   size ;
               it -> second   . alloc ++;

               _PtrInfo   pi   ( it ->   first ,   size   );
               gPtrInfo [ ptr   ] =   pi ;
      }
         else
      {
               _AllocInfo   aif   ( size , 1, 0);
               std :: pair   < std ::   map < const   LmCallStack *,   _AllocInfo ,    __comp >:: iterator   ,   bool >   ret   =   gLeakInfo   . insert (   std :: pair   < const   LmCallStack *,   _AllocInfo   >( callstack ,   aif ));
            
               if   ( ret   . second )
            {
                     _PtrInfo   pi   ( ret .   first -> first   ,   size );
                     gPtrInfo [ ptr   ] =   pi ;
            }
               else
            {
                     // failed
            }
      }

         gLock . unlock   ();
}

void   RemovePtr   (   void *   ptr   )
{
         gLock . lock   ();

         std :: map   < void *,   _PtrInfo >:: iterator   it   =   gPtrInfo . find   ( ptr );
         if   ( it   !=   gPtrInfo .   end ())
      {
               std :: map   < const   LmCallStack *,   _AllocInfo   ,    __comp >::   iterator   itc   =   gLeakInfo   . find (   it -> second   . csk );
               if   ( itc   !=   gLeakInfo .   end ())
            {
                     itc -> second   . size   -=   it -> second   . size ;
                     itc -> second   . free ++;

                     if   (0 == ( itc   -> second .   alloc   -   itc   -> second .   free ))
                  {
                           assert (0 ==   itc   -> second .   size );
                           delete   itc   -> first ;
                           gLeakInfo . erase   ( itc );
                  }
            }

               gPtrInfo . erase   ( it );
      }

         gLock . unlock   ();
}

void   Report   ()
{
         char   ** strings   =   NULL ;
         gLock . lock   ();

         __malloc_hook   =   old_malloc_hook   ;
      __free_hook   =   old_free_hook   ;

         for   ( std   :: map <   const   LmCallStack   *,   _AllocInfo ,    __comp >:: iterator   it   =   gLeakInfo   . begin ();
               it   !=   gLeakInfo   . end ();
               it ++)
      {
               printf ( "\n"   );
               printf ( "====>  size: %ld,  allocs: %d,  frees: %d, a-f: %d\n" ,   it ->   second . size   ,   it ->   second . alloc   ,   it ->   second . free   ,   it -> second   . alloc -   it -> second   . free   );
               printf ( "====>  stacks back trace:\n"   );
               strings   =   backtrace_symbols   (( void **)   it -> first   -> callstack ,   it -> first   -> size );
               if   ( strings   )
            {
                     for ( int   i   = 2;   i   <   it   -> first ->   size ;   i   ++)
                  {   //printf("     %s\n", strings[i]);
                           char   output   [1024] = {0};
                           memset ( output   , 0, 1024);
                           char   temp   [1024] = {0};
                           memset ( temp   , 0, 1024);
                           ////
                           ////    get real function name
                           ////
                           if   (1 ==   sscanf   ( strings [   i ],   "%*[^(]%*[^_]%[^)+]"   ,   temp ))
                        {
                                       int   status   ;
                                       char *   realname   =   abi :: __cxa_demangle   ( temp , 0, 0, &   status );
                                       if   (0 ==   status   )
                                    {
                                             char *   p   =   strchr (   strings [ i   ],   ‘(‘ );
                                             memcpy ( output   ,   strings [   i ],   p - strings   [ i ]);
                                             sprintf ( output   +( p -   strings [ i   ]),   "(%s+%p) "   ,   realname , ((   void **) it   -> first ->   callstack )[ i   ]);   //printf("     -%s\n", realname);
                                             free ( realname   );
                                    }
                                       else
                                    {
                                             char *   p   =   strchr (   strings [ i   ],   ‘)‘ );
                                             memcpy ( output   ,   strings [   i ],   p - strings   [ i ]+2);
                                    }
                        }
                           else
                        {
                                 char *   p   =   strchr (   strings [ i   ],   ‘)‘ );
                                 memcpy ( output   ,   strings [   i ],   p - strings   [ i ]+2);
                        }

                           FILE   *   fp   ;
                           char   module   [1024] = {0};
                           memset ( module   , 0, 1024);
                           char *   pm   =   strchr (   strings [ i   ],   ‘(‘ );
                           memcpy ( module   ,   strings [   i ],   pm   - strings [   i ]);

                           if   ( strstr   ( module ,   ".so" ))
                        {
                                 __pid_t   pid   =   getpid ();
                                 sprintf ( temp   ,   "grep %s /proc/%d/maps" ,   module ,   pid   );
                                 ///
                                 ///         get library base-map-address
                                 ///
                                 fp   =   popen   ( temp ,   "r" );
                                 if   ( fp   )
                              {
                                       char   baseaddr   [64];
                                       unsigned   long   long   base ;
                                    
                                       fgets ( temp   ,   sizeof (   temp )-1,   fp   );    //printf("memmap: %s\n", temp);
                                       sscanf ( temp   ,   "%[^-]" ,   baseaddr );
                                       base   =   strtoll   ( baseaddr ,   NULL , 16);   //printf("baseaddr:%s\n", baseaddr); //printf(" base:0x%llx\n", base);

                                       sprintf ( temp   ,   "addr2line -e %s %p" ,   module , ( void   *)(( unsigned   long   long )(( void   **) it ->   first -> callstack   )[ i ]-   base ));
                              }
                        }
                           else
                        {
                                 sprintf ( temp   ,   "addr2line -e %s %p" ,   module , (( void   **) it ->   first -> callstack   )[ i ]);
                        }
                           ////
                           ////    get source file name and line number
                           ////
                           fp   =   popen   ( temp ,   "r" );   //printf("cmdline: %s\n", temp);
                           if   ( fp   )
                        {
                                 fgets ( temp   ,   sizeof (   temp )-1,   fp   );   //printf("     -%s\n", temp);

                                 strcat ( output   ,   temp );
                                 printf ( "   ->  %s"   ,   output );
                                 pclose ( fp   );
                        }
                           else
                        {
                                 printf ( "   ->  %s\n"   ,   output );
                        }
                  }

                     free ( strings   );
                     strings   =   NULL   ;
            }
      }

         __malloc_hook   =   my_malloc_hook   ;
      __free_hook   =   my_free_hook   ;

         gLock . unlock   ();
}


//////////////////////////////////////////////////////////////////////////

CMutexLock :: CMutexLock   ()
{
         pthread_mutexattr_t     m_attr   ;
         pthread_mutexattr_init (& m_attr   );
         pthread_mutexattr_settype (& m_attr   ,   PTHREAD_MUTEX_RECURSIVE );

         if   (0 !=   pthread_mutex_init   (& m_mutex   , &   m_attr ))
      {
               printf ( "c_lock::c_lock pthread_mutex_init error<%d>.\n"   ,   errno );
               assert (0);
      }

         pthread_mutexattr_destroy (& m_attr   );
}

CMutexLock ::~ CMutexLock   ()
{
         if (0 !=   pthread_mutex_destroy   (& m_mutex ))
      {
               printf ( "c_lock::~c_lock pthread_mutex_destroy error<%d>.\n"   ,   errno );
               assert (0);
      }
}

void
CMutexLock :: lock   ()
{

         if (0 !=   pthread_mutex_lock   (& m_mutex ))
      {
               assert ( "c_lock::lock pthread_mutex_lock "   && 0);
      }
}

void
CMutexLock :: unlock   ()
{
         int   iRet   = 0;

         if (0 != ( iRet   =   pthread_mutex_unlock (&   m_mutex )))
      {
               printf ( "c_lock::unlock pthread_mutex_unlock ret<%d> error<%d>.\n" ,   iRet ,   errno   );
               assert (0);
      }
}

示例代码：
leakmom.h

////////////////////////////////////////////////////////////////////////
//
//    The Executable file MUST be linked with parameter ‘-rdynamic‘ !!!
//
////////////////////////////////////////////////////////////////////////

#pragma   once
#include   <string.h>
#include   <pthread.h>
                        
//
class   LmCallStack
{
public :
         char *   callstack   ;   // pointer to buffer recording callstack addresses
         int   size   ;   // count of call stacks
         static   const   int   MAX_STACK_LAYERS ;
public :
         LmCallStack ( void   *   csk =   NULL ,   int   s =0)
      {
               if   ( csk   )
            {
                     callstack   =   new   char [   s * sizeof   ( void *)];
                     memcpy ( callstack   ,   csk ,   s * sizeof   ( void *));
            }
               else
            {
                     callstack   = ( char   *) csk ;
            }
               size   =   s   ;
      }

      ~   LmCallStack ()
      {
               if   ( callstack   )
            {
                     delete []   callstack   ;
            }
               callstack   =   NULL   ;
               size   = 0;
      }
};

class   __comp
{
public :
         __comp (){};
         bool   operator   () ( const   LmCallStack *   first   ,   const   LmCallStack *   second )
      {
               return   (( first   -> size   <   second -> size   ) ||
                        (   first -> size   ==   second ->   size   &&
                                       memcmp ( first   -> callstack ,   second -> callstack   ,   sizeof (   void *)* first   -> size ) < 0)
                        );
      }
};

struct   _PtrInfo
{
         _PtrInfo ( const   LmCallStack *   c = NULL   ,   long   s =0)
      {
               csk   =   c   ;
               size   =   s   ;
      }
         const   LmCallStack   *   csk ;
         long   size   ;
};

struct   _AllocInfo
{
         _AllocInfo ( long   s =0,   int   a   =0,   int   f =0)
      {
               size = s   ;
               alloc = a   ;
               free = f   ;
      }
         //
         long   size   ;
         int   alloc   ;
         int   free   ;
};

class   CMutexLock
{
public :
         CMutexLock ();
      ~   CMutexLock ();

public :
         void   lock   ();
         void   unlock   ();

private :
         pthread_mutex_t   m_mutex   ;
};


//
void   RecordPtr   (   void *   ptr ,   size_t   size );
void   RemovePtr   ( void *   ptr );
void   Report   ();

原文：http://blog.csdn.net/yichigo/article/details/45092265

内容总结

以上是互联网集市为您收集整理的Linux下c++程序内存泄漏检测代码范例全部内容，希望文章能够帮你解决Linux下c++程序内存泄漏检测代码范例所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1154336.html

来源：【匿名】