使用valgrind检测内存泄露的问题。

 /* #filename: test1.c 这个例子演示了当对一个全局指针分配空间的时候,如果不显示调用free，也不会出现内存泄露,因为系统会自动回收。通过 valgrind测试。 */ #include <stdlib.h> #include <signal.h> #include <stdio.h> #include <stdbool.h> //use bool static int bIsExit = 0; int * x = NULL; //define global point void f(void) { x = malloc(10 * sizeof(int)); } void SigHandler(int signo) { bIsExit = true; } int main(int argc,char** argv) { bIsExit = false; f(); if(signal(SIGINT,SigHandler) == SIG_ERR) { printf("signal SIGINT error"); return 0; } if(signal(SIGTERM,SigHandler) == SIG_ERR) { printf("signal SIGTERM error"); return 0; } while(!bIsExit) { // sleep(2); } /* if(x) { free(x); x = NULL; } */ printf("succeed exit!"); return 0; }

$ gcc -Wall test1.c -g -o test1
$ valgrind --tool=memcheck --leak-check=full ./test1
==3391== Memcheck, a memory error detector.
==3391== Copyright (C) 2002-2008, and GNU GPL'd, by Julian Seward et al.
==3391== Using LibVEX rev 1878, a library for dynamic binary translation.
==3391== Copyright (C) 2004-2008, and GNU GPL'd, by OpenWorks LLP.
==3391== Using valgrind-3.4.0, a dynamic binary instrumentation framework.
==3391== Copyright (C) 2000-2008, and GNU GPL'd, by Julian Seward et al.
==3391== For more details, rerun with: -v
==3391==

==3391==
==3391== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 3 from 1)
==3391== malloc/free: in use at exit: 40 bytes in 1 blocks.
==3391== malloc/free: 1 allocs, 0 frees, 40 bytes allocated.
==3391== For counts of detected errors, rerun with: -v
==3391== searching for pointers to 1 not-freed blocks.
==3391== checked 57,196 bytes.
==3391==
==3391== LEAK SUMMARY:
==3391==    definitely lost: 0 bytes in 0 blocks.
==3391==      possibly lost: 0 bytes in 0 blocks.
==3391==    still reachable: 40 bytes in 1 blocks.
==3391==         suppressed: 0 bytes in 0 blocks.
==3391== Reachable blocks (those to which a pointer was found) are not shown.
==3391== To see them, rerun with: --leak-check=full --show-reachable=yes

 

我们可以看到没有内存泄露。

 

/* #filename: test2.c 这个例子演示了当对一个局部指针分配空间的时候,系统没有自动回收,将会有内存泄露,通过valgrind测试。 */ #include <stdlib.h> #include <signal.h> #include <stdio.h> #include <stdbool.h> //use bool static int bIsExit = 0; //int * x = NULL; void f(void) { int* x = malloc(10 * sizeof(int)); x[0] = 0; } void SigHandler(int signo) { bIsExit = true; } int main(int argc,char** argv) { bIsExit = false; f(); if(signal(SIGINT,SigHandler) == SIG_ERR) { printf("signal SIGINT error"); return 0; } if(signal(SIGTERM,SigHandler) == SIG_ERR) { printf("signal SIGTERM error"); return 0; } while(!bIsExit) { // sleep(2); } /* if(x) { free(x); x = NULL; } */ printf("succeed exit!"); return 0; }

 

$ gcc -Wall test2.c -g -o test2
$ valgrind --tool=memcheck --leak-check=full ./test2
gcc -Wall 1.c -g -o test2
~/20090212$ valgrind --tool=memcheck --leak-check=full test2
==3479== Memcheck, a memory error detector.
==3479== Copyright (C) 2002-2008, and GNU GPL'd, by Julian Seward et al.
==3479== Using LibVEX rev 1878, a library for dynamic binary translation.
==3479== Copyright (C) 2004-2008, and GNU GPL'd, by OpenWorks LLP.
==3479== Using valgrind-3.4.0, a dynamic binary instrumentation framework.
==3479== Copyright (C) 2000-2008, and GNU GPL'd, by Julian Seward et al.
==3479== For more details, rerun with: -v
==3479==
succeed exit!==3479==
==3479== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 3 from 1)
==3479== malloc/free: in use at exit: 40 bytes in 1 blocks.
==3479== malloc/free: 1 allocs, 0 frees, 40 bytes allocated.
==3479== For counts of detected errors, rerun with: -v
==3479== searching for pointers to 1 not-freed blocks.
==3479== checked 57,196 bytes.
==3479==
==3479== 40 bytes in 1 blocks are definitely lost in loss record 1 of 1
==3479==    at 0x4021B38: malloc (vg_replace_malloc.c:207)
==3479==    by 0x8048435: f (1.c:9)
==3479==    by 0x8048472: main (1.c:21)
==3479==
==3479== LEAK SUMMARY:
==3479==    definitely lost: 40 bytes in 1 blocks.
==3479==      possibly lost: 0 bytes in 0 blocks.
==3479==    still reachable: 0 bytes in 0 blocks.
==3479==         suppressed: 0 bytes in 0 blocks.

 

我们可以看到有内存泄露。

通过上面的例子，可以了解到:malloc系统函数分配的内存最好要自己释放,以免内存泄露。