C语言栈模板

头文件

#ifndef __STACK_H__
#define __STACK_H__

typedef struct stack_node 
{
    struct stack_node *next;
    struct stack_node *prev;
} stackNode;

#define STACK_HEAD_INIT(name) { &(name), &(name) }

#define STACK_HEAD(name) \
    struct stack_node name = STACK_HEAD_INIT(name)

static inline int stack_empty(const struct stack_node *head)
{
    return ((head->next == head) && (head->prev == head));
}

static inline void stack_append(struct stack_node *new_node, struct stack_node *existing)
{
    existing->next->prev = new_node;
    new_node->next = existing->next;
    new_node->prev = existing;
    existing->next = new_node;
}

static inline void stack_unlink(struct stack_node *entry)
{
    entry->next->prev = entry->prev;
    entry->prev->next = entry->next;
    entry->next = 0;
    entry->prev = 0;
}

#undef offsetof
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)

#define container_of(ptr, type, member) ({            \
        const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
        (type *)( (char *)__mptr - offsetof(type,member) );})

#define stack_entry(ptr, type, member) \
    container_of(ptr, type, member)

#define stack_for_each_entry(pos, head, member)                \
    for (pos = stack_entry((head)->next, typeof(*pos), member);    \
        &pos->member != (head);                     \
        pos = stack_entry(pos->member.next, typeof(*pos), member))

#define stack_push(new_node, existing)    \
    stack_append(new_node, existing)    

#define stack_pop(pos, head, member)                            \
    if(!stack_empty(head))                                        \
    {                                                            \
        pos = stack_entry((head)->next, typeof(*pos), member);    \
        stack_unlink((struct stack_node *)pos);                    \
    }                                                            \
    else                                                        \
    {                                                            \
        pos = NULL;                                                \
    }

#define stack_top(pos, head, member)                            \
    if(!stack_empty(head))                                        \
    {                                                            \
        pos = stack_entry((head)->next, typeof(*pos), member);    \
    }                                                            \
    else                                                        \
    {                                                            \
        pos = NULL;                                                \
    }

#endif

 

 

应用实例

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

struct myLinkList{
    struct stack_node stack;
    int to;
};

STACK_HEAD(glbList);

int main(int argc, char **argv){

    int i =0;
    struct myLinkList *tmp1, *tmp2, *p;

    tmp1 = (struct myLinkList *)malloc(sizeof(struct myLinkList));
    tmp1->to = 5;
    stack_push((struct stack_node *)tmp1, &glbList);

    tmp2 = (struct myLinkList *)malloc(sizeof(struct myLinkList));
    tmp2->to = 4;
    stack_push((struct stack_node *)tmp2, &glbList);
    
    stack_for_each_entry(p, &glbList,stack)
    {
        printf("%d\n",p->to);
    }

    stack_top(p, &glbList, stack);
    printf("%d\n", p->to);

    stack_pop(p, &glbList, stack);
    printf("%d\n",p->to);
    free(p);

    stack_pop(p, &glbList, stack);
    printf("%d\n",p->to);
    free(p);

    stack_pop(p, &glbList, stack);
    if(p == NULL)
    {
        printf("null\n");
    }
    return 0;
}