C 分段错误-使用链表实现堆栈

我目前在一所大学学习C语言的数据结构，现在遇到了很多麻烦。我想说明的是，我请求帮助的不是分数，而是练习挑战题

目标是使用链表实现堆栈。通过阅读课堂讲稿，我想我已经记下了大部分函数。我需要演示Push（）和Pop（）将是一个追加和一个假装。使用Cygwin，我编译时没有错误。但是当我试着运行它时，我得到了一个“分段错误”。这意味着什么？我如何修复它？如果删除“stack=initLListStack（）；”，错误就会消失。这是我的密码：

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

typedef struct Link{
int *value;
struct Link *next;
}Link;

typedef struct LList1{
int *size;
Link *head;
}LList1;

typedef struct LListStack{
LList1 *llist;
}LListStack ;


LListStack *initLListStack(void)
{
LListStack *stack = (LListStack *) malloc(sizeof(LListStack)) ;
stack->llist->size = 0;
stack->llist->head = NULL;
return(stack);
}


void removefront(LList1 *llist)
{
if(llist->head != NULL){
    llist->head = llist->head->next;
    llist->size--;
}
}

Link *FindLastLink(LList1 *llist, Link *link)
{
if(link = NULL){
    return(NULL);
}
else if(link->next == NULL){
    return(link);
}
else{
    return(FindLastLink(llist, link->next));
}
}

Link *FindSecondLastLink(LList1 *llist, Link *link)
{
if(link = NULL){
    return(NULL);
}
else if(link->next->next == NULL){
    return(link);
}
else{
    return(FindSecondLastLink(llist, link->next));
}
}

void removelast(LList1 *llist)
{
Link *secondlastlink = (Link *) malloc(sizeof(Link));
secondlastlink = FindSecondLastLink(llist, llist->head);
secondlastlink->next = NULL;
llist->size--;

}



void prepend(int *newValue, LList1 *templist)
{
Link *node = (Link *) malloc(sizeof(Link)); 
node->value = newValue; 
node->next = templist->head;
templist->head = node;
templist->size++;
}

void append(int *newValue, LList1 *templist)
{
Link *node = (Link *) malloc(sizeof(Link));
Link *lastlink = (Link *) malloc(sizeof(Link));
lastlink = FindLastLink(templist, templist->head);
node->value = newValue;
lastlink->next = node;
node->next = NULL;
templist->size++;
}

void prepush(int *value, LListStack *stack)
{
 prepend(value, stack->llist);
}

void apppush(int *value, LListStack *stack)
{
append(value, stack->llist);
}

int prepop(LListStack *stack, int *value)
{ 
int result ;

if ((!isEmpty(stack)))
{
    removefront(stack->llist);
    result = 1 ;

}
else {
    result = 0 ;
}
return(result) ;
}

int isEmpty(LListStack *stack) 
{ 
int empty;

if (stack->llist->head == NULL) 
    return( 1 ) ;
else
    return( 0 ) ;
}

int apppop(LListStack *stack, int *value)
{ 
int result ;

if ((!isEmpty(stack)))
{
    removelast(stack->llist);
    result = 1 ;
}
else 
    result = 0 ;

return(result) ;
}

//*******MAIN**********//

int main()
{
LListStack *stack = (LListStack *) malloc (sizeof(LListStack));

stack = initLListStack(); //if I take this away, I can run the program


return(0);
}

