设为首页收藏本站
开启辅助访问 切换到宽版

猿媛之家

 找回密码
 立即注册

QQ登录

只需一步，快速开始

快捷导航
搜索
热搜: 活动 交友 discuz
猿媛之家»论坛 › 程序员专题讨论 › 基础语言关 › C/C++（面试） 如何自定义函数进行内存泄露检测 ...
返回列表 发新帖
查看: 4646|回复: 0

C/C++（面试） 如何自定义函数进行内存泄露检测

[复制链接]
admin

554

主题

556

帖子

1936

积分

管理员

Rank: 9Rank: 9Rank: 9

积分
1936
发表于 2020-11-12 14:58:01 | 显示全部楼层 |阅读模式
         在C/C++程序开发的时候经常需要使用malloc/free对内存进行申请与释放，如果在使用malloc后却忘记了调用free对内存进行释放，此时就造成了内存泄露，随着时间的推移会慢慢消耗掉系统所有的内存，导致程序无法继续运行，而往往这种内存泄露的问题在大型项目中是很难被定位的，如何通过自定义函数的方法很容易地检测到内存的泄露呢？
        主要解决方法为：通过自定义内存申请和释放的方法mymalloc和myfree，然后设置一个钩子，让用户在调用malloc/free的时候会调用自定义的myalloc/free函数，然后通过下面的宏定义实现当malloc被调用的时候就会默认调用mymalloc函数的功能:

  1. #define  malloc(size)               mymalloc (size, __FILE__, __LINE__)
复制代码
       需要注意的是在调用mymalloc的时候多传入了两个参数__FILE__和 __LINE__，它们分别表示调用mymalloc的代码所在的文件以及行号。有了这些信息以后，主要的实现方法为：        自定义一个列表，每当malloc函数被调用的时候，mymalloc被调用的时候，首先通过调用系统函数malloc把内存申请好，然后把调用者的信息（调用者所在的文件和行号）以及申请好内存的信息添加到列表中；当myfree被调用的时候，首先通过调用系统函数free释放的对应的内存，然后根据待释放的内存地址在列表中删除记录这块内存申请的信息。实现代码如下：
leak_detector.h
  1. #ifndef  LEAK_DETECTOR_C_H
  2. #define  LEAK_DETECTOR_C_H

  4. #pragma  (report_mem_leak)
  5. #define  FILE_NAME_LENGTH              256   //used to store file name in whitch calls malloc
  6. #define  CALL_DEPTH                 10   //repesesent the max fuction call level
  7. #define  TIME_LEN                  26     //time string length
  8. #define  OUTPUT_FILE                           "leak_info.txt"   //store memory leak info
  9. #define  malloc(size)                                mymalloc (size, __FILE__, __LINE__)
  10. #define  calloc(elements, size)          mycalloc (elements, size, __FILE__, __LINE__)
  11. #define  realloc(address, size)     myrealloc(address, size, __FILE__, __LINE__)
  12. #define  free(mem_ref)                                    myfree(mem_ref)

  14. struct _MEM_TRACE_INFO {
  15.     char** traceInfo;     //backtrace information malloc is called
  16.     size_t size;          //number of track infos
  17. };
  18. typedef struct _MEM_TRACE_INFO MEM_TRACE_INFO;

  20. struct _MEM_INFO
  21. {
  22.     void                          *address;
  23.     unsigned int          size;
  24.     char                          file_name[FILE_NAME_LENGTH];
  25.     unsigned int          line;
  26.     char              allocTime[TIME_LEN];
  27.     MEM_TRACE_INFO*   traceInfo;
  28. };
  29. typedef struct _MEM_INFO MEM_INFO;

  31. struct _MEM_LEAK {
  32.         MEM_INFO mem_info;
  33.         struct _MEM_LEAK * next;
  34. };
  35. typedef struct _MEM_LEAK MEM_LEAK;

  37. static void add(MEM_INFO alloc_info);    //add a allocated info to the linkedlist
  38. static void erase(void * address);       //remove a allocted info from the linkedlist
  39. static void clear(void);                 //free the heap space that stores the memory leak info

  41. void * mymalloc(unsigned int size, const char * file, unsigned int line);          //replace malloc
  42. void * mycalloc(unsigned int elements, unsigned int size, const char * file, unsigned int line); //replace calloc
  43. void * myrealloc(void* address, unsigned int size, const char * file, unsigned int line); //replace realloc
  44. void myfree(void * mem_ref);   //replace free

  46. static void add_mem_info (void * mem_ref, unsigned int size,  const char * file, unsigned int line,MEM_TRACE_INFO* traceinfo);
  47. static void remove_mem_info (void * mem_ref);
  48. void report_mem_leak(void) __attribute__((destructor));

  50. #endif

