devbox
正经夜光杯
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言 --段错误（核心已转储）_段错误 (核心已转储)

作者：正经夜光杯 | 2024-07-26 00:05:14

赞

踩

段错误 (核心已转储)

文章原地址：https://blog.csdn.net/qq_29350001/article/details/53780697 

（侵删欠）

一、什么是段错误？

一旦一个程序发生了越界访问，cpu 就会产生相应的保护，于是 segmentation fault 就出现了，通过上面的解释，段错误应该就是访问了不可访问的内存，这个内存区要么是不存在的，要么是受到系统保护的，还有可能是缺少文件或者文件损坏。

二、段错误产生的原因

下面是一些典型的段错误的原因:
非关联化空指针——这是特殊情况由内存管理硬件
试图访问一个不存在的内存地址(在进程的地址空间)
试图访问内存的程序没有权利(如内核结构流程上下文)
试图写入只读存储器(如代码段)

1、访问不存在的内存地址

在C代码,分割错误通常发生由于指针的错误使用,特别是在C动态内存分配。非关联化一个空指针总是导致段错误,但野指针和悬空指针指向的内存,可能会或可能不会存在,而且可能或不可能是可读的还是可写的,因此会导致瞬态错误。

  1. #include <stdio.h>  
  2.   
  3. int main (void)  
  4. {  
  5.     int *ptr = NULL;  
  6.     *ptr = 0;  
  7.     return 0;  
  8. }  
  9. 输出结果：  
  10. 段错误（核心已转储）

现在,非关联化这些变量可能导致段错误:非关联化空指针通常会导致段错误,阅读时从野指针可能导致随机数据但没有段错误,和阅读从悬空指针可能导致有效数据,然后随机数据覆盖。

2、访问系统保护的内存地址 

  1. #include <stdio.h>  
  2.   
  3. int main (void)  
  4. {  
  5.     int *ptr = (int *)0;  
  6.     *ptr = 100;  
  7.     return 0;  
  8. }  
  9. 输出结果:  
  10. 段错误（核心已转储）

3、访问只读的内存地址

写入只读存储器提出了一个 segmentation fault,这个发生在程序写入自己的一部分代码段或者是只读的数据段,这些都是由操作系统加载到只读存储器。

  1. #include <stdio.h>  
  2. #include <string.h>  
  3.   
  4. int main (void)  
  5. {  
  6.     char *ptr = "test";  
  7.     strcpy (ptr, "TEST");  
  8.     return 0;  
  9. }  
  10. 输出结果：  
  11. 段错误（核心已转储）  
  1. #include <stdio.h>  
  2.   
  3. int main (void)  
  4. {  
  5.     char *ptr = "hello";  
  6.     *ptr = 'H';  
  7.     return 0;  
  8. }  
  9. 输出结果：  
  10. 段错误（核心已转储）
上述例子ANSI C代码通常会导致段错误和内存保护平台。它试图修改一个字符串文字,这是根据ANSI C标准未定义的行为。大多数编译器在编译时不会抓,而是编译这个可执行代码,将崩溃。

包含这个代码被编译程序时,字符串“hello”位于rodata部分程序的可执行文件的只读部分数据段。当加载时,操作系统与其他字符串和地方常数只读段的内存中的数据。当执行时,一个变量 ptr 设置为指向字符串的位置,并试图编写一个H字符通过变量进入内存,导致段错误。编译程序的编译器不检查作业的只读的位置在编译时,和运行类unix操作系统产生以下运行时发生 segmentation fault。

可以纠正这个代码使用一个数组而不是一个字符指针,这个栈上分配内存并初始化字符串的值:

  1. #include <stdio.h>  
  2.   
  3. int main (void)  
  4. {  
  5.     char ptr[] = "hello";  
  6.     ptr[0] = 'H';  
  7.     return 0;  
  8. }

即使不能修改字符串(相反,这在C标准未定义行为),在C char *类型,所以没有隐式转换原始代码,在c++的 const char *类型,因此有一个隐式转换,所以编译器通常会抓住这个特定的错误。

4、空指针废弃

因为是一个很常见的程序错误空指针废弃（读或写在一个空指针，用于C的意思是“没有对象指针”作为一个错误指示器），大多数操作系统内存访问空指针的地址，这样它会导致段错误。

  1. #include <stdio.h>  
  2.   
  3. int main (void)  
  4. {  
  5.     int *ptr = NULL;  
  6.     printf ("%d\n", *ptr);  
  7.     return 0;  
  8. }  
  9. 输出结果：  
  10. 段错误（核心已转储）
这个示例代码创建了一个空指针，然后试图访问它的值（读值）。在运行时在许多操作系统中，这样做会导致段错误。

非关联化一个空指针，然后分配（写一个值到一个不存在的目标）也通常会导致段错误。

  1. #include <stdio.h>  
  2.   
  3. int main (void)  
  4. {  
  5.     int *ptr = NULL;  
  6.     *ptr = 1;  
  7.     return 0;  
  8. }  
  9. 输出结果：  
  10. 段错误（核心已转储）

下面的代码包含一个空指针，但当编译通常不会导致段错误，值是未使用的。因此，废弃通常会被优化掉，死代码消除。

  1. #include <stdio.h>  
  2.   
  3. int main (void)  
  4. {  
  5.     int *ptr = NULL;  
  6.     *ptr;  
  7.     return 0;  
  8. }

还有，比如malloc 动态分配内存，释放、置空完成后，不可再使用该指针。

  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <string.h>  
  4.   
  5. int main()  
  6. {  
  7.     char* str=(char* )malloc(100);  
  8.     if(*str)  
  9.     {  
  10.         return;   
  11.     }  
  12.     strcpy(str,"hello");  
  13.     printf("%s\n",str);  
  14.     free(str);  
  15.     str=NULL;  
  16.     strcpy(str,"abcdef");  
  17.     return 0;  
  18. }  
  19. 输出结果：  
  20. hello  
  21. 段错误 (核心已转储)

5、堆栈溢出

  1. #include <stdio.h>  
  2. #include <string.h>  
  3.   
  4. int main (void)  
  5. {  
  6.     main ();  
  7.     return 0;  
  8. }  
  9. 输出结果：  
  10. 段错误（核心已转储）

上述例子的无限递归，导致的堆栈溢出会导致段错误，但无线递归未必导致堆栈溢出，优化执行的编译器和代码的确切结构。在这种情况下，遥不可及的代码（返回语句）行为是未定义的。因此，编译器可以消除它，使用尾部调用优化，可能导致没有堆栈使用。其他优化可能包括将递归转换成迭代，给出例子的结构功能永远会导致程序运行，虽然可能不是其他堆栈溢出。

6、内存越界（数组越界，变量类型不一致等）

  1. #include <stdio.h>  
  2.   
  3. int main (void)  
  4. {  
  5.     char test[10];  
  6.     printf ("%c\n", test[100000]);  
  7.     return 0;  
  8. }  
  9. 输出结果：  
  10. 段错误（核心已转储）

三、段错误信息的获取