#包括
#包括
类型定义结构链接{
int*值；
结构链接*下一步；
}链接；
类型定义结构1{
整数*大小；
链接*头；
}LIST1；
typedef结构LListStack{
LIST1*LIST；
}利斯塔克；
LListStack*初始LListStack（无效）
{
LListStack*堆栈=（LListStack*）malloc（sizeof（LListStack））；
堆栈->列表->大小=0；
stack->llist->head=NULL；
返回（堆栈）；
}
void removefront（LList1*llist）
{
如果（LIST->head！=NULL）{
LIST->head=LIST->head->next；
llist->size--；
}
}
Link*FindLastLink（LList1*llist，Link*Link）
{
if（link=NULL）{
返回（空）；
}
else if（链接->下一步==NULL）{
返回（链接）；
}
否则{
返回（FindLastLink（llist，link->next））；
}
}
Link*FindSecondLastLink（LList1*llist，Link*Link）
{
if（link=NULL）{
返回（空）；
}
else if（链接->下一步->下一步==NULL）{
返回（链接）；
}
否则{
返回（FindSecondLastLink（llist，link->next））；
}
}
void removelast（LList1*llist）
{
Link*secondlastlink=（Link*）malloc（sizeof（Link））；
secondlastlink=FindSecondLastLink（llist，llist->head）；
secondlastlink->next=NULL；
llist->size--；
}
void prepend（int*newValue，LList1*templast）
{
Link*node=（Link*）malloc（sizeof（Link））；
节点->值=新值；
节点->下一步=模板->头部；
圣殿骑士->头=节点；
圣堂武士->大小++；
}
void append（int*newValue，LList1*templast）
{
Link*node=（Link*）malloc（sizeof（Link））；
Link*lastlink=（Link*）malloc（sizeof（Link））；
lastlink=FindLastLink（templist，templist->head）；
节点->值=新值；
lastlink->next=节点；
节点->下一步=空；
圣堂武士->大小++；
}
void prepush（int*值，LListStack*堆栈）
{
前置（值，堆栈->列表）；
}
void apppush（int*值，LListStack*堆栈）
{
追加（值，堆栈->列表）；
}
int PREPP（LListStack*堆栈，int*值）
{ 
int结果；
如果（（！isEmpty（stack）））
{
removefront（堆栈->llist）；
结果=1；
}
否则{
结果=0；
}
返回（结果）；
}
int isEmpty（liststack*堆栈）
{ 
int空；
如果（堆栈->列表->头部==NULL）
申报表（1）；
其他的
返回（0）；
}
int-apppop（LListStack*堆栈，int*值）
{ 
int结果；
如果（（！isEmpty（stack）））
{
removelast（堆栈->llist）；
结果=1；
}
其他的
结果=0；
返回（结果）；
}
//*******主要**********//
int main（）
{
LListStack*堆栈=（LListStack*）malloc（sizeof（LListStack））；
stack=initLListStack（）；//如果我去掉这个，我就可以运行程序了
返回（0）；
}

Main（）中没有那么多内容，因为我只是想让它先运行。初始化堆栈似乎是个问题

谢谢你们的帮助，伙计们

LListStack *initLListStack(void)
{
  LListStack *stack = (LListStack *) malloc(sizeof(LListStack)) ;
  stack->llist->size = 0; // **this is probably where it crashes**
  stack->llist->head = NULL;
  return(stack);
}

您可以分配

stack

ok，但不分配

stack->llist

。因此，

stack->llist

未初始化，然后在

stack->llist->size

中取消对它的引用。解引用 未初始化的变量会导致未定义的行为

要解决此问题，请按如下方式分配堆栈->列表：

LListStack *initLListStack(void)
{
  LListStack *stack = (LListStack *) malloc(sizeof(LListStack)) ;
  stack->llist = (LListStack *) malloc(sizeof(LList1)) ; // ADD THIS LINE
  stack->llist->size = 0; 
  stack->llist->head = NULL;
  return(stack);
}

---

分段错误通常是由于尝试取消对未初始化指针的引用而导致的。在您的例子中，您已经在

initLListStack

方法中为

stack

分配了内存，但尚未对其进行初始化——特别是

llist

字段未初始化为任何特定值。您需要分配一个

LList1

，并将

llist

字段设置为新分配的内存。

问题在于

initLListStack（）函数中：

LListStack *stack = (LListStack *) malloc(sizeof(LListStack)) ;
stack->llist->size = 0;
stack->llist->head = NULL;
return(stack);

malloc
的结果是一个未初始化的内存块，其大小足以容纳
LListStack
结构

使用该内存所做的第一件事就是读取它的
llist
成员。因为这是未初始化的，所以调用未定义的行为，幸运的是，这会导致segfault。（发生这种情况时，编译器将在规范范围内向我们的讲师发送令人尴尬的电子邮件。）

您需要初始化
llist
，然后才能在堆栈中使用该成员。比如：

LListStack *stack = malloc(sizeof(*stack));
stack->llist = malloc(sizeof(*stack->llist));
stack->llist->size = 0;
stack->llist->head = NULL;
return stack;

请注意，我还删除了一些不必要的强制转换和括号，并更改了sizeof运算符，以便根据存储到其中的指针计算所需的内存。
非常感谢！成功了。只是一个问题1）我看到你在malloc之前去掉了“（LListStack*）。这有什么意义。我的教授一直告诉我们在Maloc之前把它包括进去，但是我不知道它是怎么做的，因为我读过的地方都不做。你显然是C++的教授，或者没有考虑到如果你的程序没有正确设置的话，不需要的演员可以做的所有事情。标准C不要求从
void*
转换为任何其他指针类型。