[已解决]关于栈malloc开辟空间返回失败？

理想小青年

关于栈有很多种方式来实现，那么我在定义了两个结构体一个座位栈节点指向，另一个作为节点来入栈出栈，大体原理图
问题
s->bottom底指向新节点的时总是报错也在图中，好像返回malloc失败？因为PSTACK s定义的问题的问题？0Xcccccccc好像也有地址
代码如下：

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

typedef int elementype;

typedef struct Node                        //定义节点
{
        elementype data;
        struct Node *next;
}Node,*PNode;

typedef struct stack                //定义栈节点
{
        PNode top;                                //栈顶
        PNode bottom;                        //栈底
}STACK,*PSTACK;


void Create_stack(PSTACK s);
void Push_stack( PSTACK s, int val );
void Traverse_stack( PSTACK s );
void Pop_stack(PSTACK s);
void Clear_stack(PSTACK s);


int main(void)
{
        PSTACK s;
        Create_stack(s);        
        Push_stack(s, 5);
        Traverse_stack(s);
        Pop_stack(s);
        Clear_stack(s);
        return 0;
}

void Create_stack(PSTACK s)
{ 
        s->bottom = (PNode)malloc(sizeof(Node));
//        printf("Debug");
        if ( NULL == s->bottom )
        {
                printf("分配内存失败!\n");
                exit(-1);
        }
        s->top = s->bottom;
        s->top->data = 0;
        s->top->next = NULL;                //防止出现野指针
        printf("初始化栈成功！\n");
}

void Push_stack( PSTACK s, int val )
{
        PNode p = (PNode)malloc(sizeof(Node));
        if( NULL == p )
        {
                printf("Memory allocation failure");
                exit(EXIT_FAILURE);
        }
        
        p->data = val;
        p->next = s->top;
        s->top = p;
}


void Traverse_stack( PSTACK s )                //遍历stack
{
        PNode p = s->top;
        while( NULL != p )
        {
                p = p->next;
                printf("%d",p->data);
        }
        printf("\n");
}


void Pop_stack(PSTACK s)                        //出栈
{

        if( NULL != s )
        {
                PNode temp = s->top;
                s->top = s->top->next;
                printf("Pop data of %d ",temp);
                free(temp);
                temp = NULL;
                printf("Pop Success!\n");
        }
        else
        {
                printf("The is Stack of empyt!\n");
        }
}


void Clear_stack(PSTACK s)                        //清除栈
{
        PNode p = NULL;
        PNode temp = NULL;                                //初始化临时指针
        while( NULL != p )
        {
                p = s->top;
                s->top = s->top->next;
                free(p);
                p = NULL;
        }
        free(p);
        printf("释放Stack success!\n");
}

最佳答案

月排行榜 / 总排行榜

人造人

2018-6-20 20:59:13

理想小青年 发表于 2018-6-20 20:39
男神 是不是PSTACK s 在主函数中为初始化 所以s->bottom指针指向新的节点（结构体地址）时候返回malloc错 ...

一级指针可以修改普通变量的值
二级指针可以修改一级指针的指向
三级指针可以修改二级指针的指向

#if 0
#include <stdio.h>

void ChangePointer(char *p)
{
        p = NULL;
}

int main(void)
{
        char ch = 'A';
        char *p = &ch;

        printf("%c\n", *p);
        ChangePointer(p);
        if(p)
                printf("%c\n", *p);

        return 0;
}
#else
#include <stdio.h>

void ChangePointer(char **p)
{
        *p = NULL;
}

int main(void)
{
        char ch = 'A';
        char *p = &ch;

        printf("%c\n", *p);
        ChangePointer(&p);
        if(p)
                printf("%c\n", *p);

        return 0;
}
#endif

跳转到最佳答案楼层

理想小青年

贴上汇编代码 半懂非懂

人造人

关键是感觉

#include "stdio.h"
#include "malloc.h"
typedef struct sData{
        char n;
}sData;


typedef struct sStack{
        sData *  back;
        sData *  top;
        int size;
}sStack;

sStack  inital(int size){                                                                                                //初始化栈空间
        sStack  p_stack;
        p_stack.back = (sData *)malloc(sizeof(sData) * size);
        p_stack.top = p_stack.back;
        p_stack.size=size;
        return p_stack;
}