程序发生段错误时，提示信息很少，下面有几种查看段错误的发生信息的途径。

1、dmesg

dmesg 可以在应用程序崩溃时，显示内存中保存的相关信息。如下所示，通过 dmesg 命令可以查看发生段错误的程序名称、引起段错误发生的内存地址、指令指针地址、堆栈指针地址、错误代码、错误原因等。

  1. root@#dmesg  
  2. [ 6357.422282] a.out[3044]: segfault at 806851c ip b75cd668 sp bf8b2100 error 4 in libc-2.15.so[b7559000+19f000]

2、-g

使用gcc编译程序的源码时，加上 -g 参数，这样可以使得生成的二进制文件中加入可以用于 gdb 调试的有用信息。

参看：C语言再学习 -- GCC编译过程

可产生供gdb调试用的可执行文件，大小明显比只用-o选项编译汇编连接后的文件大。

  1. root@ubuntu:/home/tarena/project/c_test# gcc hello.c   
  2. root@ubuntu:/home/tarena/project/c_test# ls -la a.out   
  3. -rwxr-xr-x 1 root root 7159 Nov 26 23:32 a.out  
  4. root@ubuntu:/home/tarena/project/c_test# gcc -g hello.c   
  5. root@ubuntu:/home/tarena/project/c_test# ls -la a.out   
  6. -rwxr-xr-x 1 root root 8051 Nov 26 23:32 a.out

gdb的简单使用：

(gdb)l  列表（list）
(gdb)r  执行（run）
(gdb)n  下一个（next）
(gdb)q  退出（quit）
(gdb)p  输出（print）
(gdb)c  继续（continue）
(gdb)b 4 设置断点（break）
(gdb)d   删除断点（delete）

  1. root@ubuntu:/home/tarena/project/c_test# gdb a.out  
  2. GNU gdb (Ubuntu/Linaro 7.4-2012.02-0ubuntu2) 7.4-2012.02  
  3. Copyright (C) 2012 Free Software Foundation, Inc.  
  4. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>  
  5. This is free software: you are free to change and redistribute it.  
  6. There is NO WARRANTY, to the extent permitted by law.  Type "show copying"  
  7. and "show warranty" for details.  
  8. This GDB was configured as "i686-linux-gnu".  
  9. For bug reporting instructions, please see:  
  10. <http://bugs.launchpad.net/gdb-linaro/>...  
  11. Reading symbols from /home/tarena/project/c_test/a.out...done.  
  12. (gdb) l  
  13. 1   #include <stdio.h>  
  14. 2   int main (void)  
  15. 3   {  
  16. 4       printf ("hello world!\n");  
  17. 5       return 0;  
  18. 6   }  
  19. (gdb) r  
  20. Starting program: /home/tarena/project/c_test/a.out   
  21. hello world!  
  22. [Inferior 1 (process 6906) exited normally]  
  23. (gdb) q  
  24. root@ubuntu:/home/tarena/project/c_test#

3、nm

使用 nm 命令列出二进制文件中符号表，包括符号地址、符号类型、符号名等。这样可以帮助定位在哪里发生了段错误。

  1. root@# nm a.out   
  2. 08049f28 d _DYNAMIC  
  3. 08049ff4 d _GLOBAL_OFFSET_TABLE_  
  4. 080484ac R _IO_stdin_used  
  5.          w _Jv_RegisterClasses  
  6. 08049f18 d __CTOR_END__  
  7. 08049f14 d __CTOR_LIST__  
  8. 08049f20 D __DTOR_END__  
  9. 08049f1c d __DTOR_LIST__  
  10. 080485a4 r __FRAME_END__  
  11. 08049f24 d __JCR_END__  
  12. 08049f24 d __JCR_LIST__  
  13. 0804a010 A __bss_start  
  14. 0804a008 D __data_start  
  15. 08048460 t __do_global_ctors_aux  
  16. 08048330 t __do_global_dtors_aux  
  17. 0804a00c D __dso_handle  
  18.          w __gmon_start__  
  19. 08048452 T __i686.get_pc_thunk.bx  
  20. 08049f14 d __init_array_end  
  21. 08049f14 d __init_array_start  
  22. 08048450 T __libc_csu_fini  
  23. 080483e0 T __libc_csu_init  
  24.          U __libc_start_main@@GLIBC_2.0  
  25. 0804a010 A _edata  
  26. 0804a018 A _end  
  27. 0804848c T _fini  
  28. 080484a8 R _fp_hw  
  29. 08048294 T _init  
  30. 08048300 T _start  
  31. 0804a010 b completed.6159  
  32. 0804a008 W data_start  
  33. 0804a014 b dtor_idx.6161  
  34. 08048390 t frame_dummy  
  35. 080483b4 T main

4、ldd

使用 ldd 命令查看二进制程序的共享链接库依赖，包括库的名称、起始地址，这样可以确定段错误到底是发生在了自己的程序中还是依赖的共享库中。

  1. root@t# ldd a.out   
  2.     linux-gate.so.1 =>  (0xb7765000)  
  3.     libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xb75ac000)  
  4.     /lib/ld-linux.so.2 (0xb7766000)

四、段错误的调试方法

接下来的讲解是围绕下面的代码进行的：

  1. #include <stdio.h>  
  2.   
  3. int main (void)  
  4. {  
  5.     int *ptr = NULL;  
  6.     *ptr = 10;  
  7.     return 0;  
  8. }  
  9. 输出结果：  
  10. 段错误（核心已转储）

1、使用 printf 输出信息

这个是看似最简单，但往往很多情况下十分有效的调试方式，也许可以说是程序员用的最多的调试方式。简单来说，就是在程序的重要代码附近加上像 printf 这类输出信息，这样可以跟踪并打印出段错误在代码中可能出现的位置。

为了方便使用这种方法，可以使用条件编译指令 #define DEBUG 和 #endif 把 printf 函数包起来。这样在程序编译时，如果加上 -DDEBUG 参数就可以查看调试信息；否则不加上参数就不会显示调试信息。

参看：C语言再学习 -- C 预处理器

2、使用 gcc 和 gdb

1）调试步骤

A、为了能够使用 gdb 调试程序，在编译阶段加上 -g 参数。

root@# gcc -g test.c
B、使用 gdb 命令调试程序 
  1. root@# gdb a.out   
  2. GNU gdb (Ubuntu/Linaro 7.4-2012.02-0ubuntu2) 7.4-2012.02  
  3. Copyright (C) 2012 Free Software Foundation, Inc.  
  4. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>  
  5. This is free software: you are free to change and redistribute it.  
  6. There is NO WARRANTY, to the extent permitted by law.  Type "show copying"  
  7. and "show warranty" for details.  
  8. This GDB was configured as "i686-linux-gnu".  
  9. For bug reporting instructions, please see:  
  10. <http://bugs.launchpad.net/gdb-linaro/>...  
  11. Reading symbols from /home/tarena/project/c_test/a.out...done.  
  12. (gdb)

