使栈头不是全局的，并增加多个栈的可能性（使用链表在C中实现栈）

我的任务是创建一个使用链表在C中实现堆栈模型的库。我所做的是为stack创建一个用户界面，允许它与控制台输入一起使用，但我的老师说我实际上必须创建它，这样它只能作为一个库工作。 但我遇到的问题是，我的堆栈头是一个全局变量，因此我的所有空隙都是空的。我想不出怎样才能使它只在主要方面起作用。此外，如果需要的话，该程序应该与多个堆栈一起工作，显然，与一个全局负责人一起工作是不可能的。这是我的程序和其他文件：

H.H

#ifndef H_H_INCLUDED
#define H_H_INCLUDED
typedef struct Node
{
    int data;
    struct Node* next;
} Node;
Node* head;
int counter = 0;



#endif // H_H_INCLUDED

函数c

#include <stdio.h>
#include <stdlib.h>
#include "H.h"
void create ()
{
    head = NULL;
}
void push ()
{
    int x;
    scanf("%d", &x);
    Node* temp = (Node*)malloc(sizeof(Node));
    (*temp).data = x; // temp ->data = x;
    (*temp).next = NULL;
    if(head != NULL) (*temp).next = head;
    head = temp;
}
void pop ()
{
    Node* htemp = (Node*)malloc(sizeof(Node));
    htemp = head;
    if (htemp == NULL)
    {
        printf("STACK EMPTY \n");
        return;
    }
    else
    {
        htemp = (*htemp).next;
        printf("ELEMNT TAKEN OUT: %d \n", (*head).data);
        free(head);
        head = htemp;
    }
}
void print ()
{
    Node* temp = head;
    printf("Stack: ");
    while (temp != NULL)
    {
        printf(" %d", (*temp).data);
        temp = (*temp).next;
    }
    printf("\n");
}
void emptycheck ()
{
    if (head == NULL) printf("Stack is empty \n");
        else printf ("Stackas is not empty \n");
}
void topelement()
{
    if (head != NULL)
    printf("top elemnt %d \n", (*head).data);
    else printf ("Stack empty");
}
void destroy()
{
   Node* htemp = (Node*)malloc(sizeof(Node));
   htemp = head;
   while (htemp != NULL)
   {
       htemp = (*head).next;
       free(head);
       head = htemp;
   }
   free(htemp);
   head = NULL;
}

#include <stdio.h>
#include <stdlib.h>
#include "funct.c"
void stackas(){
    int choice,z;
    printf("1 - create new stack \n");
    printf("2 - push new element to stack \n");
    printf("4 - pop element from stacl \n");
    printf("5 - check if stack is empty \n");
    printf("6 - check top element of stack \n");
    printf("8 - show stack elements on screen \n");
    printf("9 - destroy stack \n");
    printf("10 - end program \n");
    while (z != 1){
    scanf("%d", &choice);
    switch(choice)
    {
        case 1 :
            create();
            break;
        case 2 :
            push();
            break;
        case 4 :
            pop();
            break;
        case 5 :
            emptycheck();
            break;
        case 6 :
            topelement();
            break;
        case 8 :
            print();
            break;
        case 9 :
            destroy();
            break;
        case 10 :
            z = 1;
            break;
    }
    }
}

#include <stdio.h>
#include <stdlib.h>
#include "allinone.c"
int main()
{
    stackas();
}

#包括
#包括
#包括“H.H”
创建空（）
{
head=NULL；
}
无效推送（）
{
int x；
scanf（“%d”和&x）；
Node*temp=（Node*）malloc（sizeof（Node））；
（*temp.data=x；//temp->data=x；
（*temp）.next=NULL；
如果（磁头！=NULL）（*temp）.next=磁头；
压头=温度；
}
void pop（）
{
Node*htemp=（Node*）malloc（sizeof（Node））；
htemp=头部；
如果（htemp==NULL）
{
printf（“堆栈空\n”）；
返回；
}
其他的
{
htemp=（*htemp）.next；
printf（“提取的元素：%d\n”，（*head.data）；
自由（头）；
水头=htemp；
}
}
作废打印（）
{
节点*温度=头部；
printf（“堆栈：”）；
while（temp！=NULL）
{
printf（“%d”），（*temp.data）；
温度=（*温度）。下一步；
}
printf（“\n”）；
}
void emptycheck（）
{
如果（head==NULL）printf（“堆栈为空\n”）；
else printf（“Stackas不是空的\n”）；
}
void topelement（）
{
if（head！=NULL）
printf（“顶部元素%d\n”，（*head）.data）；
else printf（“堆栈为空”）；
}
无效销毁（）
{
Node*htemp=（Node*）malloc（sizeof（Node））；
htemp=头部；
while（htemp！=NULL）
{
htemp=（*head）.next；
自由（头）；
水头=htemp；
}
免费（htemp）；
head=NULL；
}