复制代码
leak_detector.c:
  1. #include        <stdio.h>
  2. #include        <malloc.h>
  3. #include        <string.h>
  4. #include    <time.h>
  5. #include <execinfo.h>

  7. #include        "leak_detector.h"

  9. #undef                malloc
  10. #undef                calloc
  11. #undef      realloc
  12. #undef                 free


  15. static MEM_LEAK * ptr_start = NULL; //list head
  16. static MEM_LEAK * ptr_end =  NULL;  //list tail


  19. /*
  20. * get function call trace information
  21. * return a pointer to trace info
  22. */
  23. MEM_TRACE_INFO* getTrackInfo() {
  24.   void *array[CALL_DEPTH];
  25.   size_t size;
  26.   size = backtrace(array, 10);
  27.   char** trace=backtrace_symbols(array, size);
  28.   MEM_TRACE_INFO* traceInfo=(MEM_TRACE_INFO*)malloc(sizeof(MEM_TRACE_INFO));
  29.   if(traceInfo == NULL)
  30.           return NULL;
  31.   traceInfo->size=size;
  32.   traceInfo->traceInfo=trace;
  33.   return traceInfo;
  34. }




  39. /*
  40. * adds allocated memory info into likedlist
  41. *
  42. */
  43. void add(MEM_INFO alloc_info)
  44. {
  45.     printf("add new allocation info:%d\n",(int)alloc_info.address);
  46.     MEM_LEAK* mem_leak_info=NULL;
  47.         mem_leak_info=(MEM_LEAK*)malloc(sizeof(MEM_LEAK));
  48.     mem_leak_info->mem_info.address=alloc_info.address;
  49.         mem_leak_info->mem_info.size=alloc_info.size;
  50.         strcpy(mem_leak_info->mem_info.file_name,alloc_info.file_name);
  51.         mem_leak_info->mem_info.line=alloc_info.line;
  52.         mem_leak_info->mem_info.traceInfo=alloc_info.traceInfo;
  53.     strncpy(mem_leak_info->mem_info.allocTime, alloc_info.allocTime,TIME_LEN);


  56.     if (ptr_start == NULL)  //the list has no node
  57.     {
  58.         ptr_start = mem_leak_info;
  59.         ptr_end = ptr_start;
  60.     }
  61.     else {                  //add allocated info into the tail of list
  62.         ptr_end->next = mem_leak_info;
  63.         ptr_end = ptr_end->next;
  64.     }

  66. }

  68. /*
  69. * remove memory info(address) from the list
  70. *
  71. */

  73. void erase(void* address){
  74.     MEM_LEAK * temp = ptr_start;
  75.     MEM_LEAK * pre;
  76.     if(temp != NULL && temp->mem_info.address == address){ //if the node is the head of the list
  77.         ptr_start=temp->next;
  78.         free(temp->mem_info.traceInfo);   //release space that stores traceInfo
  79.         free(temp);                       //release space that stores list node
  80.         return;
  81.     }

  83.     if(temp->next != NULL){
  84.         pre=temp;
  85.         temp=temp->next;
  86.         for(; temp != NULL; pre=temp, temp=temp->next){
  87.             if(temp->mem_info.address == address){    //find the node
  88.                 pre->next = temp->next;
  89.                 if(temp->next == NULL)     //the node to be removed is the tail of the list
  90.                     ptr_end=pre;
  91.                 free(temp->mem_info.traceInfo);   //free space for traceinfo
  92.                 free(temp);                     //free space for list node
  93.                 break;
  94.             }
  95.         }
  96.     }

  98. }

  100. /*
  101. * deletes all the elements from the list and free the space
  102. */
  103. void clear()
  104. {
  105.     MEM_LEAK * temp = ptr_start;
  106.     MEM_LEAK * alloc_info = ptr_start;

  108.     while(alloc_info != NULL)
  109.     {
  110.         alloc_info = alloc_info->next;
  111.         free(temp->mem_info.traceInfo);
  112.         free(temp);
  113.         temp = alloc_info;
  114.     }
  115. }

  117. /*
  118. * replacement of malloc
  119. */
  120. void * mymalloc (unsigned int size, const char * file, unsigned int line)
  121. {
  122.     void * ptr = malloc (size);   
  123.     if (ptr != NULL)
  124.     {  
  125.                 MEM_TRACE_INFO* traceinfo=getTrackInfo();
  126.         add_mem_info(ptr, size, file, line,traceinfo);
  127.     }
  128.     return ptr;
  129. }

  131. /*
  132. * replacement of calloc
  133. */
  134. void * mycalloc (unsigned int elements, unsigned int size, const char * file, unsigned int line)
  135. {
  136.     unsigned total_size;
  137.     void * ptr = calloc(elements , size);
  138.     if(ptr != NULL)
  139.     {
  140.                 MEM_TRACE_INFO* traceinfo=getTrackInfo();
  141.         total_size = elements * size;
  142.         add_mem_info (ptr, total_size, file, line,traceinfo);
  143.     }
  144.     return ptr;
  145. }

  147. /*
  148. * replacement of malloc
  149. */
  150. void* myrealloc(void* address, unsigned int size, const char * file, unsigned int line){
  151.     printf("realloc\n");
  152.     unsigned total_size;
  153.     void* ptr=realloc(address,size);
  154.     if(ptr!=NULL){
  155.         MEM_TRACE_INFO* traceinfo=getTrackInfo();
  156.         remove_mem_info(address);
  157.         add_mem_info(address, size, file, line ,traceinfo);
  158.     }
  159. }

  161. /*
  162. * replacement of free
  163. */
  164. void myfree(void * mem_ref)
  165. {
  166.     remove_mem_info(mem_ref);
  167.     free(mem_ref);
  168. }

  170. /*
  171. * gets the allocated memory info and adds it to a list
  172. *
  173. */
  174. void add_mem_info (void * mem_ref, unsigned int size,  const char * file, unsigned int line,MEM_TRACE_INFO* traceinfo)
  175. {
  176.     MEM_INFO mem_alloc_info;
  177.         memset(&mem_alloc_info,0,sizeof(mem_alloc_info));
  178.     mem_alloc_info.address = mem_ref;
  179.     mem_alloc_info.size = size;
  180.     strcpy(mem_alloc_info.file_name, file);
  181.     mem_alloc_info.line = line;
  182.     mem_alloc_info.traceInfo=traceinfo;
  183.     time_t timeP = time(0);
  184.     char* t=ctime(&timeP);
  185.     strncpy(mem_alloc_info.allocTime, t,TIME_LEN);


  188.     /* add the above info to a list */
  189.     add(mem_alloc_info);
  190. }

  192. /*
  193. * if the allocated memory info is part of the list, removes it
  194. *
  195. */
  196. void remove_mem_info (void * mem_ref)
  197. {
  198.     erase(mem_ref);
  199. }

  201. /*
  202. * writes all info of the unallocated memory into a file
  203. */
  204. void report_mem_leak(void)
  205. {
  206.     unsigned int i;
  207.     printf("%s","mem_leak");
  208.     unsigned short index;
  209.     MEM_LEAK * leak_info;

  211.     FILE * fp_write = fopen (OUTPUT_FILE, "w");
  212.     char info[1024];

  214.     if(fp_write != NULL)
  215.     {
  216.         fprintf(fp_write, "%s\n", "Memory Leak Summary");
  217.         fprintf(fp_write, "%s\n", "-----------------------------------");

  219.         for(leak_info = ptr_start; leak_info != NULL; leak_info = leak_info->next)
  220.         {
  221.             fprintf(fp_write, "address : %x\n", (int)leak_info->mem_info.address);
  222.             fprintf(fp_write, "size    : %d bytes\n", leak_info->mem_info.size);
  223.             fprintf(fp_write, "file    : %s\n", leak_info->mem_info.file_name);

  225.             fprintf(fp_write, "line    : %d\n", leak_info->mem_info.line);
  226.                  fprintf(fp_write, "Time    : %s\n", leak_info->mem_info.allocTime);
  227.             fprintf(fp_write, "traceInfo    :\n");
  228.             for(i=2;i<leak_info->mem_info.traceInfo->size-2;i++){
  229.                 fprintf(fp_write, " %s\n", leak_info->mem_info.traceInfo->traceInfo[i]);
  230.             }
  231.             fprintf(fp_write, "%s\n", "-----------------------------------");
  232.         }
  233.     }
  234.     clear();
  235. }