C、进入 gdb 后，运行程序

  1. (gdb) r  
  2. Starting program: /home/tarena/project/c_test/a.out   
  3.   
  4. Program received signal SIGSEGV, Segmentation fault.  
  5. 0x080483c4 in main () at test.c:6  
  6. 6       *ptr = 10;  
  7. (gdb)

从输出看出，程序收到 SIGSEGV 信号，触发段错误，并提示地址 0x080483c4、创建了一个空指针，然后试图访问它的值（读值）。

可以通过man 7 signal查看SIGSEGV的信息

  1. Signal     Value     Action   Comment  
  2.       ──────────────────────────────────────────────────────────────────────  
  3.       SIGHUP        1       Term    Hangup detected on controlling terminal  
  4.                                     or death of controlling process  
  5.       SIGINT        2       Term    Interrupt from keyboard  
  6.       SIGQUIT       3       Core    Quit from keyboard  
  7.       SIGILL        4       Core    Illegal Instruction  
  8.       SIGABRT       6       Core    Abort signal from abort(3)  
  9.       SIGFPE        8       Core    Floating point exception  
  10.       SIGKILL       9       Term    Kill signal  
  11.       SIGSEGV      11       Core    Invalid memory reference  
  12.       SIGPIPE      13       Term    Broken pipe: write to pipe with no  
  13.                                     readers  
  14.       SIGALRM      14       Term    Timer signal from alarm(2)  
  15.       SIGTERM      15       Term    Termination signal  
  16.       SIGUSR1   30,10,16    Term    User-defined signal 1  
  17.       SIGUSR2   31,12,17    Term    User-defined signal 2  
  18.       SIGCHLD   20,17,18    Ign     Child stopped or terminated  
  19.       SIGCONT   19,18,25    Cont    Continue if stopped  
  20.       SIGSTOP   17,19,23    Stop    Stop process  
  21.       SIGTSTP   18,20,24    Stop    Stop typed at tty  
  22.       SIGTTIN   21,21,26    Stop    tty input for background process  
  23.       SIGTTOU   22,22,27    Stop    tty output for background process  
  24.   
  25.       The signals SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.

D、完成调试后，输入 q 命令退出 gdb

  1. (gdb) q  
  2. A debugging session is active.  
  3.   
  4.     Inferior 1 [process 3483] will be killed.  
  5.   
  6. Quit anyway? (y or n) y

2）适用场景

A、仅当能确定程序一定会发生段错误的情况下适用。

B、当程序的源码可以获得的情况下，使用 -g 参数编译程序

C、一般用于测试阶段，生产环境下 gdb 会有副作用：使程序运行减慢，运行不够稳定，等等。

D、即使在测试阶段，如果程序过于复杂，gdb 也不能处理。

3、使用 core 文件和 gdb

上面有提到段错误触发SIGSEGV信号，通过man 7 signal，可以看到SIGSEGV默认的处理程序（handler）会打印段错误信息，并产生 core 文件，由此我们可以借助于程序异常退出生成的 core 文件中的调试信息，使用 gdb 工具来调试程序中的段错误。

1）调试步骤

A、在一些Linux版本下，默认是不产生 core 文件的，首先可以查看一下系统 core 文件的大小限制：

  1. root@# ulimit -c  
  2. 0

B、可以看到默认设置情况下，本机Linux环境下发生段错误不会自动生成 core 文件，下面设置下 core 文件的大小限制（单位为KB）

  1. root@# ulimit -c 1024  
  2. root@# ulimit -c   
  3. 1024
C、运行程序，发生段错误生成的 core 文件 
  1. root@# ./a.out   
  2. 段错误 (核心已转储)