现在，有所有开关的部分（不一定存在，我只是不想弄乱一个工作程序，所以你可以看到一个完整的视图）

allinone.c

#include <stdio.h>
#include <stdlib.h>
#include "H.h"
void create ()
{
    head = NULL;
}
void push ()
{
    int x;
    scanf("%d", &x);
    Node* temp = (Node*)malloc(sizeof(Node));
    (*temp).data = x; // temp ->data = x;
    (*temp).next = NULL;
    if(head != NULL) (*temp).next = head;
    head = temp;
}
void pop ()
{
    Node* htemp = (Node*)malloc(sizeof(Node));
    htemp = head;
    if (htemp == NULL)
    {
        printf("STACK EMPTY \n");
        return;
    }
    else
    {
        htemp = (*htemp).next;
        printf("ELEMNT TAKEN OUT: %d \n", (*head).data);
        free(head);
        head = htemp;
    }
}
void print ()
{
    Node* temp = head;
    printf("Stack: ");
    while (temp != NULL)
    {
        printf(" %d", (*temp).data);
        temp = (*temp).next;
    }
    printf("\n");
}
void emptycheck ()
{
    if (head == NULL) printf("Stack is empty \n");
        else printf ("Stackas is not empty \n");
}
void topelement()
{
    if (head != NULL)
    printf("top elemnt %d \n", (*head).data);
    else printf ("Stack empty");
}
void destroy()
{
   Node* htemp = (Node*)malloc(sizeof(Node));
   htemp = head;
   while (htemp != NULL)
   {
       htemp = (*head).next;
       free(head);
       head = htemp;
   }
   free(htemp);
   head = NULL;
}

#include <stdio.h>
#include <stdlib.h>
#include "funct.c"
void stackas(){
    int choice,z;
    printf("1 - create new stack \n");
    printf("2 - push new element to stack \n");
    printf("4 - pop element from stacl \n");
    printf("5 - check if stack is empty \n");
    printf("6 - check top element of stack \n");
    printf("8 - show stack elements on screen \n");
    printf("9 - destroy stack \n");
    printf("10 - end program \n");
    while (z != 1){
    scanf("%d", &choice);
    switch(choice)
    {
        case 1 :
            create();
            break;
        case 2 :
            push();
            break;
        case 4 :
            pop();
            break;
        case 5 :
            emptycheck();
            break;
        case 6 :
            topelement();
            break;
        case 8 :
            print();
            break;
        case 9 :
            destroy();
            break;
        case 10 :
            z = 1;
            break;
    }
    }
}

#include <stdio.h>
#include <stdlib.h>
#include "allinone.c"
int main()
{
    stackas();
}

#包括
#包括
#包括“funct.c”
void stackas（）{
整数选择，z；
printf（“1-创建新堆栈\n”）；
printf（“2-将新元素推送到堆栈\n”）；
printf（“stacl中的4-pop元素”）；
printf（“5-检查堆栈是否为空\n”）；
printf（“6-检查堆栈的顶部元素\n”）；
printf（“8-在屏幕上显示堆栈元素\n”）；
printf（“9-销毁堆栈\n”）；
printf（“10-结束程序”\n）；
而（z！=1）{
scanf（“%d”，选择（&C）；
开关（选择）
{
案例1：
创建（）；
打破
案例2：
推（）；
打破
案例4：
pop（）；
打破
案例5：
清空检查（）；
打破
案例6：
topelement（）；
打破
案例8：
打印（）；
打破
案例9：
破坏（）；
打破
案例10：
z=1；
打破
}
}
}