复制代码

test.c:

  2. /***************************************************/
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include "leak_detector.h"

  7. /*********************************/
  8. /*Correct use of MALLOC and FREE */
  9. /*********************************/

  11. //Protoytpe simple function
  12. void modify(double *);
  13. void leak(int);

  15. //Main program
  16. int main()
  17. {

  19.                 //Define the size of Array
  20.                 int SIZE=100, i;

  22.                 //Define the array starting point pointer.
  23.                 double *array;

  25.                 //Allocate memory for doubles
  26.                 array = (double *)malloc(sizeof(double)*SIZE + 1);

  28.                 //Check the memory was allocated
  29.                 if (array==NULL){
  30.                                 printf("Memory could not be allocated \n");
  31.                 }
  32.                 else {
  33.                                 printf("Memory was allocated – remember to free\n \n");

  35.                                 //Modify only the first 10 elements via a function.
  36.                                 //Modify global variable from within function.
  37.                                 modify(array);

  39.                                 //Print out the first 15 values of array;
  40.                                 printf("The first 10 will make sense, the next 5 wont! \n");
  41.                                 for(i=0;i<15;i++){
  42.                                 printf("a[%d] = %0.3f \n",i,array[i]);
  43.                                 }
  44.                 }
  45.                
  46.                 leak(6);
  47.                
  48.                 //free the memory allocated
  49.                 free(array);

  51.                 return 0;
  52. }

  54. //Create basic function – passes the pointer to array (first position)
  55. void modify(double *array_diff){
  56.                 int i;
  57.                
  58.                 for(i=0;i<10;i++){
  59.                                 array_diff[i]=i/(i*i + 1);
  60.                 }
  61.                
  62.                 leak(4);
  63.                
  64.                 return;
  65. }              
  66.                
  67.                
  68. void leak(int size){
  69.                 char *p=0;
  70.                
  71.                 p = (char*)malloc(size);
  72.                
  73.                 return;
  74. }

复制代码
makefile:
  1. test:test.c leak_detector.h leak.so
  2.         gcc -o test test.c ./leak.so -rdynamic
  3. leak.so:leak_detector.o
  4.         gcc -shared -o leak.so leak_detector.o -rdynamic
  5. leak_detector.o:leak_detector.h leak_detector.c
  6.         gcc -fpic -c leak_detector.c -rdynamic
  7. clean:
  8.         rm *.o *.so
复制代码
文件说明：
leak_detector.h: 提供了实现malloc和free接口的头文件。
leak_detector.c: 实现了自定义的内存申请和释放的函数。
test.c:                用来测试自定义内存申请和释放的函数
leak_info.txt:     运行结果将会保存在这个文件中
makefile:           用来编译程序。

运行方法：
make leak.so     //生成 leak.so
make test        //生成可执行文件 test
./test              //运行test


程序开发, 检测, 如何, 项目

相关帖子
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|Archiver|手机版|小黑屋|猿媛之家    

GMT+8, 2021-2-16 18:46 , Processed in 0.396635 second(s), 31 queries .

Powered by Discuz! X3.2

© 2001-2013 Comsenz Inc.

快速回复 返回顶部 返回列表