伙伴云客服论坛»论坛 › S区 › S软件开发 › 查看内容

0 评论

0 收藏

分享

简单办法处置C/C++内存泄漏问题

博君一肖 楼主 发布于 2023-8-21 12:41:34 阅读 909 查看全部
搜更多： 百度 谷歌 360 搜狗 搜搜 有道 必应 即刻
目录

    内存泄漏的两个问题使用宏定义覆盖 malloc 和 free 函数使用 hook 钩子


内存泄漏的两个问题

    是否有内存泄漏？内存泄漏是在代码的哪一行？
检测内存泄漏主要从上面两个问题动手。

使用宏定义覆盖 malloc 和 free 函数

在单个文件中，可以使用这种方法检测是否有内存泄漏。
  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int main() {
  6.     void *p1 = malloc(10);
  7.     void *p2 = malloc(20);
  9.     free(p1);
  11. }
复制代码
上面的代码存在内存泄漏的问题，但是直接运行看不出问题。我们可以使用宏定义覆盖覆盖系统的 malloc 和 free 函数。
我们定义两个函数，分别是 my_malloc 和 my_free ，使用宏定义覆盖原来的 malloc 和 free 。
  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. void *my_malloc(size_t size, const char *file, int line) {
  6.     void *p = malloc(size);
  7.     printf("malloc[+]: addr: %p , size: %ld , file: %s , line: %d \n", p, size, file, line);
  8.     return p;
  10. }
  12. void my_free(void *p, const char *file, int line) {
  14.     free(p);
  15.     printf("free[-]: addr: %p\n", p);
  17. }
  19. #define malloc(size)    my_malloc(size, __FILE__, __LINE__)
  20. #define free(p)         my_free(p, __FILE__, __LINE__)
  22. int main() {
  24.     void *p1 = malloc(10);
  25.     void *p2 = malloc(20);
  27.     free(p1);
  29. }
复制代码
简单办法处置C/C++内存泄漏问题-1.png

运行结果如上图，我们可以看到哪一行代码调用了 malloc 以及对应的内存有没有 free 。
还可以把上面的代码改进一下，把信息写入到文件中，方面查看。
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  5. #if 1
  7. void *my_malloc(size_t size, const char *file, int line) {
  9.     void *p = malloc(size);
  11.     char buff[128] = { 0 };
  12.     sprintf(buff, "./mem/%p.mem", p); // 需要事前创建 mem 文件夹
  14.     FILE *fp = fopen(buff, "w");
  15.     fprintf(fp, "malloc[+%s:%d] --> addr:%p, size: %ld\n", file, line, p, size);
  16.     fflush(fp);
  17.     fclose(fp);
  19.     return p;
  21. }
  23. void my_free(void *p, const char *file, int line) {
  25.     char buff[128] = { 0 };
  26.     sprintf(buff, "./mem/%p.mem", p); // 需要事前创建 mem 文件夹
  28.     if (unlink(buff) < 0) {
  29.         printf("double free addr:%p\n", p);
  30.         return;
  31.     }
  33.     free(p);
  35. }
  37. #define malloc(size)    my_malloc(size, __FILE__, __LINE__)
  38. #define free(p)         my_free(p, __FILE__, __LINE__)
  40. #endif
  42. int main() {
  44.     void *p1 = malloc(10);
  45.     void *p2 = malloc(20);
  47.     free(p1);
  49. }
复制代码
运行后，结果如下，会在 mem 文件夹下存在一个文件，点开可以看到没有被 free 的内存的信息。
简单办法处置C/C++内存泄漏问题-2.png

简单办法处置C/C++内存泄漏问题-3.png

注意：
    这种方法局限性比较大，需要在每个文件开头展开这一段代码才可以。使用的第三方库无法覆盖同理可以覆盖 calloc 以及 realloc#define malloc(size) my_malloc(size,__FILE__, __LINE__)#define free§ my_free(p, __FILE__, __LINE__)这两行代码必需放在 my_malloc 和 my_free 的下面，否则会形成递归

使用 hook 钩子

