堆栈顺序存储和 free 失败原因分析

最新推荐文章于 2023-05-16 11:35:53 发布
最新推荐文章于 2023-05-16 11:35:53 发布
阅读量2k 收藏 1
点赞数 1
分类专栏： C/C++ 数据结构和算法 文章标签： free 堆栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xy010902100449/article/details/49252099
版权 
*** Error in `./a.out': free(): invalid pointer: 0x09e7c018 ***
======= Backtrace: =========
/lib/i386-linux-gnu/libc.so.6(+0x767c2)[0xb76307c2]
/lib/i386-linux-gnu/libc.so.6(+0x77510)[0xb7631510]
./a.out[0x804864c]
./a.out[0x8048830]
/lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xf5)[0xb75d3905]
./a.out[0x8048431]
======= Memory map: ========
08048000-08049000 r-xp 00000000 08:01 655787     /home/zuopeng/Desktop/c/a.out
08049000-0804a000 r--p 00000000 08:01 655787     /home/zuopeng/Desktop/c/a.out
0804a000-0804b000 rw-p 00001000 08:01 655787     /home/zuopeng/Desktop/c/a.out
09e7c000-09e9d000 rw-p 00000000 00:00 0          [heap]
b7589000-b75a4000 r-xp 00000000 08:01 918479     /lib/i386-linux-gnu/libgcc_s.so.1
b75a4000-b75a5000 r--p 0001a000 08:01 918479     /lib/i386-linux-gnu/libgcc_s.so.1
b75a5000-b75a6000 rw-p 0001b000 08:01 918479     /lib/i386-linux-gnu/libgcc_s.so.1
b75b9000-b75ba000 rw-p 00000000 00:00 0 
b75ba000-b7768000 r-xp 00000000 08:01 918454     /lib/i386-linux-gnu/libc-2.17.so
b7768000-b776a000 r--p 001ae000 08:01 918454     /lib/i386-linux-gnu/libc-2.17.so
b776a000-b776b000 rw-p 001b0000 08:01 918454     /lib/i386-linux-gnu/libc-2.17.so
b776b000-b776e000 rw-p 00000000 00:00 0 
b777f000-b7783000 rw-p 00000000 00:00 0 
b7783000-b7784000 r-xp 00000000 00:00 0          [vdso]
b7784000-b77a4000 r-xp 00000000 08:01 918430     /lib/i386-linux-gnu/ld-2.17.so
b77a4000-b77a5000 r--p 0001f000 08:01 918430     /lib/i386-linux-gnu/ld-2.17.so
b77a5000-b77a6000 rw-p 00020000 08:01 918430     /lib/i386-linux-gnu/ld-2.17.so
bf85a000-bf87b000 rw-p 00000000 00:00 0          [stack]
Aborted (core dumped)

<span style="font-family:Arial;color:#333333;"><span style="font-size: 14px; line-height: 26px;">错误代码如下：</span></span>
<span style="font-family:Arial;color:#333333;"><span style="font-size: 14px; line-height: 26px;"></span></span><pre name="code" class="cpp">//顺序存储
//Written by ZP1015
//2015.10.19

#include <stdlib.h>
#include <stdio.h>
#include <string.h>



struct STACK_NODE
{
    int* pData;/*数组，长度为StackLenMax*/
    int top;//栈顶指针的位置
    int StackLenMax;
};

struct STACK_NODE* alloc_stack(int StackSize)
{
    
    if(StackSize <= 0)
        return NULL;
	
	struct STACK_NODE* pStackNode = NULL;
	
    pStackNode = (struct STACK_NODE*)malloc(sizeof(struct STACK_NODE));
    if(NULL == pStackNode) {
		return NULL;
    }
	
    memset(pStackNode, 0, sizeof(struct STACK_NODE));

    pStackNode->pData = (int *)malloc(sizeof(int)*StackSize);
    if(NULL == pStackNode->pData){
		goto malloc_failed;
    }
	
	printf("%d\n",pStackNode->pData);
	
    memset(pStackNode->pData, 0, sizeof(int) * StackSize);
    pStackNode->top= -1; /*初始化从0开始*/
	pStackNode->StackLenMax = StackSize;
	
    return pStackNode;

malloc_failed:
	free(pStackNode);
	return NULL;
}

int free_stack(struct STACK_NODE* pStackNode)
{
    if(NULL == pStackNode)
        return -1;

    if(NULL == pStackNode->pData) {
		return -1;
	}
	printf("%d\n",pStackNode->pData);
	printf("[%d] %d\n",__LINE__,pStackNode->pData[2]);
    free(pStackNode->pData);
    free(pStackNode);
	
    return 0;
}

int stack_push(struct STACK_NODE* pStackNode, int value)
{
	/*1.异常处理*/
    if(NULL == pStackNode)
        return -1;
	if(NULL == pStackNode->pData) {
		return -1;
	}
	
	/*2.栈满，不能压入元素*/
    if(pStackNode->top == pStackNode->StackLenMax-1)
        return -1;
	printf("%d\n",pStackNode->top);
    pStackNode->pData[pStackNode->top++] = value;

    return 0;
}

int stack_pop(struct STACK_NODE* pStackNode, int* value)
{
    if(NULL == pStackNode || NULL == value)
        return -1;

    if(-1 == pStackNode->top)
        return -1;

    *value = pStackNode->pData[pStackNode->top--];
	
    return 0;
}

int count_stack_number(struct STACK_NODE* pStackNode)
{
    return (pStackNode->top+1);
}

void print_stack_node(struct STACK_NODE *pStackNode) 
{
	/*1.输入的参数有误*/
    if(NULL == pStackNode) {
		printf("[%d] pStackNode is illegal! \n",__LINE__);
		return;
    }
	/*2.输入的链式堆栈为空*/
	if(-1 == pStackNode->top) {
		printf("[%d] pStackNode is empty!\n",__LINE__);
		return ;
	}
	
	struct STACK_NODE *pStackNodeTemp = pStackNode;
	int count = 0;
	
	while(count <= pStackNode->top) {
		printf("%d ",pStackNodeTemp->pData[count]);
		count++;;
	}
	printf("\n");
}


int main()
{
	struct STACK_NODE *pStackNode;
	pStackNode = alloc_stack(20);
	int i = 0;
	for (i = 0;i<10;i++) {
		stack_push(pStackNode,i);
	}
	print_stack_node(pStackNode);


	free_stack(pStackNode);

	getchar();
	getchar();
	
	return 0;
}


 

 

 

你是否遇到过这样的情况，真是要疯了。程序总是无端coredump，gdb到core文件里面也看不出个所以然来，排查了一下午也没找到所以然。
 

不过回过头好好想想，内存问题始终是程序员需要去面对的问题，通常我们会犯的内存问题大概有以下几种：
 

  1. 内存重复释放，出现double free时，通常是由于这种情况所致。
  2. 内存泄露，分配的内存忘了释放。
  3. 内存越界使用，使用了不该使用的内存。
  4. 使用了无效指针。
  5. 空指针，对一个空指针进行操作。
 

 

我们针对上述几种情况逐一排查，最后发现了是属于第三种情况，造成free失败。在 alloc_stack 中我把栈顶指针从-1开始计算，栈顶元素数组从-1开始操作，因此造成了这个 coredump 问题。
 

//顺序存储
//Written by ZP1015
//2015.10.19

#include <stdlib.h>
#include <stdio.h>
#include <string.h>



struct STACK_NODE
{
    int* pData;/*数组，长度为StackLenMax*/
    int top;//栈顶指针的位置
    int StackLenMax;
};

struct STACK_NODE* alloc_stack(int StackSize)
{
    
    if(StackSize <= 0)
        return NULL;
	
	struct STACK_NODE* pStackNode = NULL;
	
    pStackNode = (struct STACK_NODE*)malloc(sizeof(struct STACK_NODE));
    if(NULL == pStackNode) {
		return NULL;
    }
	
    memset(pStackNode, 0, sizeof(struct STACK_NODE));

    pStackNode->pData = (int *)malloc(sizeof(int)*StackSize);
    if(NULL == pStackNode->pData){
		goto malloc_failed;
    }
	
	printf("%d\n",pStackNode->pData);
	
    memset(pStackNode->pData, 0, sizeof(int) * StackSize);
    pStackNode->top= -1; /*初始化从0开始*/
	pStackNode->StackLenMax = StackSize;
	
    return pStackNode;

malloc_failed:
	free(pStackNode);
	return NULL;
}

int free_stack(struct STACK_NODE* pStackNode)
{
    if(NULL == pStackNode)
        return -1;

    if(NULL == pStackNode->pData) {
		return -1;
	}
	printf("%d\n",pStackNode->pData);
	printf("[%d] %d\n",__LINE__,pStackNode->pData[2]);
    free(pStackNode->pData);
    free(pStackNode);
	
    return 0;
}

int stack_push(struct STACK_NODE* pStackNode, int value)
{
	/*1.异常处理*/
    if(NULL == pStackNode)
        return -1;
	if(NULL == pStackNode->pData) {
		return -1;
	}
	
	/*2.栈满，不能压入元素*/
    if(pStackNode->top == pStackNode->StackLenMax-1)
        return -1;
	printf("%d\n",pStackNode->top);
    pStackNode->pData[++pStackNode->top] = value;

    return 0;
}

int stack_pop(struct STACK_NODE* pStackNode, int* value)
{
    if(NULL == pStackNode || NULL == value)
        return -1;

    if(-1 == pStackNode->top)
        return -1;

    *value = pStackNode->pData[pStackNode->top--];
	
    return 0;
}

int count_stack_number(struct STACK_NODE* pStackNode)
{
    return (pStackNode->top+1);
}

void print_stack_node(struct STACK_NODE *pStackNode) 
{
	/*1.输入的参数有误*/
    if(NULL == pStackNode) {
		printf("[%d] pStackNode is illegal! \n",__LINE__);
		return;
    }
	/*2.输入的链式堆栈为空*/
	if(-1 == pStackNode->top) {
		printf("[%d] pStackNode is empty!\n",__LINE__);
		return ;
	}
	
	struct STACK_NODE *pStackNodeTemp = pStackNode;
	int count = 0;
	
	while(count <= pStackNode->top) {
		printf("%d ",pStackNodeTemp->pData[count]);
		count++;;
	}
	printf("\n");
}


int main()
{
	struct STACK_NODE *pStackNode;
	pStackNode = alloc_stack(20);
	int i = 0;
	for (i = 0;i<10;i++) {
		stack_push(pStackNode,i);
	}
	print_stack_node(pStackNode);


	free_stack(pStackNode);

	getchar();
	getchar();
	
	return 0;
}

 

 

 

 

 


                

        

        

        

    

  


            

                    
            

    

      

        

            

              
                
                  狂奔的乌龟
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
free失败多是内存越界造成的

				
			

			

				

					@奮 鬥@的专栏
				

				

					04-20
					
					3903
					
				

			

		

		

			
				
指针申请后被修改再free会失败

这个free错误则不好查找，因为实际的程序往往没下面的例子这么简单，可能从申请到最后释放跨域多个模块、大量的处理代码逻辑，指针初始值被修改掉，也就是说分配的这段内存的“门牌号”被改掉了，那么free就会失败。





当我们释放动态分配的内存时，通常会遭遇内存释放失败的错误，我遇到这么一个问题，当我无意间越界访问了动态分配内存时，在释放内存时，

			
		

	



                

              
                



	

		

			

				
					
free（）一直失败，程序异常终止

				
			

			

				

					weixin_45090728的博客
				

				

					12-29
					
					881
					
				

			

		

		

			
				
项目场景：

内存的申请和释放

问题描述：

程序异常终止，控制台返回值一直为下面的问题，经检验是一句free()语句得问题。
Process returned -1073741819 (0xC0000005)

 

原因分析：

malloc分配的空间的空间出现了问题，一些标志信息被修改，可能是分配空间打下不够。
经检查，错误在于把sizeof(size)当成了大小，而不是size
   
 
解决方案：

删除多余的sizeof()即可


收获
内存的释放和申请一定是成对的，有一个申请就要对应一个

			
		

	



                


  
              

                


	

		

			

				
					
malloc free失败

				
			

			

				

					windren06的专栏
				

				

					09-04
					
					3056
					
				

			

		

		

			
				
今天遇到C语言的malloc free失败问题，因为工程代码量巨大，定位了半天才发现是DLL的问题，动态链接库里malloc分配的内存，到主程序中free时崩溃失败。起初以为是指针越界好或被修改，后来直接改成申请后就free，直接失败，于是就怀疑是DLL与主程序之间的调用问题。于是总结一下常见失败问题方便后来者参考。
一、指针未初始化就free失败
该free错误非常容易定位，也就是一个指针没

			
		

	





	

		

			

				
					
free()函数释放空间失败的原因

				
			

			

				

					NDHuaErFeiFei的博客
				

				

					07-08
					
					1587
					
				

			

		

		

			
				
转载于：https://blog.csdn.net/qq_40977765/article/details/89191053


    
#include<stdio.h>
#include<malloc.h>
#include<string.h>
#pragma warning (disable:4996)
int main()
{
	char *temp;...

			
		

	



		

			
		



	

		

			

				
					
堆栈异常

				
			

			

				

					chao430的博客
				

				

					05-11
					
					3474
					
				

			

		

		

			
				
Java栈 Java Stack：

　　Java栈总是与线程关联在一起的，每当创建一个线程，JVM就会为该线程创建对应的Java栈，在这个Java栈中又会包含多个栈帧(Stack Frame)，这些栈帧是与每个方法关联起来的，每运行一个方法就创建一个栈帧，每个栈帧会含有一些局部变量、操作栈和方法返回值等信息。每当一个方法执行完成时，该栈帧就会弹出栈帧的元素作为这个方法的返回值，并且清除这个栈帧，...

			
		

	





	

		

			

				
					
堆栈部分学习总结（栈的顺序存储实现、链式存储实现）

				
			

			

				

					cydklxh的博客
				

				

					08-11
					
					843
					
				

			

		

		

			
				
堆栈
有时为了方便解决问题需要有种存储方法，能顺序存储运算数，并在需要时“倒序”输出!由此引入堆栈。
堆栈(Stack) :具有一定操作约束的线性表，其特点如下：
➢只在一端(栈顶，Top)做插入、删除
➢插入数据:入栈(Push)
➢删除数据:出栈(Pop)
➢后入先出: Last In First Out (LIFO)
栈的顺序存储实现
主要框架：
类型名称:堆栈(Stack)
数据对象集:一个有0个或多个元素的有穷线性表。
操作集:长度为MaxSize的堆栈S∈Stack,堆栈元素item∈Eleme

			
		

	





	

		

			

				
					
【数据结构笔记05】堆栈及其顺序存储、链式存储

				
			

			

				

					记录学习痕迹的公众号：Piper蛋窝
				

				

					09-15
					
					842
					
				

			

		

		

			
				
堆栈及其顺序存储、链式存储。

			
		

	





	

		

			

				
					
堆栈的线性存储(顺序栈)和链式存储(链栈)

				
			

			

				

					CoderL
				

				

					06-17
					
					1073
					
				

			

		

		

			
				
堆栈(Stack)是有约束的线性表，插入和删除都只能在表的同一端。

对于用数组来实现的话，我们一般把数组起始位置作为栈底，把下标越来越大的部分作为栈顶。这样就需要一个标记来表示当前栈顶的位置。

顺序栈:


typedef int elementType;
typedef int position;
struct StackNode{
    elementType * Data;//表示堆栈...

			
		

	





	

		

			

				
					
栈的顺序存储

				
			

			

				

					qq_45432387的博客
				

				

					06-05
					
					825
					
				

			

		

		

			
				
栈顺序存储的基本操作：
1）初始化栈
2）入栈
3）出栈
4）返回栈的大小
5）返回栈顶元素
6）判断栈是否为空
7）销毁

			
		

	





	

		

			

				
					
【栈与队列】之栈的顺序存储（图文详细介绍！！）

				
			

			

				

					qq_62822533的博客
				

				

					12-21
					
					5857
					
				

			

		

		

			
				
栈的顺序存储结构，以及栈顺序存储结构的一些实现，如：入栈，出栈，销毁栈，清空栈，求栈的长度等等。

			
		

	





	

		

			

				
					
linux应用编程笔记（2）core dump分析内核链表使用后free出现的错误

				
			

			

				

					Deep_l_zh的博客
				

				

					09-23
					
					1660
					
				

			

		

		

			
				
摘要：介绍了core dump的功能，使用方法和步骤，最后用其分析了访问空指针，只读内存以及内核链表使用中出现的错误。


一、core dump是什么
    coredump又叫做核心转存，当程序在运行中出现错误的时候，发生异常，linux系统可以把出错时候的内容存储在一个core文件中，这个过程就叫做core dump。我们在有了这个文件之后，再联合gdb，可以找出错误，节省了人力和

			
		

	





	

		

			

				
					
堆栈的顺序存储---顺序栈

				
			

			

				

					qq_22583409的博客
				

				

					10-01
					
					5014
					
				

			

		

		

			
				
堆栈的顺序存储—顺序栈堆栈的顺序存储结构简称顺序栈，它是利用一组地址连续的存储单元依次存放自栈底到栈顶之间的元素。

			
		

	





	

		

			

				
					
free()崩溃原因总结

				
			

			

				

					juicy_w的博客
				

				

					04-22
					
					1万+
					
				

			

		

		

			
				
       在使用动态内存分配malloc()后，若不及时释放内存free()，会造成内存泄漏；我总结了在释放时经常出现错误的原因，频率由高到低排序。（一） 越界、漏写sizeof()、realloc()第二个参数写错int main()
{
	int *arr=(int *)malloc(10*sizeof(int));   //分配10个单位的连续块，每个单位4个字节
	//for(int ...

			
		

	





	

		

			

				
					
free报错问题的原因总结

					
热门推荐

				
			

			

				

					u010319440的专栏
				

				

					08-27
					
					1万+
					
				

			

		

		

			
				
前一段时候在做项目的时候碰到了运行时程序崩溃的问题，定位到了是free(p);这个语句出错误，找了半天资料解决了，现在写下一点自己的总结。
 这个问题有可能是以下4个原因构成，一一排查一般都可以解决：
1 释放一个空指针，这个就不用多说了，短点调试不会也会打印吧 printf("%x",p);可以打印出16进制数
    2 重复释放，这个问题也很好解决，在所有的释放语句后都赋值指

			
		

	





	

		

			

				
					
free崩溃原因2021

				
			

			

				

					jacke121的专栏
				

				

					06-10
					
					2456
					
				

			

		

		

			
				
int main()//free崩溃情景1
{
	int *p = (int *)malloc(10*sizeof(int));
	for(int i=0;i<=10;i++)
	{
		p[i] = 0;
	}
	free(p);
	return 0;
}




			
		

	





	

		

			

				
					
Linux：GDB 调试一些函数栈被毁坏的问题

				
			

			

				

					hhd1988的专栏
				

				

					01-17
					
					2106
					
				

			

		

		

			
				
Linux：GDB 调试一些函数栈被毁坏的问题

			
		

	





	

		

			

				
					
c中free函数报错，显示堆损坏

					
最新发布

				
			

			

				

					weixin_55098333的博客
				

				

					05-16
					
					709
					
				

			

		

		

			
				
解决使用free函数释放malloc，realloc开辟的的空间报错问题

			
		

	





	

		

			

				
					
c语言free null的时候会出错,【求助】c语言free 产生的错误

				
			

			

				

					weixin_39957068的博客
				

				

					05-20
					
					447
					
				

			

		

		

			
				
【求助】c语言free 产生的错误写了一段程序，实在找不出错误，在windows编译(gcc)有时可以运行，有时提示程序停止。索性在linux下编译(gcc)没有问题，可以运行，但结果有错误提示，看不懂是什么原因，求大侠解释。已经知道是在哪个函数里出的问题，程序太大，就把这个函数贴出来void rml(double ** A, double *y, double **z, double *x,...

			
		

	





	

		

			

				
					
linux 操作系统 栈失效 解决方法

				
			

			

				

					ARC_FEY的博客
				

				

					03-24
					
					1071
					
				

			

		

		

			
				
在做操作系统作业，或者是实验的时候。如果出现栈失效，不要慌
我们来看产生这个报错的原因：
一个程序在操作系统中并不是顺序执行的，而是被分成了多个进程，进程之间并发执行。
通常是以大括号作为进程划分的单位。

如果你的程序中创建了子进程，那么你就要小心了。
程序执行完子进程之后，跳回到父进程继续执行。
如果你的程序逻辑有问题，导致不能正常跳转，就会 出现这种报错。
所以，检查一下你程序的逻辑，尤其是if else语句。

比如

...

			
		

	





	

		

			

				
					
编程实现堆栈与队列的基本操作

				
			

			

				

					
				

			

		

		

			
				
本文将介绍如何实现栈和队列的基本操作，包括它们的顺序存储和链表存储，并讨论这两种数据结构的特性和应用。在实验环境中，我们将实现数据的进栈、出栈、进队和出队操作，并探讨它们在实际问题中的应用。  ### 堆栈...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
狂奔的乌龟

			
你的鼓励将是我创作的最大动力

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

			
您的余额不足，请更换扫码支付或充值

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值