/*
二次封装 借用已经实现双向链表结构来实现
栈 出栈入栈操作类似于 从头节点开始的插入和删除
*/

llist.h

#ifndef LLIST_H__
#define LLSIT_H__
#define LLIST_FORWARD	1
#definr LLIST_BACKWARD	2
typedef void llist_op(const void *);//回调函数
typedef int llist_cmp(const void *,const void *);struct llist_node_st
{struct llist_node_st *prev;struct llist_node_st *next;	char data[0];
};
typedef struct
{int size;struct llist_node_st head;
}LLSIT;LLIST *llist_create(int initsize);
int llist_insert(LLIST *,const void *data,int mode);void *llist_find(LLIST *, const void *key, llist_cmp *);//数据类型不统一使用void 百搭
int llist_delete(LLIST *,const void *key,llist_cmp *);
int llist_fetch(LLIST *,const void *key,llist_cmp *,void *data);void llist_travel(LLIST *,llist_op *);
void llist_destroy(LLIST *);#endif

llist.c

#include<stdio.h>
#include<stdlib.h>
#include"llist.h"
#include<string.h>LLIST *llist_create(int initsize)//只包含一个头节点（ 双向循环链表）
{LLIST *new;new = malloc(sizeof(*new));if(new == NULL)return NULL;new->size= initsize;new->head.prev = new->head;new->head.next = new->head;return new;
}
int llist_insert(LLIST *ptr,const void *data,int mode)
{struct llist_node_st *newnode;newnode = malloc(sizeof(*newnode)+ptr->size);if(newnode == NULL)return -1;//newdata->data = malloc(ptr->size);memcpy(newnode->data,data,ptr->size);if(mode == LLIST_FORWARD){newnode->prev = &ptr->head;newnode->next = ptr->head.next;newnode->prev->next = newnode;//头节点的 next 指针设置为指向新节点 newnodenewnode->next->prev = newnode;//原本在头节点之后的节点的 prev 指针设置为指向新节点 newnode。}else if(mode == LLIST_BACKWARD){newnode->prev = ptr->head.prev;newnode->next = &ptr->head;newnode->prev->next = newnode;newnode->next->prev = newnode;}else{return -3;}return 0;
}
static struct list_node_st * find_(LLIST *ptr, const void *key, llist_cmp *cmp)
{struct llist_node_st *cur;for(cur = ptr->head.next;cur!=ptr.head;cur=cur->next){if(cmp(key,cur->data) == 0)break;}return cur;
}void *llist_find(LLIST *ptr, const void *key, llist_cmp *cmp)
{struct llist_node_st *node;node = find_(ptr,key,cmp);if(node == &ptr->head))return NULL;return node->data;
}
int llist_delete(LLIST *ptr,const void *key,llist_cmp *cmp)
{	struct llist_node_st *node;node = nodefind_(ptr,key,cmp);if(node == &ptr->head)return -1;node->prev->next = node->next;node->next->prev = node->prev;free(node);return 0;
}
int llist_fetch(LLIST *ptr,const void *key,llist_cmp *cmp,void *data)
{struct llist_node_st *node;node = nodefind_(ptr,key,cmp);if(node == &ptr->head)return -1;node->prev->next = node->next;node->next->prev = node->prev;if(data!=NULL)memcpy(data,node->data,ptr->size);free(node);return 0;
}
void llist_travel(LLIST *ptr,llist_op *op)//需要一个回调函数，需要用户给我传一个函数
{struct llist_node_st *cur;for(cur = ptr->head.next;cur!=&ptr->head;cur=cur->next)//为了封装成更通用的函数，不知道用户的结构类型，因此需要回调函数，且需要在 .h文件中使用 void 函数声明，且使用typedef重命名 看起来更好一些op(cur->data);//借用户之手，把他知道的数据类型打印了出来  具有通用性}
void llist_destroy(LLIST *ptr)
{struct llist node_st *cur,*next;for(cur= ptr->head.next;cur != &ptr->head;cur= next){next = cur->next;free(cur);}free(ptr);
}

stack.h

#ifndef STACK_H__
#define STACK_H__
#include"llish.h"typedef LLIST STACK;
STACK *stack_create(int);
int stack_push(STACK *,const void data);
int stack_pop(STACK *, void *data);void stack_destory(STACK *);#endif

stack.c

#include<stdio.h>
#include<stdlib.h>#include"stack.h"STACK *stack_create(int initsize)
{return llist_create(initsize);
}int stack_push(STACK *ptr,const void data)
{return llist_insert(ptr,data,LLIST_FORWARD);
}static int alaways_match(const void *p1,const void *p2)
{return 0;
}int stack_pop(STACK *ptr, void *data)
{return  llist_fetch(ptr,(void *)0,always_match,data);//(void *)0
}void stack_destory(STACK *ptr)
{llist_destory(ptr);
}

main.c

#include<stdio.h>
#include<stdlib.h>
#include"stack.h"//此时不要包含llish.h 底层库与二次封装库的区别
#define NAMESIZE	32
struct score_st
{int id;char name[NAMESIZE];int math;int chinese;
};
static void print_s(void *record)
{struct score_st *r = record;printf("%d %s %d %d\n",r->id,r->name,r->math,r->chinese);
}
int main()
{STACK *st;int i,ret;struct score_st tmp;st = stack_create(sizeof(struct score_st));if(st ==NULL)exit(1);for(i =0;i<7;i++){tmp.id = i;snprintf(tmp.name,NAMESIZE,"stu%d",i);tmp.math = rand()%100;tmp.chinese = rand()%100;if(stack_push(st,&tmp))exit(1);}while(){ret = stack_pop(st,&tmp);if(ret == -1)break;print_s(&tmp);}stack_destory(st);exit(0);
}

Makefile

all:stack
stack:stack.o main.o llist.o$(CC) $^ -o $@
clean:rm stack *.o -rf