dlsym 函数可以自己实现系统调用
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  5. #if 1
  7. // 定义回调函数类型
  8. typedef void *(*malloc_t)(size_t size);
  10. // 定义回调函数变量
  11. malloc_t malloc_f = NULL;
  13. // 同理
  14. typedef void (*free_t)(void *p);
  15. free_t free_f = NULL;
  17. void *malloc(size_t size) {
  19.     printf("malloc [+%s:%d]\n", __FILE__, __LINE__);
  21. }
  23. void free(void *p) {
  25.     printf("malloc [+%s:%d]\n", __FILE__, __LINE__);
  27. }
  29. void init_hook(void) {
  31.     if (malloc_f == NULL)
  32.         malloc_f = dlsym(RTLD_NEXT, "malloc"); // dlsym 需要加上编译条件 -ldl
  34.     if (free_f == NULL)
  35.         free_f = dlsym(RTLD_NEXT, "free");
  37. }
  39. #define DEBUG_MEM_LEAK init_hook();
  41. #endif
  43. int main() {
  45.     DEBUG_MEM_LEAK
  47.     void *p1 = malloc(10);
  48.     void *p2 = malloc(20);
  50.     free(p1);
  52. }
复制代码
上面这一份代码，在自己实现的 malloc 和 free 内部使用了 printf 函数，会呈现错误。
是因为在 printf 函数内部也是用了 malloc 来开拓缓冲区，就会形成递归调用。
简单办法处置C/C++内存泄漏问题-4.png

我们需要定义一个 flag 来防止递归的呈现。
  1. #define _GNU_SOURCE
  2. #include <dlfcn.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <unistd.h>
  8. #if 1
  10. // 定义回调函数类型
  11. typedef void *(*malloc_t)(size_t size);
  13. // 定义回调函数变量
  14. malloc_t malloc_f = NULL;
  16. // 同理
  17. typedef void (*free_t)(void *p);
  18. free_t free_f = NULL;
  20. // flag 防止递归
  21. int enable_malloc_hook = 1;
  22. int enable_free_hook = 1;
  24. void *malloc(size_t size) {
  26.     if (enable_malloc_hook == 1) {
  27.         enable_malloc_hook = 0;
  28.         printf("malloc [+%s:%d]\n", __FILE__, __LINE__);
  29.         enable_malloc_hook = 1;
  30.     }
  32. }
  34. void free(void *p) {
  36.     if (enable_malloc_hook == 1) {
  37.         enable_malloc_hook = 0;
  38.         printf("free [+%s:%d]\n", __FILE__, __LINE__);
  39.         enable_malloc_hook = 1;
  40.     }
  42. }
  44. void init_hook(void) {
  46.     if (malloc_f == NULL)
  47.         malloc_f = dlsym(RTLD_NEXT, "malloc"); // dlsym 需要加上编译条件 -ldl
  49.     if (free_f == NULL)
  50.         free_f = dlsym(RTLD_NEXT, "free");
  52. }
  54. #define DEBUG_MEM_LEAK init_hook();
  56. #endif
  58. int main() {
  60.     DEBUG_MEM_LEAK
  62.     void *p1 = malloc(10);
  63.     void *p2 = malloc(20);
  65.     free(p1);
  67. }
复制代码
简单办法处置C/C++内存泄漏问题-5.png

这是改进的代码的运行结果，但是又呈现了一个问题，申请内存的函数是在哪一行调用的，呈现了问题，全是在同一行调用的，这显然是有问题的。
我们可以使用 __builtin_return_address() 这个函数来处置，传入 0 就返回上一层函数的信息，传入 1 就返回上两层函数的信息，以及类推。
  1. #define _GNU_SOURCE
  2. #include <dlfcn.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <unistd.h>
  8. #if 1
  10. // 定义回调函数类型
  11. typedef void *(*malloc_t)(size_t size);
  13. // 定义回调函数变量
  14. malloc_t malloc_f = NULL;
  16. // 同理
  17. typedef void (*free_t)(void *p);
  18. free_t free_f = NULL;
  20. // flag 防止递归
  21. int enable_malloc_hook = 1;
  22. int enable_free_hook = 1;
  24. void *malloc(size_t size) {
  26.     if (enable_malloc_hook == 1) {
  27.         enable_malloc_hook = 0;
  29.         void *caller = __builtin_return_address(0); // 返回上一层调用函数的信息
  30.         printf("malloc [+]: %p\n", caller);
  32.         enable_malloc_hook = 1;
  33.     }
  35. }
  37. void free(void *p) {
  39.     if (enable_malloc_hook == 1) {
  40.         enable_malloc_hook = 0;
  42.         void *caller = __builtin_return_address(0); // 返回上一层调用函数的信息
  43.         printf("free [-]: %p\n", caller);
  45.         enable_malloc_hook = 1;
  46.     }
  48. }
  50. void init_hook(void) {
  52.     if (malloc_f == NULL)
  53.         malloc_f = dlsym(RTLD_NEXT, "malloc"); // dlsym 需要加上编译条件 -ldl
  55.     if (free_f == NULL)
  56.         free_f = dlsym(RTLD_NEXT, "free");
  58. }
  60. #define DEBUG_MEM_LEAK init_hook();
  62. #endif
  64. int main() {
  66.     DEBUG_MEM_LEAK
  68.     void *p1 = malloc(10);
  69.     void *p2 = malloc(20);
  71.     free(p1);
  73. }