最后是我的main，它启动程序（在最终版本中没有“allinone”，main将自己启动库）

main.c

#include <stdio.h>
#include <stdlib.h>
#include "H.h"
void create ()
{
    head = NULL;
}
void push ()
{
    int x;
    scanf("%d", &x);
    Node* temp = (Node*)malloc(sizeof(Node));
    (*temp).data = x; // temp ->data = x;
    (*temp).next = NULL;
    if(head != NULL) (*temp).next = head;
    head = temp;
}
void pop ()
{
    Node* htemp = (Node*)malloc(sizeof(Node));
    htemp = head;
    if (htemp == NULL)
    {
        printf("STACK EMPTY \n");
        return;
    }
    else
    {
        htemp = (*htemp).next;
        printf("ELEMNT TAKEN OUT: %d \n", (*head).data);
        free(head);
        head = htemp;
    }
}
void print ()
{
    Node* temp = head;
    printf("Stack: ");
    while (temp != NULL)
    {
        printf(" %d", (*temp).data);
        temp = (*temp).next;
    }
    printf("\n");
}
void emptycheck ()
{
    if (head == NULL) printf("Stack is empty \n");
        else printf ("Stackas is not empty \n");
}
void topelement()
{
    if (head != NULL)
    printf("top elemnt %d \n", (*head).data);
    else printf ("Stack empty");
}
void destroy()
{
   Node* htemp = (Node*)malloc(sizeof(Node));
   htemp = head;
   while (htemp != NULL)
   {
       htemp = (*head).next;
       free(head);
       head = htemp;
   }
   free(htemp);
   head = NULL;
}

#include <stdio.h>
#include <stdlib.h>
#include "funct.c"
void stackas(){
    int choice,z;
    printf("1 - create new stack \n");
    printf("2 - push new element to stack \n");
    printf("4 - pop element from stacl \n");
    printf("5 - check if stack is empty \n");
    printf("6 - check top element of stack \n");
    printf("8 - show stack elements on screen \n");
    printf("9 - destroy stack \n");
    printf("10 - end program \n");
    while (z != 1){
    scanf("%d", &choice);
    switch(choice)
    {
        case 1 :
            create();
            break;
        case 2 :
            push();
            break;
        case 4 :
            pop();
            break;
        case 5 :
            emptycheck();
            break;
        case 6 :
            topelement();
            break;
        case 8 :
            print();
            break;
        case 9 :
            destroy();
            break;
        case 10 :
            z = 1;
            break;
    }
    }
}

#include <stdio.h>
#include <stdlib.h>
#include "allinone.c"
int main()
{
    stackas();
}

#包括
#包括
#包括“allinone.c”
int main（）
{
stackas（）；
}

因此，正如您可能看到的，这是一种用户界面方法，我只需要重新制作它，使其作为一个库工作，它可以理解create、push、pop、topelement、destroy命令，并根据操作是否成功返回+0/1的值。我遇到了麻烦，因为我不知道如何将global head重新制作为not global要发送给函数的具体内容

先谢谢你

---

---

---

解决了它！感谢您的建议。

首先声明一个

堆栈

类型：

typedef struct {
    Node *head;
    int counter;
} Stack;

编写构造函数：

Stack *Stack_create(void)
{
    Stack *stack = malloc(sizeof(Stack));
    if (stack) {
        stack->head = NULL;
        stack->counter = 0;
    }
    return stack;
}

然后定义函数，将

堆栈

作为参数并对其进行操作，例如：

void Stack_push (Stack*stack)
{
    /* Work with stack->head, stack->counter etc, here */
}

您还需要编写

Stack\u delete（）

来删除列表

---

我还没有检查代码的逻辑，所以您需要检查。您需要添加更多的错误检查，并且不应该强制转换

malloc（）

1）使用原型函数声明符：

void pop（）

->

void pop（void）

，等等。2）您应该已经学会如何继续。这不是编码/教程网站。如果你有这样一个基本的问题，你应该和你的老师谈谈。3） 提示：函数可以接受参数。4） 模块的标题应与模块同名（扩展名除外）。5） 使用箭头操作符6）不要在C中强制转换

malloc

&friends的结果。您的代码中有很多错误。太多了，无法列出。