关于段错误的知识总结

客官°小女子只卖身不卖艺 2022-06-03 05:42 211阅读 0赞

自己在学习过程中经常遇到段错误，在网上查找了相关资料后将知识点总结如下：（总结中引用了其他文章中的内容可以在链接中查看原文）

段（segmentation）是指二进制文件内的区域，所有某种特定类型信息被保存在里面。

在可执行程序中，正文段（Text Segment）用于存储命令，数据段（Data Segment）用于存储已经初始化的全局变量，BBS段（BBS Segment）用于存储未赋值的全局变量所需的空间。堆栈段 （Stack Segment）调用栈所在的段叫做堆栈段，堆栈段在运行时动态创建。并且不能被越界访问，否则出现段错误（Segmentation Fault）。

关于段的具体讲解我引用了一篇比较好的文章，原文作者[jasonxty][] 原文链接http://blog.csdn.net/xtydtc/article/details/52900911[点击打开链接][Link 1]

[Linux进程的5个段  
][Link 1]

*  bss段：bss段通常是指用来存放程序中未初始化的全局变量的一块区域。bss英文Block started by symbol，bss属于静态内存分配。
 *  数据段：数据段通常用来存放程序中已初始化的全局变量的一块内存区域，属于静态内存分配。
 *  代码段：代码段通常用来存放程序执行代码的一块区域。这部分区域的大小在程序运行前就已经确定了，通常这块内存区域属于只读，有些架构也允许可写，在代码段中也有可能包含以下只读的常数变量，例如字符串常量等。程序段为程序代码在内存中映射一个程序可以在内存中有多个副本。
 *  堆（heap）：堆是用来存放进程中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc等函数分配内存时，新分配的内存就被动态分配到堆上，当利用free等函数释放内存时，被释放的内存从堆中被剔除。
 *  栈（stack）：栈又称堆栈，是用户存放程序临时创建的变量，也就是我们函数\{\}中定义的变量，但不包括static声明的变量，static意味着在数据段中存放变量。除此之外，在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中，由于栈的先进后出特点，所以栈特别方便用来保存、恢复调用现场。从这个意义上讲，我们可以把堆栈看成一个寄存，交换临时数据的内存区。

下面再来总结一下常见的段错误：

自己在网上找了很多，这里列出一份比较全的，原文作者[\_\_Lemon\_\_][Lemon]原文可查看http://blog.csdn.net/Since20140504/article/details/40300403[点击打开链接][Link 2]

在Linux内存管理中，Linux结合了CPU架构采用了分段机制；  
分段就是将内存分成大小不同的段空间，将进程之间和进程内部不同数据段之间隔离起来；  
当程序内存的数据的访问超出了系统所给这个程序数据段的范围，系统就会给进程发送一个信号SIGSEGV，程序将终止退出。  
所以，可以说段错误都是对内存操作错误引起的。

这里列举了常见的段错误：  
1.访问不存在的内存、访问未知的受保护的内存；  
2.访问未初始化的指针；  
3.写常量区（只读区）；  
4.在栈中定义过大的数组，导致进程的栈空间不足；  
5.数据类型格式转换错误;  
6.4G的buffer会导致IO出现段错误  
7.main函数递归调用导致栈溢出；  
8.数组读写越界；（不一定会导致段错误，但一定会踩（覆盖）了其它数据）  
9.使用局部变量返回值；(错误未知，有可能产生断错误)  
10.使用已经释放的堆内存；(错误未知，有可能产生断错误)  
11.当堆内存耗尽？

其它：  
重复free,delete内存，程序将收到信号SIGABRT，然后退出。

这也是前辈给出的代码实例：