D、加载 core 文件，使用 gdb 工具进行调试

  1. root@ubuntu:/home/tarena/project/c_test# gdb a.out core   
  2. GNU gdb (Ubuntu/Linaro 7.4-2012.02-0ubuntu2) 7.4-2012.02  
  3. Copyright (C) 2012 Free Software Foundation, Inc.  
  4. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>  
  5. This is free software: you are free to change and redistribute it.  
  6. There is NO WARRANTY, to the extent permitted by law.  Type "show copying"  
  7. and "show warranty" for details.  
  8. This GDB was configured as "i686-linux-gnu".  
  9. For bug reporting instructions, please see:  
  10. <http://bugs.launchpad.net/gdb-linaro/>...  
  11. Reading symbols from /home/tarena/project/c_test/a.out...done.  
  12. [New LWP 3491]  
  13.   
  14. warning: Can't read pathname for load map: 输入/输出错误.  
  15. Core was generated by `./a.out'.  
  16. Program terminated with signal 11, Segmentation fault.  
  17. #0  0x080483c4 in main () at test.c:6  
  18. 6       *ptr = 10;  
  19. (gdb)
从输出看出，可以显示出异样的段错误信息


E、完成调试后，输入 q 命令退出 gdb

(gdb) q

2）适用场景

A、适合于在实际生成环境下调试程度的段错误（即在不用重新发生段错误的情况下重现段错误）

B、当程序很复杂，core 文件相当大时，该方法不可用

4、使用 objdump

1）调试步骤

A、使用 dmesg 命令，找到最近发生的段错误输入信息

  1. root@# dmesg  
  2. [  372.350652] a.out[2712]: segfault at 0 ip 080483c4 sp bfd1f7b8 error 6 in a.out[8048000+1000]

其中，对我们接下来的调试过程有用的是发生段错误的地址 0 和指令指针地址 080483c4。

有时候,“地址引起的错”可以告诉你问题的根源。看到上面的例子,我们可以说，int *ptr = NULL; *ptr = 10;，创建了一个空指针，然后试图访问它的值（读值）。

B、使用 objdump 生成二进制的相关信息，重定向到文件中

  1. root@# objdump -d a.out > a.outDump   
  2. root@# ls  
  3. a.out  a.outDump  core  test.c

其中，生成的 a.outDump 文件中包含了二进制文件的 a.out 的汇编代码


C、在 a.outDump 文件中查找发生段错误的地址

  1. root@ubuntu:/home/tarena/project/c_test# grep -n -A 10 -B 10 "0" a.outDump  
  2. 1-  
  3. 2-a.out:     file format elf32-i386  
  4.   
  5. 118:080483b4 <main>:  
  6. 119: 80483b4:   55                      push   %ebp  
  7. 120: 80483b5:   89 e5                   mov    %esp,%ebp  
  8. 121: 80483b7:   83 ec 10                sub    $0x10,%esp  
  9. 122: 80483ba:   c7 45 fc 00 00 00 00    movl   $0x0,-0x4(%ebp)  
  10. 123: 80483c1:   8b 45 fc                mov    -0x4(%ebp),%eax  
  11. 124: 80483c4:   c7 00 0a 00 00 00       movl   $0xa,(%eax)  
  12. 125: 80483ca:   b8 00 00 00 00          mov    $0x0,%eax  
  13. 126: 80483cf:   c9                      leave    
  14. 127: 80483d0:   c3                      ret      
  15. 128: 80483d1:   90                      nop  
  16. 129: 80483d2:   90                      nop  
  17. 130: 80483d3:   90                      nop  
  18. 131: 80483d4:   90                      nop  
  19. 132: 80483d5:   90                      nop  
  20. 133: 80483d6:   90                      nop  
  21. 134: 80483d7:   90                      nop  
  22. 135: 80483d8:   90                      nop  
  23. 136: 80483d9:   90                      nop  
  24. 137: 80483da:   90                      nop  
  25. 138: 80483db:   90                      nop  
  26. 139: 80483dc:   90                      nop  
  27. 140: 80483dd:   90                      nop  
  28. 141: 80483de:   90                      nop  
  29. 142: 80483df:   90                      nop
通过对以上汇编代码分析，得知段错误发生main函数，对应的汇编指令是movl   $0xa,(%eax)，接下来打开程序的源码，找到汇编指令对应的源码，也就定位到段错误了。 

2）适用场景

A、不需要 -g 参数编译，不需要借助于core文件，但需要有一定的汇编语言基础。

B、如果使用 gcc 编译优化参数（-O1，-O2，-O3）的话，生成的汇编指令将会被优化，使得调试过程有些难度。

5、使用catchsegv

catchsegv 命令专门用来补货段错误，它通过动态加载器（ld-linux.so）的预加载机制（PRELOAD）把一个事先写好的 库（/lib/libSegFault.so）加载上，用于捕捉段错误的出错信息。

  1. root@t# catchsegv ./a.out  
  2. Segmentation fault (core dumped)  
  3. *** Segmentation fault  
  4. Register dump:  
  5.   
  6.  EAX: 00000000   EBX: b77a1ff4   ECX: bfd8a0e4   EDX: bfd8a074  
  7.  ESI: 00000000   EDI: 00000000   EBP: bfd8a048   ESP: bfd8a038  
  8.   
  9.  EIP: 080483c4   EFLAGS: 00010282  
  10.   
  11.  CS: 0073   DS: 007b   ES: 007b   FS: 0000   GS: 0033   SS: 007b  
  12.   
  13.  Trap: 0000000e   Error: 00000006   OldMask: 00000000  
  14.  ESP/signal: bfd8a038   CR2: 00000000  
  15.   
  16. Backtrace:  
  17. ??:0(main)[0x80483c4]  
  18. /lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xf3)[0xb761a4d3]  
  19. ??:0(_start)[0x8048321]  
  20.   
  21. Memory map:  
  22.   
  23. 08048000-08049000 r-xp 00000000 08:01 2102158 /home/tarena/project/c_test/a.out  
  24. 08049000-0804a000 r--p 00000000 08:01 2102158 /home/tarena/project/c_test/a.out  
  25. 0804a000-0804b000 rw-p 00001000 08:01 2102158 /home/tarena/project/c_test/a.out  
  26. 09467000-0948c000 rw-p 00000000 00:00 0 [heap]  
  27. b75e1000-b75fd000 r-xp 00000000 08:01 1704884 /lib/i386-linux-gnu/libgcc_s.so.1  
  28. b75fd000-b75fe000 r--p 0001b000 08:01 1704884 /lib/i386-linux-gnu/libgcc_s.so.1  
  29. b75fe000-b75ff000 rw-p 0001c000 08:01 1704884 /lib/i386-linux-gnu/libgcc_s.so.1  
  30. b75ff000-b7601000 rw-p 00000000 00:00 0  
  31. b7601000-b77a0000 r-xp 00000000 08:01 1704863 /lib/i386-linux-gnu/libc-2.15.so  
  32. b77a0000-b77a2000 r--p 0019f000 08:01 1704863 /lib/i386-linux-gnu/libc-2.15.so  
  33. b77a2000-b77a3000 rw-p 001a1000 08:01 1704863 /lib/i386-linux-gnu/libc-2.15.so  
  34. b77a3000-b77a6000 rw-p 00000000 00:00 0  
  35. b77b8000-b77bb000 r-xp 00000000 08:01 1704847 /lib/i386-linux-gnu/libSegFault.so  
  36. b77bb000-b77bc000 r--p 00002000 08:01 1704847 /lib/i386-linux-gnu/libSegFault.so  
  37. b77bc000-b77bd000 rw-p 00003000 08:01 1704847 /lib/i386-linux-gnu/libSegFault.so  
  38. b77bd000-b77bf000 rw-p 00000000 00:00 0  
  39. b77bf000-b77c0000 r-xp 00000000 00:00 0 [vdso]  
  40. b77c0000-b77e0000 r-xp 00000000 08:01 1704843 /lib/i386-linux-gnu/ld-2.15.so  
  41. b77e0000-b77e1000 r--p 0001f000 08:01 1704843 /lib/i386-linux-gnu/ld-2.15.so  
  42. b77e1000-b77e2000 rw-p 00020000 08:01 1704843 /lib/i386-linux-gnu/ld-2.15.so  
  43. bfd6b000-bfd8c000 rw-p 00000000 00:00 0 [stack]

五、内存泄漏检测工具Valgrind

参看：Unix下C程序内存泄漏检测工具Valgrind安装与使用

参看：valgrind 的使用简介

Valgrind是一款用于内存调试、内存泄漏检测以及性能分析的软件开发工具。

官网：valgrind

（1）下载安装

下载：https://sourceware.org/pub/valgrind/valgrind-3.13.0.tar.bz2
安装：

  1. #tar xvf valgrind-3.13.0.tar.bz2  
  2. #cd valgrind-3.13.0  
  3. #./configure --prefix=/usr/local/webserver/valgrind  
  4. #make  
  5. #make install  
  6.   
  7. 添加环境变量：  
  8. #vi /etc/profile  
  9. PATH=${PATH}:/usr/local/webserver/valgrind/bin  
  10. #source /etc/profile
执行 valgrind ls -l 出现如下错误： 
  1. # valgrind ls -l  
  2. ==16243== Memcheck, a memory error detector  
  3. ==16243== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.  
  4. ==16243== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info  
  5. ==16243== Command: ls -l  
  6. ==16243==   
  7.   
  8. valgrind:  Fatal error at startup: a function redirection  
  9. valgrind:  which is mandatory for this platform-tool combination  
  10. valgrind:  cannot be set up.  Details of the redirection are:  
  11. valgrind:    
  12. valgrind:  A must-be-redirected function  
  13. valgrind:  whose name matches the pattern:      strlen  
  14. valgrind:  in an object with soname matching:   ld-linux.so.2  
  15. valgrind:  was not found whilst processing  
  16. valgrind:  symbols from the object with soname: ld-linux.so.2  
  17. valgrind:    
  18. valgrind:  Possible fixes: (1, short term): install glibc's debuginfo  
  19. valgrind:  package on this machine.  (2, longer term): ask the packagers  
  20. valgrind:  for your Linux distribution to please in future ship a non-  
  21. valgrind:  stripped ld.so (or whatever the dynamic linker .so is called)  
  22. valgrind:  that exports the above-named function using the standard  
  23. valgrind:  calling conventions for this platform.  The package you need  
  24. valgrind:  to install for fix (1) is called  
  25. valgrind:    
  26. valgrind:    On Debian, Ubuntu:                 libc6-dbg  
  27. valgrind:    On SuSE, openSuSE, Fedora, RHEL:   glibc-debuginfo  
  28. valgrind:    
  29. valgrind:  Note that if you are debugging a 32 bit process on a  
  30. valgrind:  64 bit system, you will need a corresponding 32 bit debuginfo  
  31. valgrind:  package (e.g. libc6-dbg:i386).  
  32. valgrind:    
  33. valgrind:  Cannot continue -- exiting now.  Sorry.
以上错误，是因为在Ubuntu下还需要一个LIB：libc6-dbg
运行：sudo apt-get install libc6-dbg 以安装libc6-dbg

然后再次运行： valgrind ls -l

  1. $ valgrind ls -l    
  2. ==14297== Memcheck, a memory error detector  
  3. ==14297== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.  
  4. ==14297== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info  
  5. ==14297== Command: ls -l  
  6. ==14297==   
  7. 总用量 4  
  8. -rw-rw-r-- 1 tarena tarena 105  1月 15 10:04 test.c  
  9. ==14297==   
  10. ==14297== HEAP SUMMARY:  
  11. ==14297==     in use at exit: 13,265 bytes in 29 blocks  
  12. ==14297==   total heap usage: 218 allocs, 189 frees, 73,974 bytes allocated  
  13. ==14297==   
  14. ==14297== LEAK SUMMARY:  
  15. ==14297==    definitely lost: 80 bytes in 2 blocks  
  16. ==14297==    indirectly lost: 240 bytes in 20 blocks  
  17. ==14297==      possibly lost: 0 bytes in 0 blocks  
  18. ==14297==    still reachable: 12,945 bytes in 7 blocks  
  19. ==14297==         suppressed: 0 bytes in 0 blocks  
  20. ==14297== Rerun with --leak-check=full to see details of leaked memory  
  21. ==14297==   
  22. ==14297== For counts of detected and suppressed errors, rerun with: -v  
  23. ==14297== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

（2）选项：

  1. <span style="color:#000000;">#valgrind -h  
  2. usage: valgrind [options] prog-and-args  
  3.   
  4.   tool-selection option, with default in [ ]:  
  5.     --tool=<name>             use the Valgrind tool named <name> [memcheck]  
  6.   
  7.   basic user options for all Valgrind tools, with defaults in [ ]:  
  8.     -h --help                 show this message  
  9.     --help-debug              show this message, plus debugging options  
  10.     --version                 show version  
  11.     -q --quiet                run silently; only print error msgs  
  12.     -v --verbose              be more verbose -- show misc extra info  
  13.     --trace-children=no|yes   Valgrind-ise child processes (follow execve)? [no]  
  14.     --trace-children-skip=patt1,patt2,...    specifies a list of executables  
  15.                               that --trace-children=yes should not trace into  
  16.     --trace-children-skip-by-arg=patt1,patt2,...   same as --trace-children-skip=  
  17.                               but check the argv[] entries for children, rather  
  18.                               than the exe name, to make a follow/no-follow decision  
  19.     --child-silent-after-fork=no|yes omit child output between fork & exec? [no]  
  20.     --vgdb=no|yes|full        activate gdbserver? [yes]  
  21.                               full is slower but provides precise watchpoint/step  
  22.     --vgdb-error=<number>     invoke gdbserver after <number> errors [999999999]  
  23.                               to get started quickly, use --vgdb-error=0  
  24.                               and follow the on-screen directions  
  25.     --vgdb-stop-at=event1,event2,... invoke gdbserver for given events [none]  
  26.          where event is one of:  
  27.            startup exit valgrindabexit all none  
  28.     --track-fds=no|yes        track open file descriptors? [no]  
  29.     --time-stamp=no|yes       add timestamps to log messages? [no]  
  30.     --log-fd=<number>         log messages to file descriptor [2=stderr]  
  31.     --log-file=<file>         log messages to <file>  
  32.     --log-socket=ipaddr:port  log messages to socket ipaddr:port  
  33.   
  34.   user options for Valgrind tools that report errors:  
  35.     --xml=yes                 emit error output in XML (some tools only)  
  36.     --xml-fd=<number>         XML output to file descriptor  
  37.     --xml-file=<file>         XML output to <file>  
  38.     --xml-socket=ipaddr:port  XML output to socket ipaddr:port  
  39.     --xml-user-comment=STR    copy STR verbatim into XML output  
  40.     --demangle=no|yes         automatically demangle C++ names? [yes]  
  41.     --num-callers=<number>    show <number> callers in stack traces [12]  
  42.     --error-limit=no|yes      stop showing new errors if too many? [yes]  
  43.     --error-exitcode=<number> exit code to return if errors found [0=disable]  
  44.     --error-markers=<begin>,<end> add lines with begin/end markers before/after  
  45.                               each error output in plain text mode [none]  
  46.     --show-below-main=no|yes  continue stack traces below main() [no]  
  47.     --default-suppressions=yes|no  
  48.                               load default suppressions [yes]  
  49.     --suppressions=<filename> suppress errors described in <filename>  
  50.     --gen-suppressions=no|yes|all    print suppressions for errors? [no]  
  51.     --input-fd=<number>       file descriptor for input [0=stdin]  
  52.     --dsymutil=no|yes         run dsymutil on Mac OS X when helpful? [yes]  
  53.     --max-stackframe=<number> assume stack switch for SP changes larger  
  54.                               than <number> bytes [2000000]  
  55.     --main-stacksize=<number> set size of main thread's stack (in bytes)  
  56.                               [min(max(current 'ulimit' value,1MB),16MB)]  
  57.   
  58.   user options for Valgrind tools that replace malloc:  
  59.     --alignment=<number>      set minimum alignment of heap allocations [8]  
  60.     --redzone-size=<number>   set minimum size of redzones added before/after  
  61.                               heap blocks (in bytes). [16]  
  62.     --xtree-memory=none|allocs|full   profile heap memory in an xtree [none]  
  63.                               and produces a report at the end of the execution  
  64.                               none: no profiling, allocs: current allocated  
  65.                               size/blocks, full: profile current and cumulative  
  66.                               allocated size/blocks and freed size/blocks.  
  67.     --xtree-memory-file=<file>   xtree memory report file [xtmemory.kcg.%p]  
  68.   
  69.   uncommon user options for all Valgrind tools:  
  70.     --fullpath-after=         (with nothing after the '=')  
  71.                               show full source paths in call stacks  
  72.     --fullpath-after=string   like --fullpath-after=, but only show the  
  73.                               part of the path after 'string'.  Allows removal  
  74.                               of path prefixes.  Use this flag multiple times  
  75.                               to specify a set of prefixes to remove.  
  76.     --extra-debuginfo-path=path    absolute path to search for additional  
  77.                               debug symbols, in addition to existing default  
  78.                               well known search paths.  
  79.     --debuginfo-server=ipaddr:port    also query this server  
  80.                               (valgrind-di-server) for debug symbols  
  81.     --allow-mismatched-debuginfo=no|yes  [no]  
  82.                               for the above two flags only, accept debuginfo  
  83.                               objects that don't "match" the main object  
  84.     --smc-check=none|stack|all|all-non-file [all-non-file]  
  85.                               checks for self-modifying code: none, only for  
  86.                               code found in stacks, for all code, or for all  
  87.                               code except that from file-backed mappings  
  88.     --read-inline-info=yes|no read debug info about inlined function calls  
  89.                               and use it to do better stack traces.  [yes]  
  90.                               on Linux/Android/Solaris for Memcheck/Helgrind/DRD  
  91.                               only.  [no] for all other tools and platforms.  
  92.     --read-var-info=yes|no    read debug info on stack and global variables  
  93.                               and use it to print better error messages in  
  94.                               tools that make use of it (Memcheck, Helgrind,  
  95.                               DRD) [no]  
  96.     --vgdb-poll=<number>      gdbserver poll max every <number> basic blocks [5000]   
  97.     --vgdb-shadow-registers=no|yes   let gdb see the shadow registers [no]  
  98.     --vgdb-prefix=<prefix>    prefix for vgdb FIFOs [/tmp/vgdb-pipe]  
  99.     --run-libc-freeres=no|yes free up glibc memory at exit on Linux? [yes]  
  100.     --run-cxx-freeres=no|yes  free up libstdc++ memory at exit on Linux  
  101.                               and Solaris? [yes]  
  102.     --sim-hints=hint1,hint2,...  activate unusual sim behaviours [none]   
  103.          where hint is one of:  
  104.            lax-ioctls lax-doors fuse-compatible enable-outer  
  105.            no-inner-prefix no-nptl-pthread-stackcache fallback-llsc none  
  106.     --fair-sched=no|yes|try   schedule threads fairly on multicore systems [no]  
  107.     --kernel-variant=variant1,variant2,...  
  108.          handle non-standard kernel variants [none]  
  109.          where variant is one of:  
  110.            bproc android-no-hw-tls  
  111.            android-gpu-sgx5xx android-gpu-adreno3xx none  
  112.     --merge-recursive-frames=<number>  merge frames between identical  
  113.            program counters in max <number> frames) [0]  
  114.     --num-transtab-sectors=<number> size of translated code cache [32]  
  115.            more sectors may increase performance, but use more memory.  
  116.     --avg-transtab-entry-size=<number> avg size in bytes of a translated  
  117.            basic block [0, meaning use tool provided default]  
  118.     --aspace-minaddr=0xPP     avoid mapping memory below 0xPP [guessed]  
  119.     --valgrind-stacksize=<number> size of valgrind (host) thread's stack  
  120.                                (in bytes) [1048576]  
  121.     --show-emwarns=no|yes     show warnings about emulation limits? [no]  
  122.     --require-text-symbol=:sonamepattern:symbolpattern    abort run if the  
  123.                               stated shared object doesn't have the stated  
  124.                               text symbol.  Patterns can contain ? and *.  
  125.     --soname-synonyms=syn1=pattern1,syn2=pattern2,... synonym soname  
  126.               specify patterns for function wrapping or replacement.  
  127.               To use a non-libc malloc library that is  
  128.                   in the main exe:  --soname-synonyms=somalloc=NONE  
  129.                   in libxyzzy.so:   --soname-synonyms=somalloc=libxyzzy.so  
  130.     --sigill-diagnostics=yes|no  warn about illegal instructions? [yes]  
  131.     --unw-stack-scan-thresh=<number>   Enable stack-scan unwind if fewer  
  132.                   than <number> good frames found  [0, meaning "disabled"]  
  133.                   NOTE: stack scanning is only available on arm-linux.  
  134.     --unw-stack-scan-frames=<number>   Max number of frames that can be  
  135.                   recovered by stack scanning [5]  
  136.     --resync-filter=no|yes|verbose [yes on MacOS, no on other OSes]  
  137.               attempt to avoid expensive address-space-resync operations  
  138.     --max-threads=<number>    maximum number of threads that valgrind can  
  139.                               handle [500]  
  140.   
  141.   user options for Memcheck:  
  142.     --leak-check=no|summary|full     search for memory leaks at exit?  [summary]  
  143.     --leak-resolution=low|med|high   differentiation of leak stack traces [high]  
  144.     --show-leak-kinds=kind1,kind2,.. which leak kinds to show?  
  145.                                             [definite,possible]  
  146.     --errors-for-leak-kinds=kind1,kind2,..  which leak kinds are errors?  
  147.                                             [definite,possible]  
  148.         where kind is one of:  
  149.           definite indirect possible reachable all none  
  150.     --leak-check-heuristics=heur1,heur2,... which heuristics to use for  
  151.         improving leak search false positive [all]  
  152.         where heur is one of:  
  153.           stdstring length64 newarray multipleinheritance all none  
  154.     --show-reachable=yes             same as --show-leak-kinds=all  
  155.     --show-reachable=no --show-possibly-lost=yes  
  156.                                      same as --show-leak-kinds=definite,possible  
  157.     --show-reachable=no --show-possibly-lost=no  
  158.                                      same as --show-leak-kinds=definite  
  159.     --xtree-leak=no|yes              output leak result in xtree format? [no]  
  160.     --xtree-leak-file=<file>         xtree leak report file [xtleak.kcg.%p]  
  161.     --undef-value-errors=no|yes      check for undefined value errors [yes]  
  162.     --track-origins=no|yes           show origins of undefined values? [no]  
  163.     --partial-loads-ok=no|yes        too hard to explain here; see manual [yes]  
  164.     --expensive-definedness-checks=no|yes  
  165.                                      Use extra-precise definedness tracking [no]  
  166.     --freelist-vol=<number>          volume of freed blocks queue     [20000000]  
  167.     --freelist-big-blocks=<number>   releases first blocks with size>= [1000000]  
  168.     --workaround-gcc296-bugs=no|yes  self explanatory [no].  Deprecated.  
  169.                                      Use --ignore-range-below-sp instead.  
  170.     --ignore-ranges=0xPP-0xQQ[,0xRR-0xSS]   assume given addresses are OK  
  171.     --ignore-range-below-sp=<number>-<number>  do not report errors for  
  172.                                      accesses at the given offsets below SP  
  173.     --malloc-fill=<hexnumber>        fill malloc'd areas with given value  
  174.     --free-fill=<hexnumber>          fill free'd areas with given value  
  175.     --keep-stacktraces=alloc|free|alloc-and-free|alloc-then-free|none  
  176.         stack trace(s) to keep for malloc'd/free'd areas       [alloc-and-free]  
  177.     --show-mismatched-frees=no|yes   show frees that don't match the allocator? [yes]  
  178.   
  179.   Extra options read from ~/.valgrindrc, $VALGRIND_OPTS, ./.valgrindrc  
  180.   
  181.   Memcheck is Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.  
  182.   Valgrind is Copyright (C) 2000-2017, and GNU GPL'd, by Julian Seward et al.  
  183.   LibVEX is Copyright (C) 2004-2017, and GNU GPL'd, by OpenWorks LLP et al.  
  184.   
  185.   Bug reports, feedback, admiration, abuse, etc, to: www.valgrind.org.</span><span style="color:#993399;">  
  186. </span>

（3）使用

1、使用未初始化内存问题

  1. #include<stdio.h>  
  2. int main(void)  
  3. {  
  4.       
  5.     int a[5];  
  6.     int i,s;  
  7.     a[0]=a[1]=a[2]=a[3]=a[4]=0;  
  8.     s=0;  
  9.     for (i =0;i<5;i++)  
  10.         s+=a[i];  
  11.     if(s==377)  
  12.         printf("sum is %d\n",s);  
  13.     return 0;  
  14. }  
  15. 执行：  
  16. # gcc -Wall test.c -g -o test  
  17. # valgrind --tool=memcheck --leak-check=yes ./test  
  18.   
  19. $ valgrind --tool=memcheck --leak-check=yes ./test  
  20. ==14496== Memcheck, a memory error detector  
  21. ==14496== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.  
  22. ==14496== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info  
  23. ==14496== Command: ./test  
  24. ==14496==   
  25. ==14496==   
  26. ==14496== HEAP SUMMARY:  
  27. ==14496==     in use at exit: 0 bytes in 0 blocks  
  28. ==14496==   total heap usage: 0 allocs, 0 frees, 0 bytes allocated  
  29. ==14496==   
  30. ==14496== All heap blocks were freed -- no leaks are possible  
  31. ==14496==   
  32. ==14496== For counts of detected and suppressed errors, rerun with: -v  
  33. ==14496== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

2、内存读写越界

  1. #include<stdlib.h>  
  2. #include<stdio.h>  
  3.   
  4. int main(int argc,char *argv[])  
  5. {  
  6.     int len =4;  
  7.     int* pt =(int*)malloc(len*sizeof(int));  
  8.     int* p=pt;  
  9.     int i;  
  10.     for(i=0;i<len;i++)  
  11.     {  
  12.         p++;  
  13.     }  
  14.     *p=5;  
  15.     printf("the value of p equal:%d\n",*p);  
  16.     return 0;  
  17. }  
  18. 执行：  
  19. # gcc -Wall test.c -g -o test  
  20. # valgrind --tool=memcheck --leak-check=yes ./test  
  21.   
  22. $ valgrind --tool=memcheck --leak-check=yes ./test  
  23. ==14514== Memcheck, a memory error detector  
  24. ==14514== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.  
  25. ==14514== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info  
  26. ==14514== Command: ./test  
  27. ==14514==   
  28. ==14514== Invalid write of size 4  
  29. ==14514==    at 0x8048462: main (test.c:14)  
  30. ==14514==  Address 0x41f4038 is 0 bytes after a block of size 16 alloc'd  
  31. ==14514==    at 0x402BD74: malloc (vg_replace_malloc.c:270)  
  32. ==14514==    by 0x8048433: main (test.c:7)  
  33. ==14514==   
  34. ==14514== Invalid read of size 4  
  35. ==14514==    at 0x804846C: main (test.c:15)  
  36. ==14514==  Address 0x41f4038 is 0 bytes after a block of size 16 alloc'd  
  37. ==14514==    at 0x402BD74: malloc (vg_replace_malloc.c:270)  
  38. ==14514==    by 0x8048433: main (test.c:7)  
  39. ==14514==   
  40. the value of p equal:5  
  41. ==14514==   
  42. ==14514== HEAP SUMMARY:  
  43. ==14514==     in use at exit: 16 bytes in 1 blocks  
  44. ==14514==   total heap usage: 1 allocs, 0 frees, 16 bytes allocated  
  45. ==14514==   
  46. ==14514== 16 bytes in 1 blocks are definitely lost in loss record 1 of 1  
  47. ==14514==    at 0x402BD74: malloc (vg_replace_malloc.c:270)  
  48. ==14514==    by 0x8048433: main (test.c:7)  
  49. ==14514==   
  50. ==14514== LEAK SUMMARY:  
  51. ==14514==    definitely lost: 16 bytes in 1 blocks  
  52. ==14514==    indirectly lost: 0 bytes in 0 blocks  
  53. ==14514==      possibly lost: 0 bytes in 0 blocks  
  54. ==14514==    still reachable: 0 bytes in 0 blocks  
  55. ==14514==         suppressed: 0 bytes in 0 blocks  
  56. ==14514==   
  57. ==14514== For counts of detected and suppressed errors, rerun with: -v  
  58. ==14514== ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 0 from 0)

3、内存覆盖

  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3. #include<string.h>  
  4.   
  5. int main(int argc, char* argv[])  
  6. {  
  7.     char x[50];  
  8.     int i;  
  9.     for(i=0;i<50;i++)  
  10.     {  
  11.         x[i]=i+1;  
  12.     }  
  13.     strncpy(x+20,x,20);  
  14.     strncpy(x+20,x,21);  
  15.     strncpy(x,x+20,20);  
  16.     strncpy(x,x+20,21);  
  17.       
  18.     x[39]='\0';  
  19.     strcpy(x,x+20);  
  20.       
  21.     x[39]=39;  
  22.     x[50]='\0';  
  23.     strcpy(x,x+20);  
  24.       
  25.     return 0;  
  26. }  
  27. 执行：  
  28. # gcc -Wall test.c -g -o test  
  29. # valgrind --tool=memcheck --leak-check=yes ./test  
  30.   
  31. $ valgrind --tool=memcheck --leak-check=yes ./test  
  32. ==14551== Memcheck, a memory error detector  
  33. ==14551== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.  
  34. ==14551== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info  
  35. ==14551== Command: ./test  
  36. ==14551==   
  37. ==14551== Source and destination overlap in strncpy(0xbec6a0c3, 0xbec6a0af, 21)  
  38. ==14551==    at 0x402C860: strncpy (mc_replace_strmem.c:472)  
  39. ==14551==    by 0x80484E6: main (test.c:14)  
  40. ==14551==   
  41. ==14551== Source and destination overlap in strncpy(0xbec6a0af, 0xbec6a0c3, 21)  
  42. ==14551==    at 0x402C860: strncpy (mc_replace_strmem.c:472)  
  43. ==14551==    by 0x8048524: main (test.c:16)  
  44. ==14551==   
  45. ==14551== Source and destination overlap in strcpy(0xbec6a09a, 0xbec6a0ae)  
  46. ==14551==    at 0x402C6AB: strcpy (mc_replace_strmem.c:438)  
  47. ==14551==    by 0x8048561: main (test.c:23)  
  48. ==14551==   
  49. ==14551==   
  50. ==14551== HEAP SUMMARY:  
  51. ==14551==     in use at exit: 0 bytes in 0 blocks  
  52. ==14551==   total heap usage: 0 allocs, 0 frees, 0 bytes allocated  
  53. ==14551==   
  54. ==14551== All heap blocks were freed -- no leaks are possible  
  55. ==14551==   
  56. ==14551== For counts of detected and suppressed errors, rerun with: -v  
  57. ==14551== ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 0 from 0)

4、动态内存管理错误

  1. include<stdlib.h>  
  2. #include<stdio.h>  
  3.   
  4. int main(int argc,char *argv[])  
  5. {  
  6.     int i;  
  7.     char* p=(char*)malloc(10);  
  8.     char* pt=p;  
  9.     for(i =0;i<10;i++)  
  10.     {  
  11.         p[i]='z';  
  12.     }  
  13.     delete p;  
  14.       
  15.     pt[1]='x';  
  16.     free(pt);  
  17.     return 0;  
  18. }  
  19. 执行：  
  20. # g++ -Wall test.cpp -g -o test  
  21. # valgrind --tool=memcheck --leak-check=yes ./test  
  22.   
  23. $ valgrind --tool=memcheck --leak-check=yes ./test  
  24. ==14607== Memcheck, a memory error detector  
  25. ==14607== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.  
  26. ==14607== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info  
  27. ==14607== Command: ./test  
  28. ==14607==   
  29. ==14607== Mismatched free() / delete / delete []  
  30. ==14607==    at 0x402A92A: operator delete(void*) (vg_replace_malloc.c:480)  
  31. ==14607==    by 0x80484F6: main (test.cpp:13)  
  32. ==14607==  Address 0x4324028 is 0 bytes inside a block of size 10 alloc'd  
  33. ==14607==    at 0x402BD74: malloc (vg_replace_malloc.c:270)  
  34. ==14607==    by 0x80484B8: main (test.cpp:7)  
  35. ==14607==   
  36. ==14607== Invalid write of size 1  
  37. ==14607==    at 0x80484FE: main (test.cpp:15)  
  38. ==14607==  Address 0x4324029 is 1 bytes inside a block of size 10 free'd  
  39. ==14607==    at 0x402A92A: operator delete(void*) (vg_replace_malloc.c:480)  
  40. ==14607==    by 0x80484F6: main (test.cpp:13)  
  41. ==14607==   
  42. ==14607== Invalid free() / delete / delete[] / realloc()  
  43. ==14607==    at 0x402AD3D: free (vg_replace_malloc.c:446)  
  44. ==14607==    by 0x804850C: main (test.cpp:16)  
  45. ==14607==  Address 0x4324028 is 0 bytes inside a block of size 10 free'd  
  46. ==14607==    at 0x402A92A: operator delete(void*) (vg_replace_malloc.c:480)  
  47. ==14607==    by 0x80484F6: main (test.cpp:13)  
  48. ==14607==   
  49. ==14607==   
  50. ==14607== HEAP SUMMARY:  
  51. ==14607==     in use at exit: 0 bytes in 0 blocks  
  52. ==14607==   total heap usage: 1 allocs, 2 frees, 10 bytes allocated  
  53. ==14607==   
  54. ==14607== All heap blocks were freed -- no leaks are possible  
  55. ==14607==   
  56. ==14607== For counts of detected and suppressed errors, rerun with: -v  
  57. ==14607== ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 0 from 0)

5、内存泄漏

  1. //tree.h  
  2. #ifndef _BADLEAK_  
  3. #define _BAD_LEAK_  
  4.   
  5. typedef struct _node{  
  6.     struct _node *l;  
  7.     struct _node * r;  
  8.     char v;  
  9. }node;  
  10.   
  11. node *mk( node *l,  node *r, char val);  
  12. void nodefr(node *n);  
  13. #endif  
  14.   
  15. //tree.cpp  
  16. #include <stdio.h>  
  17. #include "tree.h"  
  18. #include <stdlib.h>  
  19.   
  20. node *mk(node *l, node * r, char val)  
  21. {  
  22.     node *f=(node* )malloc(sizeof(node));  
  23.     f->l=l;  
  24.     f->r=r;  
  25.     f->v=val;  
  26.     return f;  
  27. }  
  28.   
  29. void nodefr(node* n)  
  30. {  
  31.     if(n)  
  32.     {  
  33.         nodefr(n->l);  
  34.         nodefr(n->r);  
  35.         free(n);  
  36.     }  
  37. }  
  38.   
  39. //badleak.cpp  
  40. #include <stdio.h>  
  41. #include <stdlib.h>  
  42. #include "tree.h"  
  43.   
  44. int main()  
  45. {  
  46.     node* tree1, *tree2, * tree3;  
  47.     tree1=mk(mk(mk(0,0,'3'),0,'2'),0,'1');  
  48.     tree2=mk(0,mk(0,mk(0,0,'6'),'5'),'4');  
  49.     tree3=mk(mk(tree1,tree2,'8'),0,'7');  
  50.     //nodefr(tree3);  
  51.     return 0;  
  52. }  
  53.       
  54. 执行：  
  55. # g++ -Wall tree.cpp badleak.cpp -g -o badleak  
  56. #valgrind --tool=memcheck --leak-check=yes ./badleak   
  57.   
  58. $ valgrind --tool=memcheck --leak-check=yes ./badleak   
  59. ==14676== Memcheck, a memory error detector  
  60. ==14676== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.  
  61. ==14676== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info  
  62. ==14676== Command: ./badleak  
  63. ==14676==   
  64. ==14676==   
  65. ==14676== HEAP SUMMARY:  
  66. ==14676==     in use at exit: 96 bytes in 8 blocks  
  67. ==14676==   total heap usage: 8 allocs, 0 frees, 96 bytes allocated  
  68. ==14676==   
  69. ==14676== 96 (12 direct, 84 indirect) bytes in 1 blocks are definitely lost in loss record 8 of 8  
  70. ==14676==    at 0x402BD74: malloc (vg_replace_malloc.c:270)  
  71. ==14676==    by 0x804842B: mk(_node*, _node*, char) (tree.cpp:7)  
  72. ==14676==    by 0x8048560: main (badleak.cpp:10)  
  73. ==14676==   
  74. ==14676== LEAK SUMMARY:  
  75. ==14676==    definitely lost: 12 bytes in 1 blocks  
  76. ==14676==    indirectly lost: 84 bytes in 7 blocks  
  77. ==14676==      possibly lost: 0 bytes in 0 blocks  
  78. ==14676==    still reachable: 0 bytes in 0 blocks  
  79. ==14676==         suppressed: 0 bytes in 0 blocks  
  80. ==14676==   
  81. ==14676== For counts of detected and suppressed errors, rerun with: -v  
  82. ==14676== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

六、一些注意事项

1）出现段错误时，首先应该想到段错误的定义，从它出发考虑引发错误的原因。

2）在使用指针时，定义了指针后记得初始化指针，在使用的时候记得判断是否为 NULL

3）在使用数组时，注意数组是否被初始化，数组下标是否越界，数组元素是否存在等

4）在访问变量，注意变量所占地址空间是否已经被程序释放掉

5）在处理变量时，注意变量的格式控制是否合理等


























声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/882530
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号