int is_overflow(sStack *stack){                                                                                                  //检查栈顶
        return (stack->top-stack->back)>stack->size-1 || (stack->top<stack->back);//LOOP 栈
}
void push(sStack *stack,int n){
        if(is_overflow(stack)){
                stack->top=stack->back;                                                                                        //溢出栈顶后置零
        }
        stack->top->n=n;
        stack->top++;                                                                                                                //栈顶+1
}

int is_overflow1(sStack *stack){                                                                                //检查栈底
        return stack->back>=stack->top;
}
sData * pop(sStack *stack){                                                                                                //栈顶-1                                                        
        if(is_overflow1(stack)){                                        
                stack->top=stack->back+stack->size;                                                                //LOOP 栈
        }
        return --stack->top;
}

int main(){
        sStack  p_stack,p_stack1;
        int i=0,count=0;
        char ch;
        p_stack  = inital(100);
        p_stack1 = inital(100);

        while((ch=getchar())!='\n'){
                switch(ch){
                case        '#':                                                                                                        //前一个字符无效
                        count-=1;
                        p_stack.top-=1;                                                                                                
                        break;
                case        '@':                                                                                                        //全部无效
                        count=0;
                        p_stack.top=p_stack.back;                                                                        //清空
                        break;
                default:
                        count++;
                        push(&p_stack,ch);
                        break;
                }
        }

        count=p_stack.top-p_stack.back;
        for(i=0;i<count;i++){
                char ch =(*pop(&p_stack)).n;
                //printf("%c",ch);
                push(&p_stack1,ch);
        }

        for(i=0;i<=count;i++){
                printf("%c",(*pop(&p_stack1)).n);
        }

        free(p_stack.back);
        free(p_stack1.back);
        return 0;
}

这个《C语言经典编程282例》208题，大概效果是这样
输入：12346#5
输出:12345  “#相当于退格一位”
输入：123465@abcd
输出:abcd “应该不难理解这个效果吧”
其实程序简单。就是 压栈 出栈 初始化栈区域 还有栈顶溢出检查 栈底溢出检查。

理想小青年

人造人 发表于 2018-6-20 16:26

男神 是不是PSTACK s 在主函数中为初始化 所以s->bottom指针指向新的节点（结构体地址）时候返回malloc错误

理想小青年

关键是感觉 发表于 2018-6-20 18:14
这个《C语言经典编程282例》208题，大概效果是这样
输入：12346#5
输出:12345  “#相当于退格一位”

需要好好理解一下 多谢！
突然感觉申请内存malloc这一段代码有技巧  相对多次循环申请malloc临时内存空间来说 一次申请效率更快
但是交互性差 一次输入多个values 一次性  

人造人

理想小青年 发表于 2018-6-20 20:39
男神 是不是PSTACK s 在主函数中为初始化 所以s->bottom指针指向新的节点（结构体地址）时候返回malloc错 ...

一级指针可以修改普通变量的值
二级指针可以修改一级指针的指向
三级指针可以修改二级指针的指向

#if 0
#include <stdio.h>

void ChangePointer(char *p)
{
        p = NULL;
}

int main(void)
{
        char ch = 'A';
        char *p = &ch;

        printf("%c\n", *p);
        ChangePointer(p);
        if(p)
                printf("%c\n", *p);

        return 0;
}
#else
#include <stdio.h>

void ChangePointer(char **p)
{
        *p = NULL;
}

int main(void)
{
        char ch = 'A';
        char *p = &ch;

        printf("%c\n", *p);
        ChangePointer(&p);
        if(p)
                printf("%c\n", *p);

        return 0;
}
#endif

人造人

关键是感觉

理想小青年 发表于 2018-6-20 20:40
需要好好理解一下 多谢！
突然感觉申请内存malloc这一段代码有技巧  相对多次循环申请mallo ...

我感觉没什么可理解的。简单的就是压栈 出栈 和初始化。功能可以慢慢加，比如获取栈区第几个元素等。
还有一点。其实压栈也可以一次性操作。比如 push（stack,带入数组） 或者 push(stack,...)采用可变参数到方式，类似printf函数