<pre class="cpp" name="code">#include <stdio.h>
    #include <stdlib.h>
    #include <iostream.h>
    #include <signal.h>
    
    //1.空指针解引用,访问不存在的内存地址
    //访问一段未知、（非法）内存
    void test_null_pointer() 
    {
      char *p = NULL;
      char c = *p;
      
      int *p2 = (int*)0xffff;
      *p2;
    }
    
    //传入不存在的内存给strlen
    void test_strlen()
    {
      //int *p = NULL;
      char *p;
      cout<<strlen(p)<<endl; //Segmentation fault, 不能将NULL, /0, 0传入strlen  
    }
    
    struct sInt
    {
      int a;
      int *p;
    };
    //指针访问非法内存
    void test_violation()
    {
      sInt si;
      si.p = &si.a;
      /*
      si.p[0] = 0;
      si.p[1] = 1;
      si.p[2] = 2;  //（覆盖了原指针的值）对指针重新赋值
      si.p[3] = 3;  //访问非法内存
      */
      *(si.p) = 0;
      *(si.p+1) = 1;
      *(si.p+2) = 2;
      *(si.p+3) = 3;  
    }
    
    //2.访问未初始化指针
    void test_unknown()
    { 
      int *p; 
      *p = 100;
    }
    
    //3.写常量区
    void test_const()
    {
       char * p = "hello, world";
       p[0]= 'x';
    }
    
    //4.在栈中定义过大的数组，导致进程的栈空间不足，出现段错误
    void test_stack()
    {
      float array[99][99][999] = {0};  
    }
    
    //5.数据类型格式转换错误
    void test_datatype_format()
    {
    	//enum Week {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY};
    	//enum Week day = TUESDAY;
    	int day = 1;
    	printf("monday: %s \n",day);
    }
    
    //6.4G的buffer导致io出现段错误
    void test_malloc_4g()
    {  
      char * buf;
      buf = (char*)malloc(1<<31); //1<<31 4g
      fgets(buf, 1024, stdin);
      printf("%s \n", buf);  
    }
    
    //7.数组越界
    //数组越界不一定会导致段错误，但会踩（覆盖）了其它数据
    void test_array_breakboundary()
    {
      char a[1];
      strcpy(a,"hello,world !");
    }
    
    
    char * temp_pointer_return()
    {
      //char p[] = "xyz";
      //return p;
      char t = 'a';
      return &t;  
    }
    
    //8.使用局部变量返回值
    void test_temp_pointer()
    {
      char *p = temp_pointer_return();
      p[0] = 'a';
      p[1] = 'a';
      p[2] = 'a';  
    }
    
    //9.使用已经释放的堆内存
    void test_free_reuse()
    {
      char *p = (char*)malloc(sizeof(char));
      free(p);
      *p = 'a';    
    }
    
    //10.栈溢出，递归调用main()
    int main();
    void test_main()
    {
      static int i = 0;
      ++i;  
      cout<<i<<endl;
      main();
    }
    
    //堆内存耗尽
    void test_memory_out()
    {
      
      for(int i=0; i<0xffffffff;i++)
      {
        char *p = (char*)malloc(1<<31);
    	cout<<i<<endl;
      } 
    }
    
    //Aborted
    void test_delete()
    {
      char *p = new char;
      delete p;
      delete p;   
    }
    
    //Aborted
    void test_free()
    {
      char *p = (char*)malloc(sizeof(char));
      free(p);
      free(p);
    }
    
    void catchSegFault(int )
    {
      cout<<"Hello, Segmentation fault!"<<endl;
      exit(0);
    }
    
    int main()
    {
      //signal(SIGSEGV, catchSegFault);  
      //test_null_pointer();
      //test_strlen();
      //test_violation();
      //test_unknown();
      //test_const();
      //test_stack();
      test_datatype_format();
      //test_malloc_4g();
      //test_array_breakboundary();
      //test_temp_pointer();
      //test_free_reuse();
      //test_main(); 
      //test_memory_out();  
      //test_delete();
      //test_free();  
      return 1;
    }

[jasonxty]: http://blog.csdn.net/xtydtc
[Link 1]: http://blog.csdn.net/xtydtc/article/details/52900911
[Lemon]: http://blog.csdn.net/since20140504
[Link 2]: http://blog.csdn.net/Since20140504/article/details/40300403