什么是野指针和段错误

【⾯试题】野指针的成因，危害以及避免⽅法？概念：野指针指向了⼀块随机内存空间，不受程序控制。

如指针指向已经被删除的对象或者指向⼀块没有访问权限的内存空间，之后如果对其再解引⽤的话，就会出现问题。

野指针产⽣的原因：1、指针定义时未被初始化：指针在被定义的时候，如果程序不对其进⾏初始化的话，它会指向随机区域，因为任何指针变量（除了static修饰的指针变量）在被定义的时候是不会被置空的，它的默认值是随机的。

2、指针被释放时没有被置空：我们在⽤malloc开辟内存空间时，要检查返回值是否为空，如果为空，则开辟失败；如果不为空，则指针指向的是开辟的内存空间的⾸地址。

指针指向的内存空间在⽤free()或者delete（注意delete只是⼀个操作符，⽽free()是⼀个函数）释放后，如果程序员没有对其置空或者其他的赋值操作，就会使其成为⼀个野指针。

3、指针操作超越变量作⽤域：不要返回指向栈内存的指针或引⽤，因为栈内存在函数结束的时候会被释放，⽰例（转⾃⾼质量C++）：class A{public:void Func(void){cout << “Func of class A” << endl;}};class B{public:A *p;void Test(void){A a;p = &a; // 注意 a 的⽣命期，只在这个函数Test中，⽽不是整个class B}void Test1(){p->Func(); // p 是“野指针”}};函数 Test1 在执⾏语句 p->Func()时，p 的值还是 a 的地址，对象 a 的内容已经被清除，所以 p 就成了“野指针” 。

野指针的危害：野指针的问题在于，指针指向的内存已经⽆效了，⽽指针没有被置空，解引⽤⼀个⾮空的⽆效指针是⼀个未被定义的⾏为，也就是说不⼀定导致段错误，野指针很难定位到是哪⾥出现的问题，在哪⾥这个指针就失效了，不好查找出错的原因。

c segment fault的常见原因C语言中的Segmentation Fault（段错误）是程序运行时经常遇到的错误之一，它会导致程序异常终止。

本文将介绍一些常见的导致Segmentation Fault错误的原因，并给出相应的解决方案。

1. 野指针：当程序试图访问一个未初始化的指针或已被释放的指针时，就会发生Segmentation Fault错误。

解决方法是在使用指针之前进行初始化，并确保指针指向的内存空间有效。

2. 数组越界：当程序试图访问数组中超出其边界的元素时，就会发生Segmentation Fault错误。

解决方法是在访问数组元素之前，确保数组索引在合法范围内。

3. 内存泄漏：当程序分配了一块内存空间，但在使用完后没有正确释放时，就会发生Segmentation Fault错误。

解决方法是在使用完内存后，使用free()函数释放相应的内存空间。

4. 栈溢出：当程序的递归深度过大或局部变量占用的栈空间过大时，就会发生Segmentation Fault错误。

解决方法是增加栈的大小或优化递归算法。

5. 字符串操作错误：当程序试图修改常量字符串或者使用未初始化的字符串指针时，就会发生Segmentation Fault错误。

解决方法是使用char数组来存储字符串，或者在使用字符串指针之前进行初始化。

6. 文件操作错误：当程序打开文件失败或者试图读写已关闭的文件时，就会发生Segmentation Fault错误。

解决方法是在文件操作前检查文件是否成功打开，并在文件使用完后关闭文件。

7. 运算符错误：当程序出现除零操作或者对空指针进行运算时，就会发生Segmentation Fault错误。

解决方法是在进行除法运算前检查除数是否为零，并在进行指针运算前检查指针是否为NULL。

8. 函数调用错误：当程序传递错误的参数给函数或者函数返回值没有被正确处理时，就会发生Segmentation Fault错误。

野指针，悬垂指针，垃圾内存，内存“黑洞”野指针，悬垂指针，垃圾内存，内存“黑洞”标签：内存泄漏C++c语言编译器指针2014-07-31 16:53 367人阅读评论(0) 收藏举报分类：C/C++语言（36）作者：疯狂的红豆原文链接：/zlhy_/article/details/8794969野指针，首先它不是NULL指针，其次他指向的内存是不合法的，这个不合法的内存俗称“垃圾”内存。

它产生的原因一个是在free或是delete后，没有及时将指针设置为NULL。

野指针的检测也是很困难的，比如用if(0 == ptr)也是不行的，因为在free或是delete后ptr 并没有被设置为NULL。

关于为什么是(0 == ptr)而不是(ptr == 0)，这一点建议去看Effective C++的好像是前5个条款。

悬垂指针和野指针虽然称呼上不同，但是其本质是一致的，成因也是相似的。

当多个指针指向一块内存时，对其中的一个指针施加了free或是delete后，即使把这个指针设置为了NULL，可是其余的指向这块内存的指针也是指向了不合法内存的。

取名为悬垂指针，悬垂引用也是这个道理。

“垃圾”内存这个词是对某个指针说的，说某某指针访问了垃圾内存，就是访问了不合法的内存，也就是指针没有访问这块内存的权限，目前内存的使用权限在于编译器，就像是把一个指针free或是delete后没及时显示的手动的将其设置为NULL。

因为C/C++的机制原因，free和delete只是回收了指针所指向的内存，将这块内存的使用权限收归编译器所有，但是free和delete的内部实现中并没有将指针自动设置为NULL，这就是垃圾内存与野指针的成因。

垃圾内存与野指针，悬垂指针的检测很困难，因为编译器并不知道某个指针所指向的内存是否合法。

尽量避免这些问题，一个方法就是使用智能指针。

关于这一点的讨论与代码示例请参考一篇博文：点击打开连接内存“黑洞”是和上面三个完全不同的概念，在没有对一个指针施加free或是delete前就把这个指针设置为了NULL，这样，这块内存并不属于编译器，他是属于某个变量的合法访问区域，但是这个访问的指针已经不存在了，这样子这块内存就像是一个洞一样，得名曰内存“黑洞”。

c 指针的类型C指针的类型引言：C语言是一种广泛应用的编程语言，而指针则是C语言中非常重要的概念之一。

指针可以说是C语言的精华所在，掌握了指针的类型，对于理解C语言的底层机制和进行高效的编程至关重要。

本文将详细介绍C指针的类型，包括基本指针、空指针、野指针、指向常量的指针、指向函数的指针以及指向指针的指针。

一、基本指针基本指针是C语言中最常用的指针类型。

它可以指向任何类型的数据，包括整型、字符型、浮点型等。

通过基本指针，我们可以通过引用来修改指向的数据，实现对数据的间接操作。

二、空指针空指针是指未被初始化的指针，它不指向任何有效的内存地址。

在C语言中，空指针用NULL来表示。

使用空指针时需要注意，避免对空指针进行解引用操作，否则会导致程序崩溃。

三、野指针野指针是指指向未知或无效内存地址的指针。

野指针的出现通常是由于指针未被初始化或指向的内存已经被释放。

使用野指针会导致程序运行时出现未知错误，因此在使用指针时务必进行初始化。

四、指向常量的指针指向常量的指针是指指针所指向的数据是常量，不能通过指针来修改。

在C语言中，可以使用const关键字来声明指向常量的指针。

指向常量的指针在函数参数传递和数组操作中非常常见，它可以提高程序的安全性和效率。

五、指向函数的指针指向函数的指针是指指针所指向的是函数的地址。

通过函数指针，我们可以实现函数的动态调用和回调机制。

函数指针的类型与函数的声明保持一致，通过函数指针可以调用对应的函数。

六、指向指针的指针指向指针的指针是指指针所指向的是另一个指针的地址。

通过指向指针的指针，我们可以实现对指针的间接操作。

在C语言中，常用于多级指针的传递和动态内存分配等场景。

总结：C指针的类型包括基本指针、空指针、野指针、指向常量的指针、指向函数的指针以及指向指针的指针。

掌握这些指针类型对于理解C语言的底层机制和进行高效的编程非常重要。

使用指针时需要注意避免空指针和野指针的出现，同时合理使用指向常量的指针和指向函数的指针，可以提高程序的安全性和效率。

C语言中的段错误编译完程序，执行的时候,有时会莫名的出现“Segment fault”，即段错误，段错误是让许多C程序员都头疼的提示，因为对于这种模糊的提示，很难判断错误在哪里。

那么什么事段错误呢？以及怎么发现程序中的段错误以及如何避免发生段错误呢？1.什么是段错误？所谓的段错误就是指访问的内存超出了系统所给这个程序的内存空间，通常这个值是由gdtr来保存的，他是一个48位的寄存器，其中的32位是保存由它指向的gdt表，后13位保存相应于gdt的下标，最后3位包括了程序是否在内存中以及程序的在cpu中的运行级别,指向的gdt是由以64位为一个单位的表，在这张表中就保存着程序运行的代码段以及数据段的起始地址以及与此相应的段限和页面交换还有程序运行级别还有内存粒度等等的信息。

一旦一个程序发生了越界访问，cpu就会产生相应的异常保护，于是segmentation fault就出现了。

通过上面的解释，段错误应该就是访问了不可访问的内存，这个内存区要么是不存在的，要么是受到系统保护的。

2.那什么操作会引起段错误呢？粗略的分一下类：1）往受到系统保护的内存地址写数据有些内存是内核占用的或者是其他程序正在使用，为了保证系统正常工作，所以会受到系统的保护，而不能任意访问。

2）内存越界(数组越界，变量类型不一致等)3）其他例如：<1>定义了指针后记得初始化，在使用的时候记得判断是否为NULL<2>在使用数组的时候是否被初始化，数组下标是否越界，数组元素是否存在等<3>在变量处理的时候变量的格式控制是否合理等3.那么我们如何去发现程序中的段错误呢？通过学习前人的经验和开发的工具，不断的尝试和研究，找出更恰当的方法来避免、发现并处理它。

对于一些常见的地方，我们可以避免，对于一些“隐藏”的地方，我们要发现它，发现以后就要及时处理，避免留下隐患。

用gdb来调试，在运行到段错误的地方，会自动停下来并显示出错的行和行号，gdb也是最常用的，如果需要用gdb调试，记得在编译的时候加上-g参数。

C语⾔指针详解之野指针⽬录指针是什么？怎么表⽰？什么是指针变量？指针类型⼜是什么？指针类型存在的意义野指针是什么？野指针产⽣的原因⼀、指针未初始化⼆、指针越界访问如何避免野指针（野狗）的出现呢？指针运算总结指针是什么？指针只是⼀个名词⽽已，指针就是地址。

我们平时说指针，也可以指指针变量。

怎么表⽰？类型名指针变量 = 地址；例如：int* pa = &a；//我们这⾥的指针类型叫做int*，我读做（yin te 星号）。

//pa是指针变量这段表达式的意思是：定义了⼀个指针变量pa，⾥⾯存放的是a的地址。

⽽这个指针变量的类型为int*。

那下⾯就有同学疑惑了，那什么是指针变量？什么是指针变量？很简单，在之前我们学习了怎么定义整型变量a。

⽐如定义⼀个《整型》《变量a》，然后把a初始化为10。

int a = 10；不过现在变了，我们现在学习了指针。

可以定义⼀个《int*》《变量pa》，然后把pa初识化为&a。

注意：int* 是⼀个类型。

叫做指针类型pa就叫做指针变量int* pa = &a;指针类型⼜是什么？既然变量有不同的类型，⽐如整型，浮点型等。

那么指针也有也有不同的类型。

char *pc = NULL;int *pi = NULL;short *ps = NULL;long *pl = NULL;float *pf = NULL;double *pd = NULL;//NULL为空指针。

这⾥可以看到，指针的定义⽅式是：类型 + * 。

其实：char* 类型的指针是为了存放 char 类型变量的地址。

short* 类型的指针是为了存放 short 类型变量的地址。

int* 类型的指针是为了存放 int 类型变量的地址。

指针类型存在的意义那有这么多的指针的类型，指针类型的意义是什么？我们在这⾥先说两个重要结论：指针的类型决定了指针向前或者向后⾛⼀步（也就是地址+1）有多⼤（能⾛多少个字节）指针的类型决定了，对指针解引⽤的时候有多⼤的权限（能操作⼏个字节）。

什么是野指针？ 今天偶然看到了C++中有关野指针的概念，就到百度和博客园查了⼀下，还是挺有收获的。

野指针的定义：“野指针”不是NULL指针，是指向“垃圾”内存（不可⽤内存）的指针。

⼈们⼀般不会错⽤NULL指针，因为⽤if语句很容易判断。

但是“野指针”是很危险的，if⽆法判断⼀个指针是正常指针还是“野指针”。

有个良好的编程习惯是避免“野指针”的唯⼀⽅法。

野指针形成的成因:⼀、没有被初始化。

任何刚被创建时不会⾃动成为NULL指针，它的缺省值是随机的，它会乱指⼀⽓。

所以，在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。

⼆、指针p被free或者delete之后，没有置为NULL，让⼈误以为p是个合法的指针。

别看free和delete的名字（尤其是delete），它们只是把指针所指的内存给释放掉，但并没有把指针本⾝⼲掉。

通常会⽤语句if (p != NULL)进⾏防错处理。

很遗憾，此时if语句起不到防错作⽤，因为即便p不是NULL指针，它也不指向合法的内存块。

例： #include <stdio.h> #include <string.h> #include <malloc.h> int main(void) { int i; char *p = (char *) malloc(100); strcpy(p, "hello"); free(p); // p 所指的内存被释放，但是p所指的地址仍然不变，原来的内存变为“垃圾”内存（不可⽤内存 if(p != NULL) // 没有起到防错作⽤ strcpy(p, "world"); for(i=0;i<5;i++) //i=5后为乱码 printf("%c",*(p+i)); printf("\n"); } 另外⼀个要注意的问题：不要返回指向栈内存的指针或引⽤，因为栈内存在函数结束时会被释放。

C语言指针陷阱详解及规避方法指针是C语言中重要的概念之一，它为我们提供了一种强大的工具来操作内存。

然而，指针的使用往往容易导致一些陷阱和错误。

本文将详解C语言指针的一些常见陷阱，并提供一些规避这些陷阱的方法。

一、空指针引用空指针是指未被初始化的指针，它不指向任何有效的内存地址。

如果我们在使用空指针时没有进行有效的判断，就可能发生空指针引用错误。

这种错误通常会导致程序崩溃或者产生不可预测的结果。

要规避空指针引用错误，我们可以在使用指针之前进行有效的判断。

例如，使用条件语句if来检查指针是否为空，如果为空则不进行指针操作。

另外，我们还可以在声明指针时初始化为NULL，这样可以提供一种默认情况下的安全保护。

二、野指针问题野指针是指指向已经释放的内存或者未分配的内存的指针。

如果我们在使用野指针时进行读写操作，就会造成内存访问错误，进而导致程序运行不正常。

为了规避野指针问题，我们应该养成良好的内存管理习惯。

在使用指针前，要确保指针所指向的内存是有效的。

当我们释放内存后，要及时将指针置为NULL，避免产生野指针。

此外，尽量避免使用未初始化的指针，这也是生成野指针的常见原因之一。

三、指针偏移错误指针偏移是指在指针基础上进行加减运算，以便访问不同位置的内存。

如果我们在进行指针偏移时计算错误，就会导致访问错误的内存位置，这可能会破坏数据，产生不可预测的结果。

为了避免指针偏移错误，我们需要在进行指针偏移之前仔细计算偏移量。

确保偏移的位置在合法的内存范围内，避免越界访问。

此外，在进行指针偏移后，要再次检查指针是否合法，确保我们操作的内存是有效的。

四、指针类型错误指针类型错误是指将指针赋值给错误类型的指针，或者将不同类型的指针进行赋值。

这种错误可能会导致数据类型转换错误，破坏数据的完整性。

为了避免指针类型错误，我们要在对指针进行赋值和类型转换时，仔细检查指针的类型是否匹配。

确保我们对指针的操作是合法且符合预期的。

另外，尽量避免进行强制类型转换，这可能会引入难以察觉的错误。

野（wild）指针与悬空（dangling）指针1. 什么是野指针(wild pointer)?A pointer in c which has not been initialized is known as wild pointer.野指针(wild pointer)就是没有被初始化过的指针。

例如，o foo1.c1int main(int argc, char *argv[])2 {3int *p;4return (*p & 0x7f); /* XXX: p is a wild pointer */5 }如果⽤"gcc -Wall"编译, 会出现如下警告：1 $ gcc -Wall -g -m32 -o foo foo.c2 foo.c: In function ‘main’:3 foo.c:4:10: warning: ‘p’ is used uninitialized in this function [-Wuninitialized]4 return (*p & 0x7f); /* XXX: p is a wild pointer */5 ^2. 什么是悬空指针(dangling pointer)?If a pointer still references the original memory after it has been freed, it is called a dangling pointer.悬空指针是指针最初指向的内存已经被释放了的⼀种指针。

典型的悬空指针看起来是这样的，（图⽚来源是）如果两个指针(p1和p2)指向同⼀块内存区域, 那么free(p1)后，p1和p2都成为悬空指针。

如果进⼀步将p1设置为NULL, 那么p2还是悬空指针。

诚然，使⽤*p1会导致⾮法内存访问，但是使⽤*p2却会出现⽆法预料的结果，可谓防不胜防。

例如：o foo2.c1 #include <stdlib.h>2 int main(int argc, char *argv[])3 {4 int *p1 = (int *)malloc(sizeof (int));5 int *p2 = p1; /* p2 and p1 are pointing to the same memory */6 free(p1); /* p1 is a dangling pointer, so is p2 */7 p1 = NULL; /* p1 is not a dangling pointer any more */8 return (*p2 & 0x7f); /* p2 is still a dangling pointer */9 }3. 使⽤野指针和悬空指针的危害⽆论是野指针还是悬空指针，都是指向⽆效内存区域(这⾥的⽆效指的是"不安全不可控")的指针。

随着诸如代码重构和单元测试等方法引入实践，调试技能渐渐弱化了，甚至有人主张废除调试器。

这是有道理的，原因在于调试的代价往往太大了，特别是调试系统集成之后的BUG，一个BUG花了几天甚至数周时间并非罕见。

而这些难以定位的BUG基本上可以归为两类：内存错误和并发问题。

而又以内存错误最为普遍，即使是久经沙场的老手，也有时也难免落入陷阱。

前事不忘，后世之师，了解这些常见的错误，在编程时就加以注意，把出错的概率降到最低，可以节省不少时间。

这些列举一些常见的内存错误，供新手参考。

1. 内存泄露。

大家都知道，在堆上分配的内存，如果不再使用了，应该把它释放掉，以便后面其它地方可以重用。

在C/C++中，内存管理器不会帮你自动回收不再使用的内存。

如果你忘了释放不再使用的内存，这些内存就不能被重用，就造成了所谓的内存泄露。

把内存泄露列为首位，倒并不是因为它有多么严重的后果，而因为它是最为常见的一类错误。

一两处内存泄露通常不至于让程序崩溃，也不会出现逻辑上的错误，加上进程退出时，系统会自动释放该进程所有相关的内存，所以内存泄露的后果相对来说还是比较温和的。

当然了，量变会产生质变，一旦内存泄露过多以致于耗尽内存，后续内存分配将会失败，程序可能因此而崩溃。

现在的PC机内存够大了，加上进程有独立的内存空间，对于一些小程序来说，内存泄露已经不是太大的威胁。

但对于大型软件，特别是长时间运行的软件，或者嵌入式系统来说，内存泄露仍然是致命的因素之一。

不管在什么情况下，采取比较谨慎的态度，杜绝内存泄露的出现，都是可取的。

相反，认为内存有的是，对内存泄露放任自流都不是负责的。

尽管一些工具可以帮助我们检查内存泄露问题，我认为还是应该在编程时就仔细一点，及早排除这类错误，工具只是用作验证的手段。

2.内存越界访问。

内存越界访问有两种：一种是读越界，即读了不属于自己的数据，如果所读的内存地址是无效的，程度立刻就崩溃了。

如果所读内存地址是有效的，在读的时候不会出问题，但由于读到的数据是随机的，它会产生不可预料的后果。