复制代码
运行结果如图，得到了一串地址，可以使用 addr2line 来查看详细信息。
简单办法处置C/C++内存泄漏问题-6.png

下面改成文件版本
  1. #define _GNU_SOURCE
  2. #include <dlfcn.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <unistd.h>
  8. #if 1
  10. // 定义回调函数类型
  11. typedef void *(*malloc_t)(size_t size);
  13. // 定义回调函数变量
  14. malloc_t malloc_f = NULL;
  16. // 同理
  17. typedef void (*free_t)(void *p);
  18. free_t free_f = NULL;
  20. // flag 防止递归
  21. int enable_malloc_hook = 1;
  22. int enable_free_hook = 1;
  24. void *malloc(size_t size) {
  26.     if (enable_malloc_hook == 1) {
  27.         enable_malloc_hook = 0;
  29.         void *p = malloc_f(size);
  31.         void *caller = __builtin_return_address(0); // 返回上一层调用函数的信息
  33.         char buff[128] = { 0 };
  34.         sprintf(buff, "./mem/%p.mem", p); // 需要事前创建 mem 文件夹
  36.         FILE *fp = fopen(buff, "w");
  37.         fprintf(fp, "malloc[+%p] --> addr:%p, size: %ld\n", caller, p, size);
  38.         fflush(fp);
  39.         fclose(fp);
  41.         enable_malloc_hook = 1;
  42.         return p;
  43.     } else {
  44.         return malloc_f(size);
  45.     }
  47. }
  49. void free(void *p) {
  51.     if (enable_malloc_hook == 1) {
  52.         enable_malloc_hook = 0;
  54.         // void *caller = __builtin_return_address(0); // 返回上一层调用函数的信息
  56.         char buff[128] = { 0 };
  57.         sprintf(buff, "./mem/%p.mem", p); // 需要事前创建 mem 文件夹
  59.         if (unlink(buff) < 0) {
  60.             printf("double free addr:%p\n", p);
  61.             return;
  62.         }
  64.         free_f(p);
  66.         enable_malloc_hook = 1;
  67.     } else {
  68.         free_f(p);
  69.     }
  71. }
  73. void init_hook(void) {
  75.     if (malloc_f == NULL)
  76.         malloc_f = dlsym(RTLD_NEXT, "malloc"); // dlsym 需要加上编译条件 -ldl
  78.     if (free_f == NULL)
  79.         free_f = dlsym(RTLD_NEXT, "free");
  81. }
  83. #define DEBUG_MEM_LEAK init_hook();
  85. #endif
  87. int main() {
  89.     DEBUG_MEM_LEAK
  91.     void *p1 = malloc(10);
  92.     void *p2 = malloc(20);
  94.     free(p1);
  96. }
复制代码
到此这篇关于C/C++实现内存泄漏检测详解的文章就介绍到这了,更多相关C++内存泄漏检测内容请搜索网站以前的文章或继续阅读下面的相关文章希望大家以后多多支持网站！
回复

举报 使用道具

上一篇: 通晓C++11的lambda函数

下一篇: 轻松上手，让你成为DEV C++小白达人！

相关帖子
全部回复
暂无回帖，快来参与回复吧
返回列表 发新帖回复
本版积分规则 高级模式
B Color Image Link Quote Code Smilies

博君一肖
注册会员
主题 20
回复 16
粉丝 0
加好友 发私信
标签
PMP 销售 管理 零代码
产品
解决方案
学习资料
关于我们
进一步了解
取得联系
咨询专线
400 006 1585
关注服务号
微信交流群
© 2022 伙伴智慧(北京)信息技术有限公司京公网安备11010802025927号京ICP备12038259号 增值电信业务经营许可证:京B2-20201325
Created with Huoban.
|网站地图
快速回复 返回顶部 返回列表